it-swarm.com.de

Drucken Sie Barcodes von der Webseite zum Zebra-Drucker

Wir versuchen, Barcodes von einer Webseite auf unseren Zebra-Drucker zu drucken.

Ich frage mich, ob es eine Möglichkeit gibt, sie unter Verwendung der eigenen Schriftart des Druckers zu drucken, möglicherweise unter Verwendung von Webschriftarten, oder ob ich den verwendeten Schriftartnamen kenne?

Ich habe versucht, PHP-Barcode-Generatoren zu verwenden, die im Grunde Bilder erzeugen, die den Barcode enthalten. In der Tat habe ich diesen Ansatz bereits seit einigen Tagen ohne Erfolg versucht.

Das Problem ist, wenn ich sie drucke, kann sie von den Scannern nicht gelesen werden. Ich habe versucht, die Bildauflösung an die des Druckers anzupassen (203 dpi), und habe auch versucht, mit der Bildgröße und den Formaten zu spielen, aber die Barcodes nach dem Drucken können noch nicht gescannt werden.

Hat also jemand Erfahrung damit?

Drucker: Zebra TLP 2844

Barcodes pro Seite erforderlich:

  • 01 Code39 horizontal (kann nur gescannt werden, wenn in einer bestimmten Größe und in einem bestimmten Browser gedruckt wird)
  • 01 Code128 vertikal (kann immer noch nicht funktionieren, Druck ist immer sehr verschwommen und wird nicht gescannt)

===========

Ich habe ein bisschen Fortschritte gemacht. Ich habe herausgefunden, dass dieser Drucker die EPL2-Sprache unterstützt. Ich versuche also, die Barcodes auszudrucken.

Zuerst musste ich den Durchleitungsmodus aktivieren. Dies habe ich unter Druckeroptionen> Erweiterte Einstellungen> Verschiedene getan.

Jetzt kann ich mit der integrierten Schriftart des Druckers einwandfrei Barcodes drucken: D mit diesem Befehl:

ZPL: B10,10,0,1,2,2,60, N, "TEXT-GOES-HERE" : ZPL

Aber ich kann es nur aus dem Notepad drucken, ich kann es immer noch nicht aus einem Browser heraus drucken ... Es ist wahrscheinlich ein Problem, wenn LF durch CR + LF ersetzt wird.

Wie kann dieses Problem überwunden werden?

===========

Das Etikett, das ich zu drucken versuche, enthält ein wenig Text vor dem Barcode. Einige HTML-Tabellen formatieren ihn gut. Ich muss dieses also zuerst drucken, und in der Mitte muss ich ein Nice-Label einfügen und dann etwas mehr Text hinzufügen.

Ich kann also nicht mit reinem EPL2 das Ganze drucken, ich frage mich, ob ich etwas von beiden HTML + EPL2 + HTML verwenden kann, um mein Ziel zu erreichen, oder ist das nicht erlaubt? = /

29
user1447134

Sie stoßen auf einige Hindernisse:

1) Wenn Sie über den vom Betriebssystem installierten Druckertreiber drucken, versucht der Druckertreiber, die an ihn gesendeten Daten zu übernehmen und für das Ausgabegerät (den Zebra-Drucker) zu rastern oder zu skalieren. Da der Drucker mit 203 dpi eine relativ niedrige Auflösung hat, ist für die Skalierung, die der Druckertreiber durchführen muss, nicht zu viel Druck erforderlich, um die Integrität der Qualität des Barcodes zu verlieren. Aus diesem Grund sind mit den direkten ZPL-Befehlen generierte Barcodes viel zuverlässiger. 

2) Aufgrund der Sicherheit, die Webbrowser absichtlich bieten, indem sie keinen Zugriff auf den Clientcomputer zulassen, können Sie nicht direkt mit dem an den Client angeschlossenen Drucker kommunizieren. Dieses Sandboxing hilft Benutzern dabei, sich vor Malware zu schützen, sodass schädliche Websites beispielsweise keine Dateien auf den Client-Computer schreiben oder die Ausgabe direkt an Geräte wie Drucker senden können. Daher können Sie die ZPL-Befehle nicht direkt über den Browser an den mit dem Client verbundenen Drucker senden. 

Es gibt jedoch eine Möglichkeit, das zu tun, was Sie beschreiben. Die erforderlichen Schritte sind in der Regel nur dann von Nutzen, wenn Sie über den Clientcomputer, der auf die Site zugreift, die auf den Zebra-Druckern drucken möchte, ein gewisses Maß an Kontrolle haben. Zum Beispiel wird dies nur von Computern in Ihrem Firmennetzwerk verwendet oder von Kunden, die eine kleine Anwendung installieren möchten, die Sie schreiben müssen. Dazu müssen Sie die folgenden Schritte beachten:

A) Sie müssen Ihren eigenen benutzerdefinierten MIME-Typ erstellen. Dies ist im Grunde nur ein Name, den Sie verwenden möchten und der nicht mit den registrierten MIME-Typen kollidiert. 

B) Als Nächstes definieren Sie eine Dateinamenerweiterung, die Ihrem benutzerdefinierten MIME-Typ zugeordnet wird. Dazu müssen Sie normalerweise Ihren Webserver konfigurieren (die Schritte hängen davon ab, welchen Webserver Sie verwenden), damit der neue MIME-Typ, den Sie definieren möchten, zugelassen wird und welche Dateierweiterung für diese Dateitypen verwendet wird.

C) Wenn Sie dann in Ihrer Webanwendung die ZPL-Daten ausgeben möchten, schreiben Sie sie mit einer Dateinamenerweiterung, die Ihrem neuen MIME-Typ zugeordnet ist, in eine Datei. Sobald die Datei generiert wurde, können Sie entweder einen HTML-Link angeben oder den Clientbrowser auf die Datei umleiten. Sie können testen, ob Ihre Datei zu diesem Zeitpunkt ordnungsgemäß funktioniert, indem Sie die erstellte Datei manuell direkt an den Raw-Druckerport kopieren. 

D) Als Nächstes müssen Sie eine kleine Anwendung schreiben, die auf dem Client installiert werden kann. Wenn die Anwendung installiert ist, muss sie sich selbst als gültige konsumierende Anwendung für Ihren benutzerdefinierten MIME-Typ registrieren. Wenn ein Browser feststellt, dass für eine Datei des angegebenen MIME-Typs eine Anwendung installiert ist, schreibt er die Datei einfach in ein temporäres Verzeichnis auf dem Client-Computer und versucht dann, die Anwendung des gleichen registrierten MIME-Typs mit der temporären Datei als zu starten ein Parameter für die Anwendung. Ihre Anwendung liest also nur die Datei, die der Browser an sie übergeben hat, und versucht dann, sie direkt auf dem Drucker abzulegen. 

Dies ist eine Übersicht, was Sie tun müssen, um das zu erreichen, was Sie beschreiben. Einige der spezifischen Schritte hängen davon ab, welche Art von Webserver Sie verwenden und in welchem ​​Betriebssystem sich Ihre Client-Computer befinden. Dies ist jedoch der Überblick auf hoher Ebene, mit dem Sie erreichen können, was Sie versuchen.

19
dmarietta

Wenn Sie ein Java-Applet laden möchten, kann qz-print (zuvor Jzebra) genau das tun, was Sie beschreiben, und es funktioniert gut mit dem in den Kommentaren erwähnten LP2844.

https://code.google.com/p/jzebra/

8

Was wir für unsere Web-App gemacht haben:

1) Laden Sie die kostenlose Printfile-App http://www.lerup.com/printfile/ herunter. 

"PrintFile ist ein Freeware-MS Windows-Hilfsprogramm, mit dem Sie Dateien schnell und einfach drucken können. Das Programm erkennt Klartext, PostScript, Encapsulated PostScript (EPS) und Binärformate. Mit diesem Programm können Sie viel Papier sparen und damit auch Einsparung wertvoller natürlicher Ressourcen. "

Wenn Sie PrintFile zum ersten Mal ausführen, gehen Sie in die erweiterten Optionen und aktivieren Sie "Direkt an Drucker senden".

2) Richten Sie den ZEBRA-Drucker in Windows als generischer Textdrucker ein.

2) Erzeugen Sie in der Web-App eine file.prt -Datei, bei der es sich lediglich um eine reine EPL-Datei handelt.

3) Durch Doppelklicken auf die heruntergeladene Datei wird der Barcode sofort gedruckt. Klappt wunderbar. Sie können PrintFile sogar so einrichten, dass Sie nicht einmal eine GUI sehen.

4
cmrichards

Ich entwickle hier etwas ähnliches ... Ich muss in einer LP2844 von meiner Webapp aus drucken. Das Problem ist, dass sich meine Webapp auf einem Remote-Server in der Cloud (Amazon EC2) befindet und der Drucker sich in einem Warehouse-Desk befindet.

Meine Lösung: Die webapp generiert den EPL2-Code für das Etikett mit den Barcodes, veröffentlicht dann eine PubNub-Nachricht . Ich habe ein kleines C # -Programm geschrieben, das auf dem Computer läuft, an dem der Drucker angeschlossen ist. Das Programm empfängt die Nachricht und sendet den Code an den Drucker.

3
Mario Campa

Sie können die ZPL-Befehle auch in einer Textdatei senden (Sie können mehrere Etiketten in eine einzige Datei packen) und den Benutzer über Windows Notepad öffnen und drucken lassen. Der einzige Nachteil ist, dass sie die Standardkopf- und -fußzeile (Datei -> Seiteneinrichtung) entfernen müssen.

Es ist ein bisschen Benutzerschulung, kann aber akzeptabel sein, wenn Sie die Client-Maschinen nicht kontrollieren können. 

2
StingyJack

Ich folgte der von "Tres Finocchiaro" vorgeschlagenen Idee in meiner Bewerbung, basierend auf:

  1. ASP.NET 4.0 
  2. IIS
  3. Chrome, IExplorer, Firefox
  4. Zebra TLP 2844
  5. EPL-Protokollo

Leider benötigt der jzebra einige Verbesserungen, um korrekt arbeiten zu können, und zwar aufgrund der Sicherheitsprobleme des aktuellen Browsers. 

Jzebra installieren

Laden Sie jzebdra herunter und kopieren Sie aus dem dist-Verzeichnis in Ihr Verzeichnis (zB mydir):

  • netz
    • mydir
      • js
        • ..
        • deployJava.js
      • lib
        • ..
      • qz-print.jar
      • qz-print_jnlp.jnlp 

Erstellen Sie Ihre print.html

<html>
<script type="text/javascript" src="js/deployJava.js"></script>
<script type="text/javascript">
    /**
    * Optionally used to deploy multiple versions of the applet for mixed
    * environments.  Oracle uses document.write(), which puts the applet at the
    * top of the page, bumping all HTML content down.
    */
    deployQZ();

    /** NEW FUNCTION **/
    function initPrinter() {
        findPrinters();
        useDefaultPrinter();
    }

    /** NEW FUNCTION **/    
    function myalert(txt) {
        alert(txt);
    }


    /**
    * Deploys different versions of the applet depending on Java version.
    * Useful for removing warning dialogs for Java 6.  This function is optional
    * however, if used, should replace the <applet> method.  Needed to address 
    * MANIFEST.MF TrustedLibrary=true discrepency between JRE6 and JRE7.
    */
    function deployQZ() {
        var attributes = {id: "qz", code:'qz.PrintApplet.class', 
            archive:'qz-print.jar', width:1, height:1};
        var parameters = {jnlp_href: 'qz-print_jnlp.jnlp', 
            cache_option:'plugin', disable_logging:'false', 
            initial_focus:'false'};
        if (deployJava.versionCheck("1.7+") == true) {}
        else if (deployJava.versionCheck("1.6+") == true) {
            delete parameters['jnlp_href'];
        }
        deployJava.runApplet(attributes, parameters, '1.5');
    }

    /**
    * Automatically gets called when applet has loaded.
    */
    function qzReady() {
        // Setup our global qz object
        window["qz"] = document.getElementById('qz');
        var title = document.getElementById("title");
        if (qz) {
            try {
                title.innerHTML = title.innerHTML + " " + qz.getVersion();
                document.getElementById("content").style.background = "#F0F0F0";
            } catch(err) { // LiveConnect error, display a detailed meesage
                document.getElementById("content").style.background = "#F5A9A9";
                alert("ERROR:  \nThe applet did not load correctly.  Communication to the " + 
                    "applet has failed, likely caused by Java Security Settings.  \n\n" + 
                    "CAUSE:  \nJava 7 update 25 and higher block LiveConnect calls " + 
                    "once Oracle has marked that version as outdated, which " + 
                    "is likely the cause.  \n\nSOLUTION:  \n  1. Update Java to the latest " + 
                    "Java version \n          (or)\n  2. Lower the security " + 
                    "settings from the Java Control Panel.");
          }
      }
    }

    /**
    * Returns whether or not the applet is not ready to print.
    * Displays an alert if not ready.
    */
    function notReady() {
        // If applet is not loaded, display an error
        if (!isLoaded()) {
            return true;
        }
        // If a printer hasn't been selected, display a message.
        else if (!qz.getPrinter()) {
           /** CALL TO NEW FUNCTION **/
            initPrinter();
            return false;
        }
        return false;
    }

    /**
    * Returns is the applet is not loaded properly
    */
    function isLoaded() {
        if (!qz) {
            alert('Error:\n\n\tPrint plugin is NOT loaded!');
            return false;
        } else {
            try {
                if (!qz.isActive()) {
                    alert('Error:\n\n\tPrint plugin is loaded but NOT active!');
                    return false;
                }
            } catch (err) {
                alert('Error:\n\n\tPrint plugin is NOT loaded properly!');
                return false;
            }
        }
        return true;
    }

    /**
    * Automatically gets called when "qz.print()" is finished.
    */
    function qzDonePrinting() {
        // Alert error, if any
        if (qz.getException()) {
            alert('Error printing:\n\n\t' + qz.getException().getLocalizedMessage());
            qz.clearException();
            return; 
        }

        // Alert success message
        alert('Successfully sent print data to "' + qz.getPrinter() + '" queue.');
    }

    /***************************************************************************
    * Prototype function for finding the "default printer" on the system
    * Usage:
    *    qz.findPrinter();
    *    window['qzDoneFinding'] = function() { alert(qz.getPrinter()); };
    ***************************************************************************/
    function useDefaultPrinter() {
        if (isLoaded()) {
            // Searches for default printer
            qz.findPrinter();

            // Automatically gets called when "qz.findPrinter()" is finished.
            window['qzDoneFinding'] = function() {
                // Alert the printer name to user
                var printer = qz.getPrinter();
                myalert(printer !== null ? 'Default printer found: "' + printer + '"':
                    'Default printer ' + 'not found');

                // Remove reference to this function
                window['qzDoneFinding'] = null;
            };
        }
    }

    /***************************************************************************
    * Prototype function for finding the closest match to a printer name.
    * Usage:
    *    qz.findPrinter('zebra');
    *    window['qzDoneFinding'] = function() { alert(qz.getPrinter()); };
    ***************************************************************************/
    function findPrinter(name) {
        // Get printer name from input box
        var p = document.getElementById('printer');
        if (name) {
            p.value = name;
        }

        if (isLoaded()) {
            // Searches for locally installed printer with specified name
            qz.findPrinter(p.value);

            // Automatically gets called when "qz.findPrinter()" is finished.
            window['qzDoneFinding'] = function() {
                var p = document.getElementById('printer');
                var printer = qz.getPrinter();

                // Alert the printer name to user
                alert(printer !== null ? 'Printer found: "' + printer + 
                    '" after searching for "' + p.value + '"' : 'Printer "' + 
                    p.value + '" not found.');

                // Remove reference to this function
                window['qzDoneFinding'] = null;
            };
        }
    }

    /***************************************************************************
    * Prototype function for listing all printers attached to the system
    * Usage:
    *    qz.findPrinter('\\{dummy_text\\}');
    *    window['qzDoneFinding'] = function() { alert(qz.getPrinters()); };
    ***************************************************************************/
    function findPrinters() {
        if (isLoaded()) {
            // Searches for a locally installed printer with a bogus name
            qz.findPrinter('\\{bogus_printer\\}');

            // Automatically gets called when "qz.findPrinter()" is finished.
            window['qzDoneFinding'] = function() {
                // Get the CSV listing of attached printers
                var printers = qz.getPrinters().split(',');
                for (i in printers) {
                    myalert(printers[i] ? printers[i] : 'Unknown');      
                }

                // Remove reference to this function
                window['qzDoneFinding'] = null;
            };
        }
    }

    /***************************************************************************
    * Prototype function for printing raw EPL commands
    * Usage:
    *    qz.append('\nN\nA50,50,0,5,1,1,N,"Hello World!"\n');
    *    qz.print();
    ***************************************************************************/
    function print() {
        if (notReady()) { return; }

        // Send characters/raw commands to qz using "append"
        // This example is for EPL.  Please adapt to your printer language
        // Hint:  Carriage Return = \r, New Line = \n, Escape Double Quotes= \"
        qz.append('\nN\n');            
        qz.append('q609\n');
        qz.append('Q203,26\n');
        qz.append('B5,26,0,1A,3,7,152,B,"1234"\n');
        qz.append('A310,26,0,3,1,1,N,"SKU 00000 MFG 0000"\n');
        qz.append('A310,56,0,3,1,1,N,"QZ PRINT APPLET"\n');
        qz.append('A310,86,0,3,1,1,N,"TEST PRINT SUCCESSFUL"\n');
        qz.append('A310,116,0,3,1,1,N,"FROM SAMPLE.HTML"\n');
        qz.append('A310,146,0,3,1,1,N,"QZINDUSTRIES.COM"');

        // Append the rest of our commands
        qz.append('\nP1,1\n');

        // Tell the applet to print.
        qz.print();
     }

    /***************************************************************************
    * Prototype function for logging a PostScript printer's capabilites to the
    * Java console to expose potentially  new applet features/enhancements. 
    * Warning, this has been known to trigger some PC firewalls
    * when it scans ports for certain printer capabilities.
    * Usage: (identical to appendImage(), but uses html2canvas for png rendering)
    *    qz.setLogPostScriptFeatures(true);
    *    qz.appendHTML("<h1>Hello world!</h1>");
    *    qz.printPS();
    ***************************************************************************/ 
    function logFeatures() {
        if (isLoaded()) {
            var logging = qz.getLogPostScriptFeatures();
            qz.setLogPostScriptFeatures(!logging);
            alert('Logging of PostScript printer capabilities to console set to "' + !logging + '"');
        }
    }

    /***************************************************************************
    ****************************************************************************
    * *                          HELPER FUNCTIONS                             **
    ****************************************************************************
    ***************************************************************************/

    function getPath() {
        var path = window.location.href;
        return path.substring(0, path.lastIndexOf("/")) + "/";
    }

    /**
    * Fixes some html formatting for printing. Only use on text, not on tags!
    * Very important!
    *   1.  HTML ignores white spaces, this fixes that
    *   2.  The right quotation mark breaks PostScript print formatting
    *   3.  The hyphen/dash autoflows and breaks formatting  
    */
    function fixHTML(html) {
        return html.replace(/ /g, "&nbsp;").replace(/’/g, "'").replace(/-/g,"&#8209;"); 
    }

    /**
    * Equivelant of VisualBasic CHR() function
    */
    function chr(i) {
        return String.fromCharCode(i);
    }

    /***************************************************************************
    * Prototype function for allowing the applet to run multiple instances.
    * IE and Firefox may benefit from this setting if using heavy AJAX to
    * rewrite the page.  Use with care;
    * Usage:
    *    qz.allowMultipleInstances(true);
    ***************************************************************************/ 
    function allowMultiple() {
      if (isLoaded()) {
        var multiple = qz.getAllowMultipleInstances();
        qz.allowMultipleInstances(!multiple);
        alert('Allowing of multiple applet instances set to "' + !multiple + '"');
      }
    }
</script>

    <input type="button" onClick="print()" />
    </body>
</html>

der bereitgestellte Code basiert auf "jzebra_installation/dist/sample.html".

2
venergiac

Ich verwende QZ Tray , um Etiketten von einer Webseite auf den Thermodrucker von Zebra zu drucken.

Im Ordner demo/js von QZ Tray befinden sich drei JavaScript-Dateien, die für die Kommunikation mit der QZ Tray-Anwendung erforderlich sind: dependencies/rsvp-3.1.0.min.js, dependencies/sha-256.min.js und qz-tray.js

Fügen Sie diese JavaScript-Dateien wie folgt in Ihr Projekt ein:

<script type="text/javascript" src="/lib/qz-tray/rsvp-3.1.0.min.js"></script>
<script type="text/javascript" src="/lib/qz-tray/sha-256.min.js"></script>
<script type="text/javascript" src="/lib/qz-tray/qz-tray.js"></script>

Die einfachste Möglichkeit, ein Etikett auf einem Thermodrucker von Zebra zu drucken, wird unten gezeigt.

<script type="text/javascript">
qz.websocket.connect().then(function() {
   // Pass the printer name into the next Promise
   return qz.printers.find("zebra");
}).then(function(printer) {
   // Create a default config for the found printer
   var config = qz.configs.create(printer);

   // Raw ZPL
   var data = ['^XA^FO50,50^ADN,36,20^FDRAW ZPL EXAMPLE^FS^XZ'];

   return qz.print(config, data);
}).catch(function(e) { console.error(e); });
</script>

Weitere Informationen finden Sie unter So drucken Sie Etiketten von einer Webseite an den Zebra-Thermodrucker .

2
Gyrocode.com

erstellen Sie einen Websocket, der den Druck auf der Clientseite steuert, und senden Sie mit ajax Daten von der Seite an localhost.

/// websocket
using System;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;

namespace Server
{
    class Program
    {
        public static WebsocketServer ws;
        static void Main(string[] args)
        {
            ws = new Server.WebsocketServer();
            ws.LogMessage += Ws_LogMessage;
            ws.Start("http://localhost:2645/service/");
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }

        private static void Ws_LogMessage(object sender, WebsocketServer.LogMessageEventArgs e)
        {
            Console.WriteLine(e.Message);
        }
    }

    public class WebsocketServer
    {
        public event OnLogMessage LogMessage;
        public delegate void OnLogMessage(Object sender, LogMessageEventArgs e);
        public class LogMessageEventArgs : EventArgs
        {
            public string Message { get; set; }
            public LogMessageEventArgs(string Message)
            {
                this.Message = Message;
            }
        }

        public bool started = false;
        public async void Start(string httpListenerPrefix)
        {
            HttpListener httpListener = new HttpListener();
            httpListener.Prefixes.Add(httpListenerPrefix);
            httpListener.Start();
            LogMessage(this, new LogMessageEventArgs("Listening..."));
            started = true;

            while (started)
            {
                HttpListenerContext httpListenerContext = await httpListener.GetContextAsync();
                if (httpListenerContext.Request.IsWebSocketRequest)
                {
                    ProcessRequest(httpListenerContext);
                }
                else
                {
                    httpListenerContext.Response.StatusCode = 400;
                    httpListenerContext.Response.Close();
                    LogMessage(this, new LogMessageEventArgs("Closed..."));
                }
            }
        }

        public void Stop()
        {
            started = false;
        }
        private async void ProcessRequest(HttpListenerContext httpListenerContext)
        {
            WebSocketContext webSocketContext = null;

            try
            {
                webSocketContext = await httpListenerContext.AcceptWebSocketAsync(subProtocol: null);
                LogMessage(this, new LogMessageEventArgs("Connected"));
            }
            catch (Exception e)
            {
                httpListenerContext.Response.StatusCode = 500;
                httpListenerContext.Response.Close();
                LogMessage(this, new LogMessageEventArgs(String.Format("Exception: {0}", e)));
                return;
            }

            WebSocket webSocket = webSocketContext.WebSocket;
            try
            {


                while (webSocket.State == WebSocketState.Open)
                {

                    ArraySegment<Byte> buffer = new ArraySegment<byte>(new Byte[8192]);

                    WebSocketReceiveResult result = null;

                    using (var ms = new System.IO.MemoryStream())
                    {
                        do
                        {
                            result = await webSocket.ReceiveAsync(buffer, CancellationToken.None);
                            ms.Write(buffer.Array, buffer.Offset, result.Count);
                        }
                        while (!result.EndOfMessage);

                        ms.Seek(0, System.IO.SeekOrigin.Begin);

                        if (result.MessageType == WebSocketMessageType.Text)
                        {
                            using (var reader = new System.IO.StreamReader(ms, Encoding.UTF8))
                            {
                                var r = System.Text.Encoding.UTF8.GetString(ms.ToArray());
                                var t = Newtonsoft.Json.JsonConvert.DeserializeObject<Datos>(r);
                                bool valid = true;
                                byte[] toBytes = Encoding.UTF8.GetBytes(""); ;

                                if (t != null)
                                {
                                    if (t.printer.Trim() == string.Empty)
                                    {
                                        var printers = "";
                                        foreach (var imp in System.Drawing.Printing.PrinterSettings.InstalledPrinters)
                                        {
                                            printers += imp + "\n";
                                        }

                                        toBytes = Encoding.UTF8.GetBytes("No se Indicó la Impresora\nLas Impresoras disponibles son: " + printers);
                                        valid = false;
                                    }
                                    if (t.name.Trim() == string.Empty)
                                    {
                                        toBytes = Encoding.UTF8.GetBytes("No se Indicó el nombre del Documento");
                                        valid = false;
                                    }
                                    if (t.code == null)
                                    {
                                        toBytes = Encoding.UTF8.GetBytes("No hay datos para enviar a la Impresora");
                                        valid = false;
                                    }


                                    if (valid)
                                    {
                                        print.RawPrinter.SendStringToPrinter(t.printer, t.code, t.name);
                                        toBytes = Encoding.UTF8.GetBytes("Correcto...");
                                    }

                                    await webSocket.SendAsync(new ArraySegment<byte>(toBytes, 0, int.Parse(toBytes.Length.ToString())), WebSocketMessageType.Binary, result.EndOfMessage, CancellationToken.None);
                                }
                                else
                                {
                                    toBytes = Encoding.UTF8.GetBytes("Error...");
                                    await webSocket.SendAsync(new ArraySegment<byte>(toBytes, 0, int.Parse(toBytes.Length.ToString())), WebSocketMessageType.Binary, result.EndOfMessage, CancellationToken.None);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                LogMessage(this, new LogMessageEventArgs(String.Format("Exception: {0} \nLinea:{1}", e, e.StackTrace)));
            }
            finally
            {
                if (webSocket != null)
                    webSocket.Dispose();
            }
        }
    }

    public class Datos
    {
        public string name { get; set; }
        public string code { get; set; }
        public string printer { get; set; } = "";
    }
}

roher Druck:

using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.IO;

namespace print
{
    public class RawPrinter
    {
        // Structure and API declarions:
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        public class DOCINFOA
        {
            [MarshalAs(UnmanagedType.LPStr)]
            public string pDocName;
            [MarshalAs(UnmanagedType.LPStr)]
            public string pOutputFile;
            [MarshalAs(UnmanagedType.LPStr)]
            public string pDataType;
        }
        [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)]
string szPrinter, ref IntPtr hPriknter, IntPtr pd);

        [DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool ClosePrinter(IntPtr hPrinter);

        [DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In(), MarshalAs(UnmanagedType.LPStruct)]
DOCINFOA di);

        [DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool EndDocPrinter(IntPtr hPrinter);

        [DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool StartPagePrinter(IntPtr hPrinter);

        [DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool EndPagePrinter(IntPtr hPrinter);

        [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, ref Int32 dwWritten);

        // SendBytesToPrinter()
        // When the function is given a printer name and an unmanaged array
        // of bytes, the function sends those bytes to the print queue.
        // Returns true on success, false on failure.
        public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount, string DocName = "")
        {
            Int32 dwError = 0;
            Int32 dwWritten = 0;
            IntPtr hPrinter = new IntPtr(0);
            DOCINFOA di = new DOCINFOA();
            bool bSuccess = false;
            // Assume failure unless you specifically succeed.
            di.pDocName = string.IsNullOrEmpty(DocName) ? "My C#.NET RAW Document" : DocName;
            di.pDataType = "RAW";

            // Open the printer.
            if (OpenPrinter(szPrinterName.Normalize(), ref hPrinter, IntPtr.Zero))
            {
                // Start a document.
                if (StartDocPrinter(hPrinter, 1, di))
                {
                    // Start a page.
                    if (StartPagePrinter(hPrinter))
                    {
                        // Write your bytes.
                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount, ref dwWritten);
                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            // If you did not succeed, GetLastError may give more information
            // about why not.
            if (bSuccess == false)
            {
                dwError = Marshal.GetLastWin32Error();
            }
            return bSuccess;
        }

        public static bool SendFileToPrinter(string szPrinterName, string szFileName)
        {
            // Open the file.
            FileStream fs = new FileStream(szFileName, FileMode.Open);
            // Create a BinaryReader on the file.
            BinaryReader br = new BinaryReader(fs);
            // Dim an array of bytes big enough to hold the file's contents.
            Byte[] bytes = new Byte[fs.Length];
            bool bSuccess = false;
            // Your unmanaged pointer.
            IntPtr pUnmanagedBytes = new IntPtr(0);
            int nLength = 0;

            nLength = Convert.ToInt32(fs.Length);
            // Read the contents of the file into the array.
            bytes = br.ReadBytes(nLength);
            // Allocate some unmanaged memory for those bytes.
            pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
            // Copy the managed byte array into the unmanaged array.
            Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
            // Send the unmanaged bytes to the printer.
            bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
            // Free the unmanaged memory that you allocated earlier.
            Marshal.FreeCoTaskMem(pUnmanagedBytes);
            return bSuccess;
        }
        public static bool SendStringToPrinter(string szPrinterName, string szString, string DocName = "")
        {
            IntPtr pBytes = default(IntPtr);
            Int32 dwCount = default(Int32);
            // How many characters are in the string?
            dwCount = szString.Length;
            // Assume that the printer is expecting ANSI text, and then convert
            // the string to ANSI text.
            pBytes = Marshal.StringToCoTaskMemAnsi(szString);
            // Send the converted ANSI string to the printer.
            SendBytesToPrinter(szPrinterName, pBytes, dwCount, DocName);
            Marshal.FreeCoTaskMem(pBytes);
            return true;
        }
    }
}

hTML-Seite:

<!DOCTYPE html>
<html>

<head>
</head>

<body ng-app="myapp">

    <div ng-controller="try as ctl">
        <input ng-model="ctl.ticket.nombre">

        <textarea ng-model="ctl.ticket.code"></textarea>

        <button ng-click="ctl.send()">Enviar</button>
    </div>


    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.6/angular.min.js"></script>
    <script>
        var ws = new WebSocket("ws://localhost:2645/service");
        ws.binaryType = "arraybuffer";
        ws.onopen = function () {
            console.log('connection is opened!!!');
        };

        ws.onmessage = function (evt) {
            console.log(arrayBufferToString(evt.data))

        };

        ws.onclose = function () {
            console.log("Connection is Closed...")
        };

        function arrayBufferToString(buffer) {
            var arr = new Uint8Array(buffer);
            var str = String.fromCharCode.apply(String, arr); 

           return  decodeURIComponent(escape(str));
        }
        var app = angular.module('myapp', []);
        app.controller('try', function () {
            this.ticket= {nombre:'', estado:''}

            this.send = () => {
                var toSend= JSON.stringify(this.ticket);
                ws.send(toSend);
            }
        });
    </script>
</body>

</html>

senden Sie dann einen ZPL-Code aus HTML (schreiben Sie diesen in Textfeld-Code).

^XA
^FO200,50^BY2^B3N,N,80,Y,N^FD0123456789^FS
^PQ1^XZ
0
henoc salinas