diff options
Diffstat (limited to 'ql')
| -rw-r--r-- | ql/ql.go | 354 |
1 files changed, 324 insertions, 30 deletions
@@ -9,7 +9,10 @@ package ql import ( "errors" + "fmt" + "image" "io" + "log" "os" "path/filepath" "regexp" @@ -97,6 +100,8 @@ type Printer struct { File *os.File Manufacturer string Model string + LastStatus *Status + MediaInfo *MediaInfo } func compatible(id deviceID) bool { @@ -160,9 +165,9 @@ func (p *Printer) Initialize() error { // 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. /* + var dummy [32]byte for { - dummy := make([]byte, 32) - if _, err := f.Read(dummy); err == io.EOF { + if _, err := f.Read(dummy[:]); err == io.EOF { break } } @@ -171,33 +176,50 @@ func (p *Printer) Initialize() error { 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 - } +var errTimeout = errors.New("timeout") +var errInvalidRead = errors.New("invalid read") - // We need to poll the device a bit. - status := make([]byte, 32) - start := time.Now() +// pollStatusBytes waits for the printer to send a status packet and returns +// it as raw data. +func (p *Printer) pollStatusBytes( + timeout time.Duration) (status [32]byte, err error) { + start, n := time.Now(), 0 for { - if n, err := p.File.Read(status); err == io.EOF { + if n, err = p.File.Read(status[:]); err == io.EOF { time.Sleep(10 * time.Millisecond) } else if err != nil { - return nil, err + return status, err } else if n < 32 { - return nil, errors.New("invalid read") + return status, errInvalidRead } else { return status, nil } - if time.Now().Sub(start) > time.Second { - return nil, errors.New("timeout") + if time.Now().Sub(start) > timeout { + return status, errTimeout } } } +// Request new status information from the printer. The printer +// must be in an appropriate mode, i.e. on-line and not currently printing. +func (p *Printer) UpdateStatus() error { + // Request status information. + if _, err := p.File.WriteString("\x1b\x69\x53"); err != nil { + return err + } + + // Retrieve status information. + status, err := p.pollStatusBytes(time.Second) + if err != nil { + p.LastStatus = nil + return err + } + + s := Status(status) + p.LastStatus = &s + return nil +} + // Close closes the underlying file. func (p *Printer) Close() error { return p.File.Close() @@ -256,12 +278,141 @@ func GetMediaInfo(widthMM, lengthMM int) *MediaInfo { // ----------------------------------------------------------------------------- -type Status struct { - MediaWidthMM int - MediaLengthMM int - Errors []string +// makeBitmapData converts an image to the printer's raster format. +func makeBitmapData(src image.Image, offset, length int) (data []byte) { + bounds := src.Bounds() + pixels := [720]bool{} + for y := bounds.Min.Y; y < bounds.Max.Y; y++ { + length-- + if length <= 0 { + break + } + + off := offset + for x := bounds.Max.X - 1; x >= bounds.Min.X; x-- { + if off >= len(pixels) { + break + } + + // TODO: Anything to do with the ColorModel? + r, g, b, a := src.At(x, y).RGBA() + pixels[off] = r == 0 && g == 0 && b == 0 && a != 0 + off++ + } + + data = append(data, 'g', 0x00, 90) + for i := 0; i < 90; i++ { + var b byte + for j := 0; j < 8; j++ { + b <<= 1 + if pixels[i*8+j] { + b |= 1 + } + } + data = append(data, b) + } + } + for ; length > 0; length-- { + data = append(data, 'g', 0x00, 90) + data = append(data, make([]byte, 90)...) + } + return +} + +func (p *Printer) makePrintData(image image.Image) (data []byte) { + mediaInfo := GetMediaInfo( + p.LastStatus.MediaWidthMM(), + p.LastStatus.MediaLengthMM(), + ) + + // Raster mode. + // Should be the only supported mode for QL-800. + data = append(data, 0x1b, 0x69, 0x61, 0x01) + + // Automatic status mode (though it's the default). + data = append(data, 0x1b, 0x69, 0x21, 0x00) + + // Print information command. + dy := image.Bounds().Dy() + if mediaInfo.PrintAreaLength != 0 { + dy = mediaInfo.PrintAreaLength + } + + mediaType := byte(0x0a) + if p.LastStatus.MediaLengthMM() != 0 { + mediaType = byte(0x0b) + } + + data = append(data, 0x1b, 0x69, 0x7a, 0x02|0x04|0x40|0x80, mediaType, + byte(p.LastStatus.MediaWidthMM()), byte(p.LastStatus.MediaLengthMM()), + byte(dy), byte(dy>>8), byte(dy>>16), byte(dy>>24), 0, 0x00) + + // Auto cut, each 1 label. + data = append(data, 0x1b, 0x69, 0x4d, 0x40) + data = append(data, 0x1b, 0x69, 0x41, 0x01) + + // Cut at end (though it's the default). + // Not sure what it means, doesn't seem to have any effect to turn it off. + data = append(data, 0x1b, 0x69, 0x4b, 0x08) + + if p.LastStatus.MediaLengthMM() != 0 { + // 3mm margins along the direction of feed. 0x23 = 35 dots, the minimum. + data = append(data, 0x1b, 0x69, 0x64, 0x23, 0x00) + } else { + // May not set anything other than zero. + data = append(data, 0x1b, 0x69, 0x64, 0x00, 0x00) + } + + // Compression mode: no compression. + // Should be the only supported mode for QL-800. + data = append(data, 0x4d, 0x00) + + // The graphics data itself. + data = append(data, makeBitmapData(image, mediaInfo.SideMarginPins, dy)...) + + // Print command with feeding. + return append(data, 0x1a) +} + +func (p *Printer) Print(image image.Image) error { + data := p.makePrintData(image) + + // Print the prepared data. + if _, err := p.File.Write(data); err != nil { + return err + } + + // TODO: We specifically need to wait for a transition to the receiving + // state, and try to figure out something from the statuses. + // We may also receive an error status instead of the transition to + // the printing state. Or even after it. + start, b := time.Now(), [32]byte{} + for { + if n, err := p.File.Read(b[:]); err == io.EOF { + time.Sleep(100 * time.Millisecond) + } else if err != nil { + return err + } else if n < 32 { + return errors.New("invalid read") + } else { + status := Status(b) + log.Printf("status\n%s", &status) + } + if time.Now().Sub(start) > 3*time.Second { + break + } + } + return nil } +// ----------------------------------------------------------------------------- + +// Status is a decoder for the status packed returned by the printer. +type Status [32]byte + +func (s *Status) MediaWidthMM() int { return int(s[10]) } +func (s *Status) MediaLengthMM() int { return int(s[17]) } + func decodeBitfieldErrors(b byte, errors [8]string) []string { var result []string for i := uint(0); i < 8; i++ { @@ -272,18 +423,161 @@ func decodeBitfieldErrors(b byte, errors [8]string) []string { return result } -// TODO: What exactly do we need? Probably extend as needed. -func DecodeStatus(d []byte) *Status { - var status Status - status.MediaWidthMM = int(d[10]) - status.MediaLengthMM = int(d[17]) - - status.Errors = append(status.Errors, decodeBitfieldErrors(d[8], [8]string{ +func (s *Status) Errors() (errors []string) { + errors = append(errors, decodeBitfieldErrors(s[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{ + errors = append(errors, decodeBitfieldErrors(s[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 + return +} + +// String implements the Stringer interface. +func (s *Status) String() string { + var b strings.Builder + s.Dump(&b) + return b.String() +} + +// Dump writes the status data to an io.Writer in a human-readable format. +func (s *Status) Dump(f io.Writer) { + /* + if s[0] != 0x80 || s[1] != 0x20 || s[2] != 0x42 || s[3] != 0x34 { + fmt.Fprintln(f, "unexpected status fixed bytes") + } + */ + + // Model code. + switch m := s[4]; m { + case 0x38: + fmt.Fprintln(f, "model: QL-800") + case 0x39: + fmt.Fprintln(f, "model: QL-810W") + case 0x41: + fmt.Fprintln(f, "model: QL-820NWB") + case 0x43: + fmt.Fprintln(f, "model: QL-1100") + case 0x44: + fmt.Fprintln(f, "model: QL-1110NWB") + case 0x45: + fmt.Fprintln(f, "model: QL-1115NWB") + default: + fmt.Fprintln(f, "model:", m) + } + + /* + // s[6] seems to be 0x00 in a real-world QL-800, as in QL-1100 docs. + if s[5] != 0x30 || s[6] != 0x30 || s[7] != 0x00 { + fmt.Fprintln(f, "unexpected status fixed bytes") + } + */ + + // Error information 1. + for _, e := range decodeBitfieldErrors(s[8], [8]string{ + "no media", "end of media", "cutter jam", "?", "printer in use", + "printer turned off", "high-voltage adapter", "fan motor error"}) { + fmt.Fprintln(f, "error 1:", e) + } + + // Error information 2. + for _, e := range decodeBitfieldErrors(s[9], [8]string{ + "replace media", "expansion buffer full", "communication error", + "communication buffer full", "cover open", "cancel key", + "media cannot be fed", "system error"}) { + fmt.Fprintln(f, "error 2:", e) + } + + // Media width. + fmt.Fprintln(f, "media width:", s[10], "mm") + + // Media type. + switch t := s[11]; t { + case 0x00: + fmt.Fprintln(f, "media: no media") + case 0x4a, 0x0a: // 0x4a = J, in reality we get 0x0a, as in QL-1100 docs. + fmt.Fprintln(f, "media: continuous length tape") + case 0x4b, 0x0b: // 0x4b = K, in reality we get 0x0b, as in QL-1100 docs. + fmt.Fprintln(f, "media: die-cut labels") + default: + fmt.Fprintln(f, "media:", t) + } + + /* + // In a real-world QL-800, s[14] seems to be: + // 0x01 with die-cut 29mm long labels, + // 0x14 with 29mm tape, + // 0x23 with red-black 62mm tape, + // and directly corresponds to physical pins on the tape. + if s[12] != 0x00 || s[13] != 0x00 || s[14] != 0x3f { + fmt.Fprintln(f, "unexpected status fixed bytes") + } + */ + + // Mode. + fmt.Fprintln(f, "mode:", s[15]) + + /* + if s[16] != 0x00 { + fmt.Fprintln(f, "unexpected status fixed bytes") + } + */ + + // Media length. + fmt.Fprintln(f, "media length:", s[17], "mm") + + // Status type. + switch t := s[18]; t { + case 0x00: + fmt.Fprintln(f, "status type: reply to status request") + case 0x01: + fmt.Fprintln(f, "status type: printing completed") + case 0x02: + fmt.Fprintln(f, "status type: error occurred") + case 0x04: + fmt.Fprintln(f, "status type: turned off") + case 0x05: + fmt.Fprintln(f, "status type: notification") + case 0x06: + fmt.Fprintln(f, "status type: phase change") + default: + fmt.Fprintln(f, "status type:", t) + } + + // Phase type. + switch t := s[19]; t { + case 0x00: + fmt.Fprintln(f, "phase state: receiving state") + case 0x01: + fmt.Fprintln(f, "phase state: printing state") + default: + fmt.Fprintln(f, "phase state:", t) + } + + // Phase number. + fmt.Fprintln(f, "phase number:", int(s[20])*256+int(s[21])) + + // Notification number. + switch n := s[22]; n { + case 0x00: + fmt.Fprintln(f, "notification number: not available") + case 0x03: + fmt.Fprintln(f, "notification number: cooling (started)") + case 0x04: + fmt.Fprintln(f, "notification number: cooling (finished)") + default: + fmt.Fprintln(f, "notification number:", n) + } + + /* + // In a real-world QL-800, s[25] seems to be: + // 0x01 with 29mm tape or die-cut 29mm long labels, + // 0x81 with red-black 62mm tape. + if s[23] != 0x00 || s[24] != 0x00 || s[25] != 0x00 || s[26] != 0x00 || + s[27] != 0x00 || s[28] != 0x00 || s[29] != 0x00 || s[30] != 0x00 || + s[31] != 0x00 { + fmt.Fprintln(f, "unexpected status fixed bytes") + } + */ } |