Facturación de extranjeros a través de la impresora POS e impresión de imágenes

Question

Estoy intentando crear un prototipo para imprimir datos de mapa de bits para un archivo de texto en mi impresora habilitada para LAN LAN TM-T88V.

Si bien no tengo problemas para enviar texto y las instrucciones de formato de texto, no entiendo, lo que tengo que hacer, para que mi impresora imprima los datos del Arecibo message.

primeras líneas:

00000010101010000000000 
00101000001010000000100 
10001000100010010110010 
10101010101010100100100 
00000000000000000000000 
00000000000011000000000 
00000000001101000000000 
00000000001101000000000 
00000000010101000000000 
00000000011111000000000 
00000000000000000000000 
11000011100011000011000 
10000000000000110010000 
11010001100011000011010 
11111011111011111011111 
00000000000000000000000 
00010000000000000000010 
00000000000000000000000 
00001000000000000000001 

El mensaje tiene 73 filas y 23 columnas resultantes en 1679 elementos de imagen. Cada uno de estos elementos está definido por un 1 para negro o un 0 como blanco y debe imprimirse como un cuadrado de 8x8 (o 16x16) puntos. el resultado se traduciría en

Arecibo message http://www.satsig.net/seti/message-to-gliese-581.gif

De especificaciones de la impresora:

Mientras que - como dije - la conexión y enviar a la impresora no es ningún problema, simplemente no consigo, lo que esta instrucción me quiere decir ¿Cuál sería en el caso del mensaje de Arecibo

¿Qué números debo enviar a la impresora? ¿Debo enviar cada punto? ¿Qué significa nL, nH specify the number of dots of the image data in the horizontal direction as (nL + nH × 256).?

Aquí es mi sencillo programa de Python que uso para la creación de prototipos:

# -*- coding: utf-8 -*- 
import struct 
import socket 

def sendInstructions(mySocket,l): 
    for x in l: 
     mySocket.send(struct.pack('h', *[x]),1) 


def emphasizeOn(mySocket): 
    sendInstructions(mySocket,[27,33,48]) 


def emphasizeOff(mySocket): 
    sendInstructions(mySocket,[27,33,0]) 


def lineFeed(mySocket,number): 
    for i in range(number): 
     sendInstructions(mySocket,[0x0a,]) 


def paperCut(mySocket): 
    sendInstructions(mySocket,[29,86,0]) 

def sendText(mySocket,string): 
    mySocket.send(string.encode('UTF-8')) 


def main(): 
    mySocket = socket.socket (socket.AF_INET, socket.SOCK_STREAM) 
    mySocket.connect(('192.168.1.15',9100))  


    lines = ["Hello,","World!"] 
    emphasizeOff(mySocket) 
    lineFeed(mySocket,2) 
    for l in lines: 
     if lines.index(l) == 0: 
      emphasizeOn(mySocket) 
     else: 
      emphasizeOff(mySocket) 

     sendText(mySocket,l) 
     lineFeed(mySocket,2) 

    lineFeed(mySocket,4) 
    paperCut(mySocket) 

    mySocket.close() 

if __name__=="__main__": 
    main() 

Answer 1

Este comando genera una franja horizontal de la imagen a la vez. La tira tiene 8 o 24 puntos de alto, dependiendo del valor de m.

nL y nH son los bytes bajos y altos de un entero que especifica el ancho en puntos de la franja horizontal de la imagen. Ese ancho se calcula como nL + nH * 256, por lo que si desea que la imagen tenga 550 puntos de ancho, entonces nH = 2 y nL = 38.

El argumento d son los datos de mapa de bits; si la tira de imagen tiene 8 puntos de alto, entonces cada byte representa una columna en la tira. Si la tira tiene 24 puntos de alto, entonces tres bytes representan una columna.

Digamos que usted tiene Arecibo en una matriz de enteros numpy WxH, 1 o 0. haría:

data = np.zeros((W, H), dtype=np.ubyte) 
## (fill in data here) 

## Use m=33 since this is apparently the only mode with 
## square pixels and also the highest resolution 
## (unless it prints too slowly for your liking) 
m = 33 

nH = W // 256 ## note this is integer division, but SO's 
       ## syntax hilighting thinks it looks like a comment. 
nL = W % 256 

## Divide the array into sections with shape Wx24: 
for n in range(data.shape[1] // 24): 
    ## Note that if the image height is not a multiple of 24, 
    ## you'll have to pad it with zeros somehow. 

    strip = data[:, n*24:(n+1)*24] 

    ## Convert each strip into a string of bytes: 

    strip = strip.reshape(W, 3, 8) 
    bytes = (strip * (2**np.arange(8)[np.newaxis, np.newaxis, :])).sum(axis=2) # magic 
    byteString = bytes.astype(np.ubyte).tostring() 

    ## Send the command to POS