Create a package for the printer

brother-info/main.go

@@ -1,10 +1,9 @@
 package main
 
 import (
-	"io"
 	"log"
-	"os"
-	"time"
+
+	"janouch.name/sklad/ql"
 )
 
 func decodeBitfieldErrors(b byte, errors [8]string) []string {
@@ -19,25 +18,6 @@ func decodeBitfieldErrors(b byte, errors [8]string) []string {
 
 // -----------------------------------------------------------------------------
 
-type brotherStatus struct {
-	errors []string
-}
-
-// TODO: What exactly do we need? Probably extend as needed.
-func decodeStatusInformation(d []byte) brotherStatus {
-	var status brotherStatus
-	status.errors = append(status.errors, decodeBitfieldErrors(d[8], [8]string{
-		"no media", "end of media", "cutter jam", "?", "printer in use",
-		"printer turned off", "high-voltage adapter", "fan motor error"})...)
-	status.errors = append(status.errors, decodeBitfieldErrors(d[9], [8]string{
-		"replace media", "expansion buffer full", "communication error",
-		"communication buffer full", "cover open", "cancel key",
-		"media cannot be fed", "system error"})...)
-	return status
-}
-
-// -----------------------------------------------------------------------------
-
 func printStatusInformation(d []byte) {
 	if d[0] != 0x80 || d[1] != 0x20 || d[2] != 0x42 || d[3] != 0x34 {
 		log.Println("unexpected status fixed bytes")
@@ -157,51 +137,23 @@ func printStatusInformation(d []byte) {
 }
 
 func main() {
-	// Linux usblp module, located in /drivers/usb/class/usblp.c
-	// (at least that's where the trails go, I don't understand the code)
-	f, err := os.OpenFile("/dev/usb/lp0", os.O_RDWR, 0)
+	printer, err := ql.Open()
 	if err != nil {
 		log.Fatalln(err)
 	}
-	defer f.Close()
-
-	// Flush any former responses in the printer's queue.
-	for {
-		dummy := make([]byte, 32)
-		if _, err := f.Read(dummy); err == io.EOF {
-			break
-		}
+	if printer == nil {
+		log.Fatalln("no suitable printer found")
 	}
+	defer printer.Close()
 
-	// Clear the print buffer.
-	invalidate := make([]byte, 400)
-	if _, err := f.Write(invalidate); err != nil {
+	if err := printer.Initialize(); err != nil {
 		log.Fatalln(err)
 	}
 
-	// Initialize.
-	if _, err := f.WriteString("\x1b\x40"); err != nil {
+	status, err := printer.GetStatus()
+	if err != nil {
 		log.Fatalln(err)
 	}
 
-	// Request status information.
-	if _, err := f.WriteString("\x1b\x69\x53"); err != nil {
-		log.Fatalln(err)
-	}
-
-	// We need to poll the device.
-	status := make([]byte, 32)
-	for {
-		if n, err := f.Read(status); err == io.EOF {
-			time.Sleep(10 * time.Millisecond)
-		} else if err != nil {
-			log.Fatalln(err)
-		} else if n < 32 {
-			log.Fatalln("invalid read")
-		} else {
-			break
-		}
-	}
-
 	printStatusInformation(status)
 }

label-exp/main.go

@@ -18,6 +18,7 @@ import (
 	"github.com/boombuler/barcode/qr"
 
 	"janouch.name/sklad/bdf"
+	"janouch.name/sklad/ql"
 )
 
 // scaler is a scaling image.Image wrapper.
@@ -233,55 +234,28 @@ func printLabel(src image.Image) error {
 
 	// ---
 
-	// Linux usblp module, located in /drivers/usb/class/usblp.c
-	// (at least that's where the trails go, I don't understand the code)
-	f, err := os.OpenFile("/dev/usb/lp0", os.O_RDWR, 0)
+	printer, err := ql.Open()
 	if err != nil {
 		return err
 	}
-	defer f.Close()
-
-	// Flush any former responses in the printer's queue.
-	for {
-		dummy := make([]byte, 32)
-		if _, err := f.Read(dummy); err == io.EOF {
-			break
-		}
+	if printer == nil {
+		return errors.New("no suitable printer found")
 	}
+	defer printer.Close()
 
-	// Clear the print buffer.
-	invalidate := make([]byte, 400)
-	if _, err := f.Write(invalidate); err != nil {
+	if err := printer.Initialize(); err != nil {
 		return err
 	}
 
-	// Initialize.
-	if _, err := f.WriteString("\x1b\x40"); err != nil {
+	status, err := printer.GetStatus()
+	if err != nil {
 		return err
 	}
 
-	// Request status information.
-	if _, err := f.WriteString("\x1b\x69\x53"); err != nil {
-		return err
-	}
-
-	// We need to poll the device.
-	status := make([]byte, 32)
-	for {
-		if n, err := f.Read(status); err == io.EOF {
-			time.Sleep(10 * time.Millisecond)
-		} else if err != nil {
-			return err
-		} else if n < 32 {
-			return errors.New("invalid read")
-		} else {
-			break
-		}
-	}
 	printStatusInformation(status)
 
 	// Print the prepared data.
-	if _, err := f.Write(data); err != nil {
+	if _, err := printer.File.Write(data); err != nil {
 		return err
 	}
 
@@ -294,7 +268,7 @@ func printLabel(src image.Image) error {
 		if time.Now().Sub(start) > 3*time.Second {
 			break
 		}
-		if n, err := f.Read(status); err == io.EOF {
+		if n, err := printer.File.Read(status); err == io.EOF {
 			time.Sleep(100 * time.Millisecond)
 		} else if err != nil {
 			return err

ql/ql.go

@@ -0,0 +1,218 @@
+// Package ql is a Linux driver for Brother QL-series printers.
+package ql
+
+// Resources:
+//  http://www.undocprint.org/formats/page_description_languages/brother_p-touch
+
+import (
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// #include <linux/ioctl.h>
+import "C"
+
+// -----------------------------------------------------------------------------
+
+func _IOC(dir, typ, nr, size int) uintptr {
+	return (uintptr(dir) << C._IOC_DIRSHIFT) |
+		(uintptr(typ) << C._IOC_TYPESHIFT) |
+		(uintptr(nr) << C._IOC_NRSHIFT) |
+		(uintptr(size) << C._IOC_SIZESHIFT)
+}
+
+const (
+	iocnrGetDeviceID = 1
+)
+
+// lpiocGetDeviceID reads the IEEE-1284 Device ID string of a printer.
+func lpiocGetDeviceID(fd uintptr) ([]byte, error) {
+	var buf [1024]byte
+	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd,
+		_IOC(C._IOC_READ, 'P', iocnrGetDeviceID, len(buf)),
+		uintptr(unsafe.Pointer(&buf))); err != 0 {
+		return nil, err
+	}
+
+	// In theory it might get trimmed along the way.
+	length := int(buf[0])<<8 | int(buf[1])
+	if 2+length > len(buf) {
+		return buf[2:], errors.New("the device ID string got trimmed")
+	}
+
+	return buf[2 : 2+length], nil
+}
+
+// -----------------------------------------------------------------------------
+
+var deviceIDRegexp = regexp.MustCompile(
+	`(?s:\s*([^:,;]+?)\s*:\s*([^:;]*)\s*(?:;|$))`)
+
+type deviceID map[string][]string
+
+// parseIEEE1284DeviceID leniently parses an IEEE 1284 Device ID string
+// and returns a map containing a slice of values for each key.
+//
+// See e.g. http://www.undocprint.org/formats/communication_protocols/ieee_1284
+func parseIEEE1284DeviceID(id []byte) deviceID {
+	m := make(deviceID)
+	for _, kv := range deviceIDRegexp.FindAllStringSubmatch(string(id), -1) {
+		var values []string
+		for _, v := range strings.Split(kv[2], ",") {
+			values = append(values, strings.Trim(v, "\t\n\v\f\r "))
+		}
+		m[kv[1]] = values
+	}
+	return m
+}
+
+func (id deviceID) Find(key, abbreviation string) []string {
+	if values, ok := id[key]; ok {
+		return values
+	}
+	if values, ok := id[abbreviation]; ok {
+		return values
+	}
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+type Printer struct {
+	File *os.File
+}
+
+func compatible(id deviceID) bool {
+	for _, commandSet := range id.Find("COMMAND SET", "CMD") {
+		if commandSet == "PT-CBP" {
+			return true
+		}
+	}
+	return false
+}
+
+// Open finds and initializes the first USB printer found supporting
+// the appropriate protocol. Returns nil if no printer could be found.
+func Open() (*Printer, error) {
+	// Linux usblp module, located in /drivers/usb/class/usblp.c
+	paths, err := filepath.Glob("/dev/usb/lp[0-9]*")
+	if err != nil {
+		return nil, err
+	}
+	for _, candidate := range paths {
+		f, err := os.OpenFile(candidate, os.O_RDWR, 0)
+		if err != nil {
+			continue
+		}
+		// Filter out obvious non-printers.
+		deviceID, err := lpiocGetDeviceID(f.Fd())
+		if err != nil {
+			f.Close()
+			continue
+		}
+		// Filter out printers that wouldn't understand the protocol.
+		if !compatible(parseIEEE1284DeviceID(deviceID)) {
+			f.Close()
+			continue
+		}
+		return &Printer{File: f}, nil
+	}
+	return nil, nil
+}
+
+// Initialize initializes the printer for further operations.
+func (p *Printer) Initialize() error {
+	// Clear the print buffer.
+	invalidate := make([]byte, 400)
+	if _, err := p.File.Write(invalidate); err != nil {
+		return err
+	}
+
+	// Initialize.
+	if _, err := p.File.WriteString("\x1b\x40"); err != nil {
+		return err
+	}
+
+	// Flush any former responses in the printer's queue.
+	//
+	// I'm not sure if this is necessary, or rather whether the kernel driver
+	// does any buffering that could cause data to be returned at this point.
+	/*
+		for {
+			dummy := make([]byte, 32)
+			if _, err := f.Read(dummy); err == io.EOF {
+				break
+			}
+		}
+	*/
+
+	return nil
+}
+
+// GetStatus retrieves the printer's status as raw data. The printer must be
+// in an appropriate mode, i.e. on-line and not currently printing.
+func (p *Printer) GetStatus() ([]byte, error) {
+	// Request status information.
+	if _, err := p.File.WriteString("\x1b\x69\x53"); err != nil {
+		return nil, err
+	}
+
+	// We need to poll the device a bit.
+	status := make([]byte, 32)
+	start := time.Now()
+	for {
+		if n, err := p.File.Read(status); err == io.EOF {
+			time.Sleep(10 * time.Millisecond)
+		} else if err != nil {
+			return nil, err
+		} else if n < 32 {
+			return nil, errors.New("invalid read")
+		} else {
+			return status, nil
+		}
+		if time.Now().Sub(start) > time.Second {
+			return nil, errors.New("timeout")
+		}
+	}
+}
+
+// Close closes the underlying file.
+func (p *Printer) Close() error {
+	return p.File.Close()
+}
+
+// -----------------------------------------------------------------------------
+
+type Status struct {
+	errors []string
+}
+
+func decodeBitfieldErrors(b byte, errors [8]string) []string {
+	var result []string
+	for i := uint(0); i < 8; i++ {
+		if b&(1<<i) != 0 {
+			result = append(result, errors[i])
+		}
+	}
+	return result
+}
+
+// TODO: What exactly do we need? Probably extend as needed.
+func decodeStatusInformation(d []byte) Status {
+	var status Status
+	status.errors = append(status.errors, decodeBitfieldErrors(d[8], [8]string{
+		"no media", "end of media", "cutter jam", "?", "printer in use",
+		"printer turned off", "high-voltage adapter", "fan motor error"})...)
+	status.errors = append(status.errors, decodeBitfieldErrors(d[9], [8]string{
+		"replace media", "expansion buffer full", "communication error",
+		"communication buffer full", "cover open", "cancel key",
+		"media cannot be fed", "system error"})...)
+	return status
+}