Thermal Print Head For A Parking Management System Based On Raspberry Pi Pico And STONE TFT LCD

Breve introduzione

Le stampanti termiche sono molto comuni nella nostra vita quotidiana e ci sono esempi di stampanti termiche in ristoranti, parcheggi e negozi. Questo articolo si concentrerà sull'applicazione delle stampanti termiche nei sistemi di parcheggio.

Thermal print head for a parking management system based on Raspberry Pi pico and STONE TFT LCD IOT PlatoBlockchain Data Intelligence. Vertical Search. Ai.

Materiali da utilizzare

PIETRA STWI101WT-01
Testina stampante termica FTP
Raspberry Pi Pico
- Macchina a gettoni
FunzioneLa funzione di controllo viene visualizzata sullo schermo seriale, l'interfaccia principale seleziona il piano, dopo essere entrati nell'interfaccia principale seleziona il posto auto, contemporaneamente visualizzerà il numero del posto auto nella casella di testo in alto a destra, quindi seleziona il tempo di permanenza, sono due selettori di testo a scorrimento, quindi anche lo stesso visualizzerà le informazioni dell'ordine nella casella di testo in alto a destra, in base al prezzo unitario fisso che si moltiplica con il tempo di permanenza per ottenere il prezzo totale. Quindi solo quando sono selezionati il posto auto e il tempo di permanenza, puoi andare al pulsante di pagamento, altrimenti non è valido. Dopo essere entrati nella schermata di pagamento, verrà utilizzata una gettoniera. Quindi lo schermo mostrerà il numero di monete da inserire e il numero di monete già inserite. Dopo che le monete sono state inserite, verrà visualizzato un messaggio di successo del pagamento. Quindi puoi scegliere di stampare un piccolo biglietto per stampare il numero del luogo e l'ora sulla carta termica.Il processo di progettazioneAll'inizio volevo usare il Raspberry Pi Pico per fare una piccola stampante. Quindi nel processo di selezione dei componenti penso che la stampante termica sia più conveniente da ottenere, dopo aver determinato il programma, ho iniziato ad acquistare l'hardware. Infatti, nel processo di acquisto online ho scoperto che ci sono molte stampanti termiche con buoni circuiti di pilotaggio, la maggior parte di esse sono realizzate utilizzando il chip di stm e sono progettate con il proprio set di istruzioni. Ad esempio, usando le sue istruzioni per lasciare che la stampante stampi caratteri o vada su carta, ma la praticità di questa stampante è molto alta, ma non c'è valore dell'apprendimento. Si tratta di inviare istruzioni tramite la porta seriale sulla linea, è possibile manipolare la stampante. Così ho pensato di acquistare una testina di stampa e di svilupparla da solo. Poi per quanto riguarda la testina di stampa, ho scelto una testina di stampa termica ftp.La testina di stampa termica ftp
Questa testina di stampa dovrebbe essere disponibile a livello internazionale, i principi di base sono simili. Il lato sinistro è un motore passo-passo. Quindi la testa centrale è composta da 6 unità di riscaldamento. Ogni unità di riscaldamento dispone di 64 punti di riscaldamento. Quindi un totale di 384 punti riscaldamento. Poi sotto c'è un chiavistello. Sotto il fermo c'è un registro a scorrimento. Infine, è necessario fornire un segnale di clock. Quindi l'intero principio di funzionamento è fornire un segnale di clock alla testina di stampa e quindi inviare un dato ogni periodo di clock, dopo aver inviato 384 segnali di clock e 384 dati, i dati nel registro a scorrimento verranno memorizzati nel latch. Quindi il fermo è impostato su un livello basso. Quindi i 384 punti di riscaldamento sceglieranno di riscaldarsi o meno a seconda che ciascun dato sia 0 o 1. Allo stesso tempo, lascia che il motore passo-passo ruoti per guidare la carta termica per disegnare il carattere desiderato. Dopo aver ottenuto la stampa termica testa, sono andato avanti e ho chiesto una scheda tecnica ed era un cavo FPC a 30 pin. Quindi ovviamente non è molto comodo collegarsi direttamente al pico. Quindi ho pensato che sarebbe stato meglio progettare un circuito backplane. Ne ho uno Schermo seriale STONE è l'alimentazione a 12v, quindi guardo la tensione di stampa della testina di stampa termica di un valore di riferimento è 7.6v, il valore massimo è 8v, quindi fornisco una tensione di circa 7.6v. Ha anche una tensione logica di 3.3 V, quindi il Raspberry Pi pico supporta l'alimentazione massima 5 V e ha una tensione di uscita di 3.3 V, quindi il design dell'alimentatore può utilizzare due dcdc, con alimentazione 12v, un'uscita dcdc 7.6 v per alimentare la testina di stampa termica, l'altra uscita dcdc 5v al pico, quindi utilizzare il 3.3v dal pico per alimentare la tensione logica della testina di stampa termica. Quindi 12v aprono la strada direttamente allo schermo seriale.
A proposito, anche il motore passo-passo della testina di stampa termica deve essere azionato. Ho un integratore di tubi Darlington integrato. Ma è troppo grande ed è un semplice plug-in, quindi basta acquistare un chip driver. Quindi anche questo aspetto del motore di azionamento va bene. La stampa richiede la progettazione di un carattere, praticamente tutti utilizzano Spi Flash per l'archiviazione dei caratteri, il che è un progetto enorme. Solo il codice ascii è superiore a 100, quindi è necessario acquistare un altro flash SPF. Quindi l'intera pianificazione è quasi così.
STONE Designer (software GUI Designer)A partire dal:https://www.stoneitech.com/support/download/software
Progetta il circuitoQuindi i seguenti iniziarono a progettare il circuito. Per prima cosa trovo l'alimentatore, infatti all'inizio ho usato un regolatore di tensione a tre terminali, perchè il circuito è semplice, dopo averlo fatto, la situazione di riscaldamento era più grave in fase di debug, molto calda al tatto, quindi cambio per usare dcdc. Basta seguire direttamente la scheda dati del chip per fare lo schema del circuito. Ho scelto mt2492 qui, ma ho ignorato un parametro importante è la corrente operativa della testina di stampa, la corrente di uscita massima di questo chip è 2 A, ma la corrente operativa della testina di stampa di 2.3 A, una differenza di 0.3 A, può anche essere utilizzata, ma l'efficienza non è così alta, dell'effetto specifico parleremo più avanti.
Quindi il chip del driver del motore che ho acquistato è lv8548, vedere la scheda tecnica della testina di stampa, che ha un diagramma di temporizzazione dell'azionamento del motore passo-passo, in base alla sua tempistica, per fornirgli un segnale pwm a quattro vie su di esso.
Poi c'è il chip flash, con by25q32bs, capacità di 32Mbit abbastanza grande, e connesso al pico, in attesa di essere chiamato dal pico.
Dopodiché, lo schema elettrico generale è così, l'angolo in alto a sinistra è la presa di comunicazione e la presa di alimentazione, sotto c'è un cicalino (non effettivamente utilizzato nel circuito), c'è un diodo a emissione luminosa sulla destra e l'angolo in basso a destra è un fpc a 30 pin per il collegamento della testina di stampa.
Dopo averlo fatto e può essere utilizzato è come mostrato di seguito, lasciando una presa di intestazione pin sulla scheda per il Raspberry Pi pico, è possibile collegarlo direttamente.
Il Raspberry Pi pico
Accendere l'alimentazione, prima non collegata al pico e alla testina di stampa, misurare la tensione di uscita del dcdc, nel caso normale una è di circa 7.5v, l'altra è di circa 5v.
Quindi collegare la testina di stampa, lo schermo seriale e il pico, misurare la tensione logica di circa 3.3 v, senza problemi, è possibile scrivere il programma.
ProgrammaIntendo regolare prima il motore passo-passo, questa parte è facile da regolare, guarda il diagramma dei tempi nella scheda tecnica, 8 periodi di clock, ogni periodo di clock dovrebbe fornire separatamente un segnale logico ai quattro pin del motore, dopo 8 periodi il motore lo farà alzare, e poi regolare la velocità, ma nel mezzo dobbiamo aggiungere un ritardo per regolare il rapporto di lavoro altrimenti gira troppo velocemente, il tempo di ritardo che ho impostato è di circa 5ms e poi dopo averlo lasciato girare devi dare il livello a basso, altrimenti il motore sembra non girare infatti la bobina interna è ancora accesa, dopo molto tempo si sente odore di bruciato. Quindi scrivere la funzione, mettere il corpo in loop, il numero di cicli rappresenta il durata della rotazione del motore, la funzione sembra un po' lunga, mettilo da qualche altra parte da solo e attendi la chiamata.
Questa è la funzione dopo alcune modifiche, la velocità e la durata verranno trasmesse nel programma principale. Ha ancora bisogno di molta ottimizzazione. Poi è il punto di regolare la testina di stampa, questa parte è difficile per me, ha bisogno di un segnale di clock, la scheda tecnica è scritta al massimo 8M, pensavo che servisse un segnale di circa 8M frequenza, e' difficile, prima ho misurato la frequenza con io flip level, la differenza è troppa. E poi voglio usare pio, e ho ricercato un'intera giornata ma il risultato non è buono, le mie capacità personali sono limitate, probabilmente ho bisogno di studiare a fondo il manuale del chip rp2040. Quindi gira i periodi del livello 384 per provare, è un flusso di lavoro come questo, inizializza il pin di input dei dati 1, il latch 1 pin, il segnale di clock 1 pin, 6 pin dell'unità di stampa, quindi oltre al latch tutti gli altri tirano verso il basso, quindi inviano un dato entro un periodo di clock, dopo aver ciclizzato 384 volte per impostare il fermo su 0, per impostare le 6 unità di stampa su 1, quindi quale punto contiene i dati su quale punto verrà riscaldato. Dopo l'implementazione del set, abbassare il livello. Poi, dopo che il programma è stato scritto e iniziato a testare, in realtà non ha funzionato, in realtà perché venivano controllate troppe unità di stampa ma la corrente non era sufficiente, quindi cambiarlo per dare meno due unità di stampa ad alto livello e ripetere il test.
Funziona davvero! Ha stampato una linea orizzontale. Ciò significa che non esiste un limite inferiore alla frequenza dell'orologio, quindi è possibile azionare il motore passo-passo per stampare una linea verticale. pico dual thread, quindi lascia che l'altro thread faccia funzionare in modo sincrono il motore, quindi scrivi il programma ed esegui. La linea verticale esce.
Con le linee orizzontali e verticali, quindi ottenere una linea diagonale, prestare attenzione a un'unità di stampa ha 64 punti, che definisce una lunghezza, ad esempio 32, e quindi eseguire un ciclo 32 volte 384 periodi, ogni periodo imposta solo i primi 64 dati su 1 e imposta i successivi 320 dati su 0, e poi 32 volte ogni volta solo nella prima unità per stampare un punto e poi ciclo incrementale, combinato con la velocità del motore passo-passo da regolare, e infine regolato le dimensioni 64 * 32 del linea diagonale, puoi anche scrivere prima una lettera Z.
Quindi lo schema del programma è lì, se vuoi stampare la parola devi prima fare il font. Prima fai una lettera maiuscola A, dimensione 32 * 32, con un elenco di definizioni, ho intenzione di farlo qui con pin.value (), quindi crea il carattere, quindi usa 32 righe e 32 colonne di valori binari da chiamare, prendi per fare uno spostamento e poi passa a pin.value(), quindi questo è il processo di implementazione.
Con 0 come sfondo e 1 come primo piano, il processo di implementazione effettivo si presenta così.
Il ciclo 32 più grande esterno rappresenta il ciclo di 32 righe, ovvero stampa 32 righe, quindi i primi 32 cicli interni servono a riscaldare metà della prima unità di riscaldamento, quindi i restanti 352 periodi verranno impostati su 0 e quindi meno 1 da 31 ogni volta fino a 0, puoi contare la prima riga dei punti che devono essere riscaldati da sinistra a destra, e poi ogni 384 periodi da completare una volta che il latch si è impostato a 0 e il gruppo termico è stato impostato a 1 e poi puoi stampare, e poi una parola A dopo aver ripetuto 32 volte.
Ancora in grassetto, questo tipo di parola a matrice di punti, ci sono strumenti online che possono essere fatti direttamente, il davanti più 0b e poi aggiungi una virgola sul retro, e poi giochi secondo le tue idee, il carattere è in realtà inizialmente inteso per essere memorizzato nel chip flash, ma regolo a lungo non può ancora essere aperto.
Non so dove sia il problema, dopo che avrò tempo mi aggiusterò di nuovo, la cosa buona è che pico stesso ha un flash di dimensioni 16mbit, memorizzare una libreria ascii è ancora sufficiente, quindi sono così memorizzato.
Definitelo con un dizionario, inseritelo in un pezzo separato e richiamatelo nel programma principale. 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()
Fonte: Platone Data Intelligence