Cabezal de impresión térmica para un sistema de gestión de estacionamiento basado en Raspberry Pi Pico y STONE TFT LCD

Breve introducción

Las impresoras térmicas son muy comunes en nuestra vida diaria, y existen ejemplos de impresoras térmicas en restaurantes, estacionamientos y tiendas. Este artículo se centrará en la aplicación de impresoras térmicas en sistemas de estacionamiento.

Cabezal de impresión térmica para un sistema de gestión de parking basado en Raspberry Pi pico y STONE TFT LCD IOT PlatoBlockchain Data Intelligence. Búsqueda vertical. Ai.

Materiales a utilizar

PIEDRA STWI101WT-01
Cabezal de impresora térmica FTP
Pico de frambuesa Pi
- Máquina que funciona con monedas
FunciónLa función de control se muestra en la pantalla de serie, la interfaz principal selecciona el piso, después de ingresar a la interfaz principal selecciona el espacio de estacionamiento, al mismo tiempo mostrará el número de espacio de estacionamiento en el cuadro de texto en la parte superior derecha, luego selecciona el tiempo de estancia, son dos selectores de texto desplazables, luego el mismo mostrará la información del pedido en el cuadro de texto en la parte superior derecha, de acuerdo con el precio unitario fijo que se multiplica por el tiempo de estancia para obtener el precio total. Entonces, solo cuando se seleccionan el espacio de estacionamiento y el tiempo de estadía, puede ir al botón de pago; de lo contrario, no es válido. Después de ingresar a la pantalla de pago, se utilizará un aceptador de monedas. Luego, la pantalla mostrará la cantidad de monedas que se colocarán y la cantidad de monedas que ya se colocaron. Una vez que se hayan colocado las monedas, se mostrará un mensaje de éxito del pago. Luego, puede optar por imprimir un boleto pequeño para imprimir el número de lugar y la hora en el papel térmico.El proceso de diseñoAl principio quería usar el Pico de frambuesa Pi para hacer una pequeña impresora. Luego en el proceso de selección de componentes creo que la impresora térmica es más conveniente de lograr, luego de determinar el programa, comencé a comprar hardware. De hecho, en el proceso de adquisición en línea descubrí que hay muchas impresoras térmicas con buenos circuitos de controladores, la mayoría de ellas se fabrican con el chip de stm y están diseñadas con su propio conjunto de instrucciones. Por ejemplo, al usar sus instrucciones para dejar que la impresora imprima caracteres o se convierta en papel, la practicidad de esta impresora es muy alta, pero el aprendizaje no tiene valor. Es para enviar instrucciones a través del puerto serie en la línea, puede manipular la impresora. Así que pensé en comprar un cabezal de impresión y desarrollarlo yo mismo. Luego, sobre el cabezal de impresión, elegí un cabezal de impresión térmica ftp.El cabezal de impresión térmica ftp
Este cabezal de impresión debería estar disponible internacionalmente, los principios básicos son similares. El lado izquierdo es un motor paso a paso. Entonces la cabeza media es de 6 unidades de calefacción. Cada unidad de calefacción tiene 64 puntos de calefacción. Así que un total de 384 puntos de calefacción. Luego debajo hay un pestillo. Debajo del pestillo hay un registro de desplazamiento. Finalmente, hay que proporcionar una señal de reloj. Entonces, todo el principio de funcionamiento es proporcionar una señal de reloj al cabezal de impresión y luego enviar datos cada período de reloj, después de enviar 384 señales de reloj y 384 datos, los datos en el registro de desplazamiento se almacenarán en el pestillo. Luego, el pestillo se establece en un nivel bajo. Luego, los 384 puntos de calentamiento elegirán calentar o no calentar según si cada dato es 0 o 1. Al mismo tiempo, deje que el motor paso a paso gire para impulsar el papel térmico para diseñar el carácter deseado. Después de obtener la impresión térmica cabeza, seguí adelante y pedí una hoja de datos y era un cable fpc de 30 pines. Entonces, obviamente, no es muy conveniente conectarse al pico directamente con él. Así que pensé que sería mejor diseñar un circuito backplane. Tengo un Pantalla de serie STONE es una fuente de alimentación de 12v, y luego miro el voltaje de impresión del cabezal de impresión térmica de un valor de referencia es de 7.6v, el valor máximo es de 8v, luego le proporciono un voltaje de aproximadamente 7.6v. También tiene un voltaje lógico de 3.3v, y luego la fuente de alimentación de 5v de soporte máximo de Raspberry Pi pico y tiene un voltaje de salida de 3.3v, luego el diseño de la fuente de alimentación puede usar dos dcdc, con fuente de alimentación de 12v, una salida de dcdc 7.6v para alimentar el cabezal de impresión térmica, la otra salida dcdc 5v al pico, y luego usar los 3.3v del pico para alimentar el voltaje lógico del cabezal de impresión térmica. Luego, 12v lidera el camino directamente a la pantalla de serie.
Por cierto, el motor paso a paso para ese cabezal de impresión térmica también necesita ser accionado. Tengo un integrador de tubo Darlington integrado. Pero es demasiado grande y es un complemento directo, así que solo compre un chip controlador. Entonces, este aspecto del motor de accionamiento también está bien. La impresión requiere el diseño de una fuente, básicamente todos usan spi flash para el almacenamiento de fuentes, lo cual es un proyecto enorme. Solo el código ascii es más de 100, por lo que debe comprar otro flash SPF. Entonces toda la planificación es casi así.
STONE Designer （Software GUI Designer）De:https://www.stoneitech.com/support/download/software
Diseña el circuitoLuego, los siguientes comenzaron a diseñar el circuito. Primero busque la fuente de alimentación, de hecho, al principio usé un regulador de voltaje de tres terminales, porque el circuito es simple, después de estar hecho, la situación de calentamiento fue más grave durante la depuración, muy caliente al tacto, así que cambio de uso. dcdc. Simplemente siga la hoja de datos del chip directamente para hacer el diagrama del circuito. Elegí mt2492 aquí, pero ignoré un parámetro importante es la corriente de operación del cabezal de impresión, la corriente de salida máxima de este chip es 2A, pero la corriente de operación del cabezal de impresión de 2.3A, una diferencia de 0.3A, también se puede usar, pero la eficiencia no es tan alta, hablaremos del efecto específico más adelante.
Luego, el chip del controlador del motor que compré es lv8548, consulte la hoja de datos del cabezal de impresión, que tiene un diagrama de sincronización de la transmisión del motor paso a paso, de acuerdo con su sincronización, para proporcionarle una señal pwm de cuatro vías.
Luego está el chip flash, con by25q32bs, la capacidad de 32Mbit es bastante grande, y está conectado al pico, esperando ser llamado por el pico.
Después de eso, el diagrama general del circuito es así, la esquina superior izquierda es la toma de comunicación y la toma de la fuente de alimentación, debajo hay un zumbador (no se usa realmente en el circuito), hay un diodo emisor de luz a la derecha, y la esquina inferior derecha es un fpc de 30 pines para conectar el cabezal de impresión.
Una vez hecho esto, se puede usar como se muestra a continuación, dejando un receptáculo de encabezado de clavija en la placa para el Raspberry Pi pico, puede enchufarlo directamente.
El pico Raspberry Pi
Encienda la alimentación, primero no conectado al pico y al cabezal de impresión, mida el voltaje de salida del dcdc, en el caso normal uno es de aproximadamente 7.5v, el otro es de aproximadamente 5v.
Luego, conecte el cabezal de impresión, la pantalla de serie y el pico, mida que el voltaje lógico es de aproximadamente 3.3v, después de que no haya problemas, puede escribir el programa.
ProgramaTengo la intención de ajustar primero el motor paso a paso, esta parte es fácil de ajustar, mire el diagrama de tiempo en la hoja de datos, 8 períodos de reloj, cada período de reloj debe dar una señal lógica a los cuatro pines del motor por separado, después de 8 períodos el motor suba y luego ajuste la velocidad, pero en el medio tenemos que agregar un retraso para ajustar la relación de trabajo; de lo contrario, gira demasiado rápido, el tiempo de retraso que configuré es de aproximadamente 5 ms y luego, después de dejarlo girar, debe darle el nivel a bajo, de lo contrario, el motor no parece girar, de hecho, la bobina interna todavía está encendida, después de mucho tiempo puede oler el olor a quemado. Luego escriba la función, coloque el cuerpo en un bucle, el número de ciclos representa el duración de la rotación del motor, la función parece un poco larga, colóquela en otro lugar solo y espere la llamada.
Esta es la función después de algunos cambios, la velocidad y la duración se transmitirán en el programa principal. Todavía necesita mucha optimización. Entonces es el punto de ajustar el cabezal de impresión, esta parte es difícil para mí, necesita una señal de reloj, la hoja de datos está escrita en el máximo de 8M, pensé que necesitaba una señal de aproximadamente 8M frecuencia, es difícil, primero medí la frecuencia con io flip level, la diferencia es demasiada. Y luego quiero usar pio, e investigué todo un día pero el resultado no es bueno, mis habilidades personales son limitadas, probablemente necesito estudiar profundamente el manual del chip rp2040. Luego cambie el nivel 384 períodos para probar, es un flujo de trabajo como este, inicialice el pin de entrada de datos 1, pestillo 1 pin, señal de reloj 1 pin, 6 pines de la unidad de impresión y luego, además del pestillo, todos los demás tiran hacia abajo, y luego envíe un dato dentro de un período de reloj, después del ciclo 384 veces para establecer el pestillo en 0, para establecer la unidad de impresión 6 en 1, y luego qué punto tiene datos sobre qué punto se calentará. Después de la implementación del conjunto, retroceda el nivel. Luego, después de escribir el programa y comenzar las pruebas, realmente no funcionó, en realidad porque se controlaron demasiadas unidades de impresión pero la corriente no fue suficiente, luego cámbielo para dar menos dos unidades de impresión de alto nivel y vuelva a probar.
¡Realmente está funcionando! Imprimió una línea horizontal. Eso significa que no hay un límite inferior en la frecuencia del reloj, luego puede hacer funcionar el motor paso a paso para imprimir una línea vertical. pico dual hilo, luego deje que el otro hilo funcione sincrónicamente el motor, luego escriba el programa y ejecútelo. Sale la línea vertical.
Con las líneas horizontales y verticales, luego obtenga una línea diagonal, preste atención a una unidad de impresión que tiene 64 puntos, que define una longitud, como 32, y luego cicla 32 veces 384 períodos, cada período solo establece los primeros 64 datos en 1 y establezca los siguientes 320 datos en 0, y luego 32 veces cada vez solo en la primera unidad para imprimir un punto y luego un ciclo incremental, combinado con la velocidad del motor paso a paso para ajustar, y finalmente ajustó el tamaño 64 * 32 del línea diagonal, también puede deletrear primero una letra Z.
Luego, el esquema del programa está ahí, si desea imprimir la palabra, primero debe escribir la fuente. Primero haga una letra mayúscula A, tamaño 32 * 32, con una lista de definiciones, estoy planeando hacer aquí con pin.value (), así que haga la fuente, luego use 32 filas y 32 columnas de valores binarios para ser llamados, sacar para hacer un turno y luego pasar a pin.value (), por lo que este es el proceso de implementación.
Con 0 como fondo y 1 como primer plano, el proceso de implementación real se ve así.
El ciclo grande más externo 32 representa el ciclo de 32 líneas, es decir, imprime 32 líneas, y luego los primeros 32 ciclos internos son para calentar la mitad de la primera unidad de calefacción, luego los 352 períodos restantes se establecerán en 0, y luego menos 1 desde 31 cada vez hasta 0, puede contar la primera línea de los puntos que deben calentarse de izquierda a derecha, y luego cada 384 períodos para completar una vez que el pestillo se haya configurado en 0 y la unidad de calefacción se haya configurado en 1 y luego puede imprimir, y luego una palabra después de repetir 32 veces.
Aún en negrita, este tipo de palabra de matriz de puntos, hay herramientas en línea que se pueden hacer directamente, el frente más 0b y luego agregue una coma en la parte posterior, y luego juegue de acuerdo con sus propias ideas, la fuente en realidad está destinada inicialmente a ser almacenado en el chip flash, pero lo ajusto durante mucho tiempo, todavía no se puede abrir.
No sé dónde está el problema, después de que tenga tiempo me ajustaré nuevamente, lo bueno es que el pico en sí tiene un flash de 16mbit, almacenar una biblioteca ascii todavía es suficiente, entonces estoy tan almacenado.
Defínalo con un diccionario, colóquelo en una pieza separada y vuelva a llamarlo en el programa principal. Then after debugging, the available version looks like this.from machine import Pinfrom time import sleepimport _threadimport rp2from array import arrayimport ascii_kuimport speed_motor#import sysdelaytime = 0.0000001 # Printer clock delaymotor = speed_motor.motor_control(2, 3, 4, 5) # Initialize the printer’s internal stepper motor pins, corresponding to the a+/a-/b+/b- of the stepper motormov_bit = 0PRINTER_DIN = Pin(20, Pin.OUT)PRINTER_CLK = Pin(19, Pin.OUT)PRINTER_LAT = Pin(18, Pin.OUT, Pin.PULL_UP)STB1 = Pin(6, Pin.OUT, Pin.PULL_DOWN)STB2 = Pin(7, Pin.OUT, Pin.PULL_DOWN)STB3 = Pin(8, Pin.OUT, Pin.PULL_DOWN)STB4 = Pin(9, Pin.OUT, Pin.PULL_DOWN)STB5 = Pin(14, Pin.OUT, Pin.PULL_DOWN)STB6 = Pin(15, Pin.OUT, Pin.PULL_DOWN)lock = _thread.allocate_lock()ascii_code = ascii_ku.ascii_code() # Importing an ascii character libraryshuru = input(“Please enter text:”)line_word = []for item in range(len(shuru)): line_word.append(shuru[item])# line_num = len(shuru)# bottom_line_num = len(shuru)%# global motor_speed = 0# global line = 0# if len(shuru) > 12:# motor_speed = len(shuru) % 6# if (len(shuru) % 6) == 0:# motor_speed = 12# else:# motor_speed = len(shuru)# print(motor_speed)motor_speed = len(shuru)line = (len(shuru) // 12) + 1if (len(shuru) % 12) == 0: line -= 1lins = 0supper = 0slower = 0# _thread.start_new_thread(motor.run_stop, (0.005*motor_speed, 26*line))_thread.start_new_thread(motor.run_stop, (motor_speed, 1))# _thread.start_new_thread(motor.run_stop, (0.03, 56))def last_word_size32 (word_line, linss, lins, supper, slower): for mov_bit in range((supper*32)+(slower*24)): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(31, -1, -1): word_bit = (word_line[linss] >> mov_bit)&0b00000000000000000000000000000001 PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(word_bit) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(352-((supper*32)+(slower*24))): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) if (supper*32)+(slower*24) < 192: PRINTER_LAT.value(0) STB1.value(1) STB2.value(1) STB3.value(1) sleep(0.005) STB1.value(0) STB2.value(0) STB3.value(0) PRINTER_LAT.value(1) else: PRINTER_LAT.value(0) STB4.value(1) STB5.value(1) STB6.value(1) sleep(0.005) STB4.value(0) STB5.value(0) STB6.value(0) PRINTER_LAT.value(1)def word_size24 (word_line, linss, lins, supper, slower): for mov_bit in range((supper*32)+(slower*24)): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(23, -1, -1): word_bit = (word_line[linss] >> mov_bit)&0b000000000000000000000001 PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(word_bit) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(360-((supper*32)+(slower*24))): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) if (supper*32)+(slower*24) < 192: PRINTER_LAT.value(0) STB1.value(1) STB2.value(1) STB3.value(1) sleep(0.005) STB1.value(0) STB2.value(0) STB3.value(0) PRINTER_LAT.value(1) else: PRINTER_LAT.value(0) STB4.value(1) STB5.value(1) STB6.value(1) sleep(0.005) STB4.value(0) STB5.value(0) STB6.value(0) PRINTER_LAT.value(1)for linss in range(32): supper=slower=0 if linss < 32: for lins in range(len(line_word)):# if lins//12:# break if (line_word[lins].isupper() or line_word[lins].isdigit() or line_word[lins].isspace()): last_word_size32 (ascii_code.code.get(line_word[lins]), linss%32, lins%12, supper, slower) supper += 1 elif (line_word[lins].islower()): word_size24 (ascii_code.code.get(line_word[lins]), linss%32, lins%12, supper, slower) slower += 1 else: if linss == 32: sleep(5.8) for lins in range(motor_speed): if (line_word[lins].isupper()): last_word_size32 (ascii_code.code.get(line_word[12]), linss%32, lins%12, len(line_word))# elif:# _thread.start_new_thread(motor.run_stop, (motor_speed, line))# for linss in range(32):# for lins in range(len(line_word)):# if (line_word[lins].isupper()):# last_word_size32 (ascii_code.code.get(line_word[lins]), linss, lins, len(line_word))line_word.clear()I am separate control printing unit, because the current is not enough so like this, but in order to print clear, making my printing speed becomes particularly slow, the more words the slower, and then the lowercase letters is 24 * 32 dot matrix, that it is less print points to use, but can not give it to leave 32 heating points of space then the character spacing is large, so the capital letters and lowercase letters are separated, the numbers are still 32 * 32.
Finally, the whole program is attached.from machine import UART,Pinfrom time import sleepimport _threadimport rp2from array import arrayimport ascii_kuimport speed_motorfrom os import uname#import sysuart1 = UART(0, baudrate = 115200, tx =Pin(0), rx = Pin(1))floor1 = [‘f’, ‘l’, ‘o’, ‘o’, ‘r’,’1′]floor2 = [‘f’, ‘l’, ‘o’, ‘o’, ‘r’,’2′]floor3 = [‘f’, ‘l’, ‘o’, ‘o’, ‘r’,’3′]button_cmd = [16,1]selector_cmd = [16,129]print(uname()[0])delaytime = 0.0000001 # Printer clock delaycoin = Pin(22, Pin.IN,Pin.PULL_UP)coin_num = 0motor = speed_motor.motor_control(2, 3, 4, 5) # Initialize the printer’s internal stepper motor pins, corresponding to the a+/a-/b+/b- of the stepper motormov_bit = 0PRINTER_DIN = Pin(20, Pin.OUT)PRINTER_CLK = Pin(19, Pin.OUT)PRINTER_LAT = Pin(18, Pin.OUT, Pin.PULL_UP)STB1 = Pin(6, Pin.OUT, Pin.PULL_DOWN)STB2 = Pin(7, Pin.OUT, Pin.PULL_DOWN)STB3 = Pin(8, Pin.OUT, Pin.PULL_DOWN)STB4 = Pin(9, Pin.OUT, Pin.PULL_DOWN)STB5 = Pin(14, Pin.OUT, Pin.PULL_DOWN)STB6 = Pin(15, Pin.OUT, Pin.PULL_DOWN)lock = _thread.allocate_lock()ascii_code = ascii_ku.ascii_code() # Importing an ascii character library# shuru = ‘aa’# line_word = []# for item in range(len(shuru)):# line_word.append(shuru[item])# line_num = len(shuru)# bottom_line_num = len(shuru)%# global motor_speed = 0# global line = 0# if len(shuru) > 6:# motor_speed = len(shuru) % 6# if (len(shuru) % 6) == 0:# motor_speed = 12# else:# motor_speed = len(shuru)# # print(motor_speed)# # line = (len(shuru) // 12) + 1# if (len(shuru) % 12) == 0:# line -= 1lins = 0supper = 0slower = 0danjia = 0# _thread.start_new_thread(motor.run_stop, (0.005*motor_speed, 26*line))# _thread.start_new_thread(motor.run_stop, (motor_speed, line))# _thread.start_new_thread(motor.run_stop, (0.03, 56))def pay(pay): global coin_num line_word = {‘line_word1’:[‘s’,’i’,’t’,’e’,’:’,’F’,’1′,’-‘,’0′],’line_word2’:[‘0′,’d’,’a’,’y’,’2′,’h’,’o’,’u’,’r’],’line_word3′:[‘t’,’o’,’t’,’a’,’l’,’:’,’4′,’.’,’0′],’line_word4′:[‘T’,’o’,’t’,’a’,’l’,’:’,’4′,’.’,’0′]} line_wors = {‘line_word1’:[‘U’,’n’,’i’,’t’,’:’,’2′,’.’,’0′,’0′],’line_word2′:[‘T’,’o’,’t’,’a’,’l’,’:’,’4′,’.’,’0′], ‘line_word3’:[‘U’,’n’,’i’,’t’,’:’,’2′,’.’,’0′,’0′],’line_word4′:[‘T’,’o’,’t’,’a’,’l’,’:’,’5′,’.’,’0′]}# line_word1 = [‘S’,’i’,’t’,’e’,’:’,’F’,’1′,’-‘,’0’]# line_word2 = [‘1′,’D’,’a’,’y’,’1′,’H’,’o’,’u’,’r’]# line_word3 = [‘U’,’n’,’i’,’t’,’:’,’2′,’.’,’0′,’0′]# line_word4 = [‘T’,’o’,’t’,’a’,’l’,’:’,’5′,’.’,’0′]# line_word1[8]=str(pay[0])# line_word2[0]=str(pay[1])# line_word2[4]=str(pay[2])# line_word4[6]=str(pay[3]) (line_word[‘line_word1’])[8]=str(pay[0])# (line_word[‘line_word2’])[0]=str(pay[1])# (line_word[‘line_word2’])[4]=str(pay[2])# (line_word[‘line_word4’])[6]=str(pay[3]) sleep(1) uart1.write(‘ST<{“cmd_code”:”set_value”,”type”:”image_value”,”widget”:”image_value4″,”value”:’+str(pay[3])+’}>ET’)# sleep(2)# print(line_word.get(‘line_word’+str(1))[0])# print(‘zfdszfz’,line_word)# sleep(2)# uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message5″,”text”:”F1 – ‘+pay[0]+'”}>ET’)# uart1.sendbreak()# sleep(1)# uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message6″,”text”:”‘+str(pay[1])+'”}>ET’)# uart1.sendbreak()# sleep(1)# # uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message22″,”text”:”‘+str(pay[2])+'”}>ET’)# uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message8″,”text”:”‘+str(pay[3])+'”}>ET’) while True: if coin.value()==0: coin_num += 1 print(“Number of coins deposited：”,coin_num) sleep(0.1) uart1.write(‘ST<{“cmd_code”:”set_value”,”type”:”image_value”,”widget”:”image_value2″,”value”:’+str(coin_num)+’}>ET’) if coin_num == pay[3]: uart1.write(‘ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”image37″,”visible”:true}>ET’) if uart1.any()>1: rx2 = [] data_name2 = ” bin_data = uart1.read(40) uart1.sendbreak() rx1 = list(bin_data) for item in rx1: rx2.append(chr(item)) print(rx2) if rx1[3:5:1] == button_cmd: data_name_len = rx1[6] – 1 data_name = rx2[7:data_name_len+6:1] data_name2 = ”.join(data_name) print(data_name2) if data_name2 == ‘back’: break elif data_name2 == ‘print’ and coin_num == pay[3] and rx1[13] == 2: data_name2=” _thread.start_new_thread(motor.run_stop, (9, 4)) for iii in range(1,3): for linss in range(32): supper=slower=0 for lins in range(9):# temp_list=ascii_code.code.get((‘line_word’+str(iii))[lins])# print(temp_list,type(temp_list)) if (line_word.get(‘line_word’+str(iii))[lins]).islower(): word_size24 (ascii_code.code.get(line_word.get(‘line_word’+str(iii))[lins]), linss%32, lins%12, supper, slower) slower += 1 else: last_word_size32 (ascii_code.code.get(line_word.get(‘line_word’+str(iii))[lins]), linss%32, lins%12, supper, slower) supper += sleep(6)# for iii in range(1,2):# for linss in range(32):# supper=slower=0# for lins in range(9):# # temp_list=ascii_code.code.get((‘line_word’+str(iii))[lins])# # print(temp_list,type(temp_list))# if (line_wors.get(‘line_word’+str(iii))[lins]).islower():# word_size24 (ascii_code.code.get(line_wors.get(‘line_word’+str(iii))[lins]), linss%32, lins%12, supper, slower)# slower += 1# else:# last_word_size32 (ascii_code.code.get(line_wors.get(‘line_word’+str(iii))[lins]), linss%32, lins%12, supper, slower)# supper += 1# sleep(6)# for iii in range(1,2):# for linss in range(32):# supper=slower=0# for lins in range(9):# # temp_list=ascii_code.code.get((‘line_word’+str(iii))[lins])# # print(temp_list,type(temp_list))# if (line_wors.get(‘line_word’+str(iii))[lins]).islower():# word_size24 (ascii_code.code.get(line_wors.get(‘line_word’+str(iii))[lins]), linss%32, lins%12, supper, slower)# slower += 1# else:# last_word_size32 (ascii_code.code.get(line_wors.get(‘line_word’+str(iii))[lins]), linss%32, lins%12, supper, slower)# supper += 1def floor1def(): day_jia = 0 hour_jia = 0 day_flag = False hour_flag = False price_flag = False posltion = False zongjia = 0 pay1 = [0,0,0,0] print(“floor1 now”)# uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message3″,”text”:”2.00$/H”}>ET’) uart1.sendbreak() while True: if uart1.any()>1: rx2 = [] data_name2 = ” bin_data = uart1.read(40) uart1.sendbreak() rx1 = list(bin_data) for item in rx1: rx2.append(chr(item)) print(rx2) if rx1[3:5:1] == button_cmd: data_name_len = rx1[6] – 1 data_name = rx2[7:data_name_len+6:1] data_name2 = ”.join(data_name) print(data_name2) if data_name2 == ‘back’: break elif data_name2 == ‘position’: posltion = True pay1[0]=rx2[15] write1(rx2[15]) elif data_name2 == ‘pay’ and posltion and price_flag: uart1.write(‘ST<{“cmd_code”:”open_win”,”type”:”window”,”widget”:”window7″}>ET’) pay(pay1)# if data_name2 == ‘pay’ and posltion = True and (day_flag or hour_flag):# posltion = True# uart1.write(‘ST<{“cmd_code”:”open_win”,”type”:”window”,”widget”:”window7″}>ET’) if rx1[3:5:1] == selector_cmd: data_name_len = rx1[6] – 4 data_name = rx2[7:data_name_len+7:1] data_name2 = ”.join(data_name) print(data_name2) if data_name2 == ‘time_day1’: pay1[1]=rx2[19] write2(ord(rx2[19])) day_jia = ord(rx2[19]) day_flag = True elif data_name2 == ‘time_hour1’: pay1[2]=rx2[20] write3(ord(rx2[20])) hour_jia = ord(rx2[20]) hour_flag = True if hour_flag or day_flag: price_flag = True zongjia = (day_jia*48) + (hour_jia*2) pay1[3]=zongjia print(str(zongjia)) uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message4″,”text”:”‘+str(zongjia)+'”}>ET’) hour_flag = day_flag = Falsedef floor2def(): passdef floor3def(): passdef write1(num): #print(ss) for item in range(49,55): uart1.write(‘ST<{“cmd_code”:”set_image”,”type”:”image”,”widget”:”image1_’+chr(item)+'”,”image”:”nocar_bg”}>ET’) uart1.write(‘ST<{“cmd_code”:”set_image”,”type”:”image”,”widget”:”image1_’+num+'”,”image”:”selectedcar_bg2″}>ET’) uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message1″,”text”:”F1 – ‘+num+'”}>ET’)def write2(num):# danjia = 1 uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message2″,”text”:”‘+str(num)+'”}>ET’)# if danjia == 1:# uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message3″,”text”:”2.00$/H”}>ET’)def write3(num):# danjia = 1 uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message22″,”text”:”‘+str(num)+'”}>ET’)# if danjia == 1:# uart1.write(‘ST<{“cmd_code”:”set_text”,”type”:”edit”,”widget”:”message3″,”text”:”2.00$/H”}>ET’)def last_word_size32 (word_line, linss, lins, supper, slower): for mov_bit in range((supper*32)+(slower*24)): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(31, -1, -1): word_bit = (word_line[linss] >> mov_bit)&0b00000000000000000000000000000001 PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(word_bit) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(352-((supper*32)+(slower*24))): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) if (supper*32)+(slower*24) < 192: PRINTER_LAT.value(0) STB1.value(1) STB2.value(1) STB3.value(1) STB4.value(1) sleep(0.005) STB1.value(0) STB2.value(0) STB3.value(0) STB4.value(0) PRINTER_LAT.value(1) else: PRINTER_LAT.value(0) STB4.value(1) STB5.value(1) STB6.value(1) sleep(0.005) STB4.value(0) STB5.value(0) STB6.value(0) PRINTER_LAT.value(1)# PRINTER_LAT.value(0)# STB1.value(1)# STB2.value(1)# STB3.value(1)# STB4.value(1)# STB5.value(1)# STB6.value(1)# sleep(0.005)# STB1.value(0)# STB2.value(0)# STB3.value(0)# STB4.value(0)# STB5.value(0)# STB6.value(0)# PRINTER_LAT.value(1) def word_size24 (word_line, linss, lins, supper, slower): for mov_bit in range((supper*32)+(slower*24)): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(23, -1, -1): word_bit = (word_line[linss] >> mov_bit)&0b000000000000000000000001 PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(word_bit) PRINTER_CLK.value(1) sleep(delaytime) for mov_bit in range(360-((supper*32)+(slower*24))): PRINTER_CLK.value(0) sleep(delaytime) PRINTER_DIN.value(0) PRINTER_CLK.value(1) sleep(delaytime) if (supper*32)+(slower*24) < 192: PRINTER_LAT.value(0) STB1.value(1) STB2.value(1) STB3.value(1) sleep(0.005) STB1.value(0) STB2.value(0) STB3.value(0) PRINTER_LAT.value(1) else: PRINTER_LAT.value(0) STB4.value(1) STB5.value(1) STB6.value(1) sleep(0.005) STB4.value(0) STB5.value(0) STB6.value(0) PRINTER_LAT.value(1)# PRINTER_LAT.value(0)# STB1.value(1)# STB2.value(1)# STB3.value(1)# STB4.value(1)# STB5.value(1)# STB6.value(1)# sleep(0.005)# STB1.value(0)# STB2.value(0)# STB3.value(0)# STB4.value(0)# STB5.value(0)# STB6.value(0)# PRINTER_LAT.value(1)while True: if uart1.any()>1: rx2 = [] data_name2 = ” bin_data = uart1.read(40) uart1.sendbreak() rx1 = list(bin_data) for item in rx1: rx2.append(chr(item)) print(rx2) if rx2[7:13:1] == floor1: floor1def() elif rx2[7:13:1] == floor2: floor2def() elif rx2[7:13:1] == floor3: floor3def()for linss in range(32): supper=slower=0 if linss < 32: for lins in range(len(line_word)):# if lins//12:# break if (line_word[lins].isupper() or line_word[lins].isdigit() or line_word[lins].isspace()): last_word_size32 (ascii_code.code.get(line_word[lins]), linss%32, lins%12, supper, slower) supper += 1 elif (line_word[lins].islower()): word_size24 (ascii_code.code.get(line_word[lins]), linss%32, lins%12, supper, slower) slower += 1 else: if linss == 32: sleep(5.8) for lins in range(motor_speed): if (line_word[lins].isupper()): last_word_size32 (ascii_code.code.get(line_word[12]), linss%32, lins%12, len(line_word))# elif:# _thread.start_new_thread(motor.run_stop, (motor_speed, line))# for linss in range(32):# for lins in range(len(line_word)):# if (line_word[lins].isupper()):# last_word_size32 (ascii_code.code.get(line_word[lins]), linss, lins, len(line_word)line_word.clear()
Fuente: Platón Data Intelliigence