Tête d'impression thermique pour un système de gestion de stationnement basé sur Raspberry Pi Pico et STONE TFT LCD

Brève introduction

Les imprimantes thermiques sont très courantes dans notre vie quotidienne, et il existe des exemples d'imprimantes thermiques dans les restaurants, les parkings et les magasins. Cet article se concentrera sur l'application des imprimantes thermiques dans les systèmes de stationnement.

Matériaux à utiliser

  1. STONE STWI101WT-01
  2. Tête d'impression thermique FTP
  3. Framboise Pi pico
  4. Machine à pièces

Fonction

La fonction de contrôle est affichée sur l'écran série, l'interface principale sélectionne l'étage, après être entrée dans l'interface principale sélectionne la place de stationnement, en même temps, elle affichera le numéro de place de stationnement dans la zone de texte en haut à droite, puis sélectionne le temps de séjour, ce sont deux sélecteurs de texte défilants, puis le même affichera les informations de commande dans la zone de texte en haut à droite, selon le prix unitaire fixe qui se multiplie avec le temps de séjour pour obtenir le prix total. Ensuite, seulement lorsque la place de parking et le temps de séjour sont sélectionnés, vous pouvez accéder au bouton de paiement, sinon, il est invalide. Après être entré dans l'écran de paiement, un accepteur de pièces sera utilisé. Ensuite, l'écran affichera le nombre de pièces à introduire et le nombre de pièces déjà introduites. Une fois les pièces introduites, un message de réussite du paiement s'affichera. Ensuite, vous pouvez choisir d'imprimer un petit ticket pour imprimer le numéro de lieu et l'heure sur le papier thermique.

Le processus de conception

Au départ, je voulais utiliser le pico Raspberry Pi pour faire une petite imprimante. Ensuite, dans le processus de sélection des composants, je pense que l'imprimante thermique est plus pratique à réaliser, après avoir déterminé le programme, j'ai commencé à acheter du matériel. En fait, lors du processus d'achat en ligne, j'ai découvert qu'il existait de nombreuses imprimantes thermiques dotées de bons circuits de commande, la plupart d'entre elles étant fabriquées à l'aide de la puce STM et conçues avec leur propre ensemble d'instructions. Par exemple, en utilisant ses instructions pour laisser l'imprimante imprimer des caractères ou passer du papier, mais l'aspect pratique de cette imprimante est très élevé, mais l'apprentissage n'a aucune valeur. Il s'agit d'envoyer des instructions via le port série sur la ligne, vous pouvez manipuler l'imprimante. J'ai donc pensé acheter une tête d'impression et la développer moi-même. Ensuite concernant la tête d'impression, j'ai choisi une tête d'impression thermique FTP.

La tête d'impression thermique FTP

système-de-gestion-de-parking

Cette tête d'impression devrait être disponible à l'international, les principes de base sont similaires. Le côté gauche est un moteur pas à pas. Ensuite, la tête du milieu est de 6 unités de chauffage. Chaque unité de chauffage dispose de 64 points de chauffage. Soit un total de 384 points de chauffe. Ensuite, ci-dessous est un loquet. Sous le loquet se trouve un registre à décalage. Enfin, un signal d'horloge doit être fourni. Ainsi, tout le principe de fonctionnement consiste à fournir un signal d'horloge à la tête d'impression, puis à envoyer des données à chaque période d'horloge, après avoir envoyé 384 signaux d'horloge et 384 données, les données du registre à décalage seront stockées dans le verrou. Ensuite, le verrou est réglé sur un niveau bas. Ensuite, les 384 points de chauffage choisiront de chauffer ou de ne pas chauffer selon que chaque donnée est 0 ou 1. En même temps, laissez le moteur pas à pas tourner pour entraîner le papier thermique afin de concevoir le caractère souhaité.
Après avoir obtenu la tête d'impression thermique, je suis allé de l'avant et j'ai demandé une fiche technique et c'était un câble FPC à 30 broches. Ce n'est donc évidemment pas très pratique de se connecter au pico directement avec celui-ci. J'ai donc pensé que je ferais mieux de concevoir un circuit de fond de panier.
j'ai un STONE écran série est une alimentation 12v, puis je regarde la tension d'impression de la tête d'impression thermique d'une valeur de référence est de 7.6v, la valeur maximale est de 8v, puis lui fournir une tension d'environ 7.6v. Il a également une tension logique de 3.3 V, puis le Raspberry Pi pico prend en charge l'alimentation maximale de 5 V et il a une tension de sortie de 3.3 V, puis la conception de l'alimentation peut utiliser deux DC DC, avec une alimentation 12 V, une sortie DC DC 7.6 V. pour alimenter la tête d'impression thermique, l'autre sortie dcdc 5v vers le pico, puis utilisez le 3.3v du pico pour alimenter la tension logique de la tête d'impression thermique. Ensuite, 12v ouvre la voie directement à l'écran série.
Soit dit en passant, le moteur pas à pas de cette tête d'impression thermique doit également être entraîné. J'ai un intégrateur de tube Darlington intégré. Mais c'est trop gros, et c'est un simple plug-in, alors achetez simplement une puce de pilote. Ensuite, cet aspect du moteur d'entraînement est également OK.
L'impression nécessite la conception de la police, en gros, tout le monde utilise le spin flash pour le stockage des polices, ce qui est un projet énorme. Seul le code ASCII est supérieur à 100, vous devez donc acheter un autre flash SPF. Ensuite, toute la planification est presque comme ça.

Concevoir le circuit

Ensuite, les suivants ont commencé à concevoir le circuit. Tout d'abord, trouver l'alimentation, en fait, au début, j'utilisais un régulateur de tension à trois bornes, car le circuit est simple, après avoir été fait, la situation de chauffe était plus grave lors du débogage, très chaude au toucher, donc je change utiliser DCDC. Suivez simplement la fiche technique de la puce directement pour faire le schéma de circuit. J'ai choisi mt2492 ici, mais j'ai ignoré un paramètre important est le courant de fonctionnement de la tête d'impression, le courant de sortie maximum de cette puce est de 2A, mais le courant de fonctionnement de la tête d'impression de 2.3A, une différence de 0.3A, il peut également être utilisé, mais l'efficacité n'est pas si élevée, nous parlerons de l'effet spécifique plus tard.

système-de-gestion-de-parking

Ensuite, la puce de commande de moteur que j'ai achetée est lv8548, voir la fiche technique de la tête d'impression, qui contient un chronogramme d'entraînement de moteur pas à pas, en fonction de sa synchronisation, pour lui fournir un signal pwm à quatre voies.

système-de-gestion-de-parking

Vient ensuite la puce flash, avec by25q32bs, la capacité de 32Mbit est assez grande, et connectée au pico, attendant d'être appelée par le pico.

système-de-gestion-de-parking

Après cela, le schéma de circuit global est comme ceci, le coin supérieur gauche est la prise de communication et la prise d'alimentation, en dessous il y a un buzzer (pas réellement utilisé dans le circuit), il y a une diode électroluminescente à droite, et le coin inférieur droit est un FPC 30 broches pour connecter la tête d'impression.

système-de-gestion-du-parkingsystème-de-gestion-du-parking

Le pico Raspberry Pi

système-de-gestion-de-parking

Mettez sous tension, d'abord non connecté au pico et à la tête d'impression, mesurez la tension de sortie du dcdc, dans le cas normal, l'un est d'environ 7.5 v, l'autre d'environ 5 v.

système-de-gestion-de-parking

système-de-gestion-de-parking

système-de-gestion-de-parking

Ensuite, connectez la tête d'impression, l'écran série et le pico, mesurez la tension logique est d'environ 3.3 v, après aucun problème, vous pouvez écrire le programme.

Programme

J'ai l'intention de régler d'abord le moteur pas à pas, cette pièce est facile à régler, regardez le diagramme de synchronisation dans la fiche technique, 8 périodes d'horloge, chaque période d'horloge doit donner séparément aux quatre broches du moteur un signal logique, après 8 périodes, le moteur tournera vers le haut, puis régler la vitesse, mais au milieu, il faut ajouter un délai pour ajuster le rapport cyclique sinon il tourne trop vite, le temps de délai que j'ai réglé est d'environ 5ms et puis après l'avoir laissé tourner il faut donner le niveau à bas, sinon le moteur ne semble pas tourner en fait la bobine interne est toujours sous tension, après un long moment on sent l'odeur de brûlé.
Ensuite, écrivez la fonction, mettez le corps dans une boucle, le nombre de cycles représente la durée de rotation du moteur, la fonction a l'air un peu longue, placez-la ailleurs seule et attendez l'appel.

système-de-gestion-de-parking

système-de-gestion-de-parking

C'est la fonction après quelques changements, la vitesse et la durée seront transmises dans le programme principal. Il a encore besoin de beaucoup d'optimisation.
Vient ensuite le point de réglage de la tête d'impression, cette partie est difficile pour moi, elle a besoin d'un signal d'horloge, la fiche technique est écrite dans le maximum 8M, je pensais qu'il fallait un signal d'environ 8M de fréquence, c'est difficile, d'abord je mesuré la fréquence avec le niveau de bascule io, la différence est trop.
Et puis je veux utiliser une épingle, et j'ai fait des recherches pendant une journée entière mais le résultat n'est pas bon, mes compétences personnelles sont limitées, j'ai probablement besoin d'étudier en profondeur la puce rp2040 manuellement.
Ensuite, retournez le niveau 384 périodes pour essayer, c'est un flux de travail comme celui-ci, initialisez l'entrée de données 1 broche, verrouillez 1 broche, signal d'horloge 1 broche, 6 broches d'unité d'impression, puis en plus du verrou, tous les autres tirent vers le bas, et puis envoyez une donnée dans une période d'horloge, après avoir fait 384 cycles pour régler le verrou sur 0, pour régler l'unité d'impression 6 sur 1, puis quel point a des données quel point sera chauffé. Après la mise en œuvre de l'ensemble, tirez le niveau vers l'arrière.
Ensuite, une fois que le programme a été écrit et a commencé à être testé, cela n'a vraiment pas fonctionné, en fait parce que trop d'unités d'impression étaient contrôlées mais que le courant n'était pas suffisant, puis modifiez-le pour donner moins de deux unités d'impression de haut niveau et testez à nouveau.

système-de-gestion-de-parking

ça marche vraiment ! Il a imprimé une ligne horizontale.
Cela signifie qu'il n'y a pas de limite inférieure sur la fréquence d'horloge, alors vous pouvez exécuter le moteur pas à pas pour imprimer une ligne verticale. pico dual thread, puis laissez l'autre thread tourner le moteur de manière synchrone, puis écrivez le programme et exécutez-le. La ligne verticale sort.

système-de-gestion-de-parking

Avec les lignes horizontales et verticales, puis obtenez une ligne diagonale, faites attention à une unité d'impression a 64 points, qui définit une longueur, telle que 32, puis cyclez 32 fois 384 périodes, chaque période ne définit que les 64 premières données à 1 et définissez les 320 données suivantes sur 0, puis 32 fois à chaque fois uniquement dans la première unité pour imprimer un point, puis effectuer un cycle incrémentiel, combiné à la vitesse du moteur pas à pas à ajuster, et enfin ajusté sur la taille 64 * 32 de la diagonale, vous pouvez aussi d'abord épeler une lettre Z.

système-de-gestion-de-parking

Ensuite, le plan du programme est là, si vous voulez imprimer le mot, vous devez d'abord faire la police. Faites d'abord une lettre majuscule A, 32 * 32 tailles, avec une liste de définitions, que je prévois de faire ici avec une épingle. value (), faites donc la police, puis utilisez 32 lignes et 32 ​​colonnes de valeurs binaires à appeler, sortez pour faire un décalage, puis passez à épingler. valeur (), c'est donc le processus de mise en œuvre.

système-de-gestion-de-parking

Avec 0 comme arrière-plan et 1 comme premier plan, le processus de mise en œuvre réel ressemble alors à ceci.

système-de-gestion-de-parking

Le grand cycle le plus externe 32 représente le cycle de 32 lignes, c'est-à-dire imprimez 32 lignes, puis les 32 premiers cycles à l'intérieur consistent à chauffer la moitié de la première unité de chauffage, puis les 352 périodes restantes seront définies sur 0, et puis moins 1 de 31 à chaque fois jusqu'à 0, on peut compter la première ligne des points qu'il faut chauffer de gauche à droite, puis toutes les 384 périodes à compléter une fois la gâche réglée à 0 et le groupe de chauffe réglé à 1 puis vous pouvez imprimer, puis un mot A après avoir à nouveau bouclé 32 fois.

système-de-gestion-de-parking

Toujours audacieux, ce genre de mot matriciel, il y a des outils en ligne on peut faire directement, le recto plus 0b puis ajouter une virgule au verso, et puis vous jouez selon vos propres idées, la police est en fait initialement destinée à être stocké dans la puce flash, mais j'ajuste longtemps qu'il ne peut toujours pas être ouvert.

système-de-gestion-de-parking

Je ne sais pas où est le problème, après avoir eu le temps, je m'ajusterai à nouveau, la bonne chose est que pico lui-même a un flash de taille 16mbit, stocker une bibliothèque ASCII est encore suffisant, alors je suis tellement stocké.

système-de-gestion-de-parking

Définissez-le avec un dictionnaire, mettez-le dans un morceau séparé et rappelez-le dans le programme principal. Ensuite, après le débogage, la version disponible ressemble à ceci.
from machine import Pin
from time import sleep
import _thread
import rp2
from array import array
import ascii_ku
import speed_motor
#import sys
delaytime = 0.0000001 # Printer clock delay
motor = 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 motor
mov_bit = 0
PRINTER_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 = 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) + 1
if (len(shuru) % 12) == 0:
line -= 1
lins = 0
supper = 0
slower = 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()

Je suis une unité d'impression de contrôle séparée, car le courant n'est pas suffisant, mais pour imprimer clairement, ma vitesse d'impression devient particulièrement lente, plus il y a de mots, plus lent est lent, puis les lettres minuscules sont 24 * 32 matrice de points , qu'il y a moins de points d'impression à utiliser, mais ne peut pas lui donner de laisser 32 points de chauffage d'espace alors l'espacement des caractères est grand, donc les majuscules et les minuscules sont séparées, les chiffres sont toujours 32 * 32. Ensuite, l'impression peut atteindre les fonctions de base, mais il y a deux fonctions auxiliaires qui n'ont pas été faites, l'une est le manque de détection de papier et de protection contre la surchauffe, la partie circuit a été faite, le programme je n'ai toujours pas le temps de le faire.
Temporairement d'abord une attention manuelle pour renouveler le papier et ne pas laisser la tête chauffante le chauffer pendant longtemps.
L'étape suivante consiste à faire l'accepteur de pièces, et j'ai constaté que le circuit avait oublié de laisser un port de câblage pour l'accepteur de pièces, je vais donc connecter les fils à l'arrière de la carte.
Heureusement, une seule ligne de signal à utiliser pour l'accepteur de pièces, puis regardez mon pico, il y a un GP28 disponible sur le côté droit, mais, après connexion, le signal ne peut pas être mesuré, j'ai donc changé pour utiliser le GP22 , le même programme, je ne comprends pas pourquoi le GP28 ne peut pas être utilisé.

système de gestion de stationnement(20)

Finally, the whole program is attached.
from machine import UART,Pin
from time import sleep
import _thread
import rp2
from array import array
import ascii_ku
import speed_motor
from os import uname
#import sys
uart1 = 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 delay
coin = Pin(22, Pin.IN,Pin.PULL_UP)
coin_num = 0
motor = 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 motor
mov_bit = 0
PRINTER_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 -= 1
lins = 0
supper = 0
slower = 0
danjia = 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 += 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 += 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 += 1
def 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 = False
def floor2def():
pass
def floor3def():
pass
def 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()

Remonter en haut