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

הקדמה קצרה

מדפסות תרמיות נפוצות מאוד בחיי היום יום שלנו, וישנן דוגמאות למדפסות תרמיות במסעדות, בחניונים ובקניות. מאמר זה יתמקד ביישום של מדפסות תרמיות במערכות חניה.

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

חומרים לשימוש

STONE STWI101WT-01
ראש מדפסת תרמי FTP
פטל פי פיקו
- מכונה המופעלת באמצעות מטבעות
פונקציהפונקציית הבקרה מוצגת במסך הטורי, הממשק הראשי בוחר את הקומה, לאחר הכניסה לממשק הראשי בוחר את מקום החניה, במקביל יציג את מספר החניה בתיבת הטקסט בצד ימין למעלה, לאחר מכן בוחר את זמן שהייה, זה שני בוררי טקסט גלילה, ואז זה גם יציג את פרטי ההזמנה בתיבת הטקסט בצד ימין למעלה, לפי מחיר היחידה הקבוע שמכפיל את זמן השהייה כדי לקבל את המחיר הכולל. לאחר מכן רק כאשר נבחר מקום החניה וזמן השהייה, ניתן לעבור לכפתור התשלום, אחרת הוא אינו חוקי. לאחר כניסה למסך התשלום, ייעשה שימוש במקבל מטבעות. לאחר מכן המסך יראה את מספר המטבעות שיש להכניס ומספר המטבעות שכבר הוכנסו. לאחר הכנסת המטבעות, תוצג הודעת הצלחה בתשלום. לאחר מכן תוכלו לבחור להדפיס כרטיס קטן להדפסת מספר המקום והשעה על הנייר התרמי.תהליך העיצובבהתחלה רציתי להשתמש ב פטל פי פיקו לעשות מדפסת קטנה. ואז בתהליך בחירת הרכיבים אני חושב שהמדפסת התרמית נוחה יותר להשגה, לאחר קביעת התוכנית, התחלתי לרכוש חומרה. למעשה, בתהליך הרכש המקוון גיליתי שיש הרבה מדפסות תרמיות עם מעגלי דרייבר טובים, רובן מיוצרות באמצעות השבב של stm, והן מעוצבות עם סט הוראות משלהן. לדוגמה, על ידי שימוש בהוראות שלו לתת למדפסת להדפיס תווים או ללכת על נייר, אבל הפרקטיות של המדפסת הזו גבוהה מאוד, אבל אין ערך ללמידה. זה לשלוח הוראות דרך היציאה הטורית על הקו, אתה יכול לתפעל את המדפסת. אז חשבתי לקנות ראש הדפסה ולפתח אותו בעצמי. ואז לגבי ראש ההדפסה, בחרתי בראש הדפסה תרמי ftp.ראש ההדפסה התרמי ftp
ראש הדפסה זה צריך להיות זמין בינלאומי, העקרונות הבסיסיים דומים. הצד השמאלי הוא מנוע צעד. ואז הראש האמצעי הוא 6 יחידות חימום. על כל יחידת חימום 64 נקודות חימום. אז בסך הכל 384 נקודות חימום. ואז למטה יש תפס. מתחת לבריח נמצא אוגר משמרות. לבסוף, יש לספק אות שעון. אז כל עקרון הפעולה הוא לספק אות שעון לראש ההדפסה ואז לשלוח נתונים בכל תקופת שעון, לאחר שליחת 384 אותות שעון ו-384 נתונים, הנתונים באוגר המשמרות יאוחסנו בתפס. אז התפס מוגדר לרמה נמוכה. ואז 384 נקודות החימום יבחרו לחמם או לא לחמם לפי אם כל נתון הוא 0 או 1. במקביל, תן למנוע הצעד להסתובב כדי להניע את הנייר התרמי לעיצוב התו הרצוי. לאחר שקיבלתי את ההדפסה התרמית head, הלכתי וביקשתי גיליון נתונים וזה היה כבל fpc 30 פינים. אז ברור שזה לא מאוד נוח להתחבר לפיקו ישירות איתו. אז חשבתי שעדיף לעצב מעגל אחורי. יש לי מסך טורי של STONE הוא ספק כוח של 12 וולט, ואז אני מסתכל על מתח ההדפסה של ראש ההדפסה התרמי של ערך ייחוס הוא 7.6 וולט, הערך המרבי הוא 8 וולט, ואז מספק לו מתח של בערך 7.6 וולט. יש לו גם מתח לוגי הוא 3.3 וולט, ולאחר מכן ה-Raspberry Pi pico תומך בספק כוח של 5 וולט ויש לו מתח פלט של 3.3 וולט, ואז עיצוב ספק הכוח יכול להשתמש בשני DCDC, עם ספק כוח 12V, פלט dcdc אחד 7.6V כדי להפעיל את ראש ההדפסה התרמי, פלט ה-dcdc השני 5v ל-Pico, ולאחר מכן להשתמש ב-3.3V מה-Pico כדי להפעיל את המתח הלוגי של ראש ההדפסה התרמי. ואז 12v מובילים את הדרך ישירות למסך הטורי.
אגב, גם את מנוע הצעד של ראש ההדפסה התרמי הזה צריך להניע. יש לי אינטגרטור משולב של צינורות דרלינגטון. אבל זה גדול מדי, וזה פלאגין ישר, אז פשוט קנה שבב דרייבר. אז גם ההיבט הזה של מנוע הכונן בסדר. הדפסה דורשת עיצוב של גופן, בעצם כולם משתמשים ב-spi flash לאחסון גופנים, שזה פרויקט ענק. רק קוד ascii הוא יותר מ-100, אז אתה צריך לקנות פלאש SPF נוסף. ואז כל התכנון הוא כמעט כזה.
STONE Designer （תוכנת GUI Designer）מ:https://www.stoneitech.com/support/download/software
תכנן את המעגלואז החלו הבאים לתכנן את המעגל. ראשית מצא את ספק הכוח, למעשה, בהתחלה השתמשתי בווסת מתח תלת-מסוף, כי המעגל הוא פשוט, לאחר ביצוע, מצב החימום היה חמור יותר במהלך איתור באגים, חם מאוד למגע, אז אני משנה לשימוש dcdc. פשוט עקוב אחר גיליון הנתונים של השבב ישירות כדי לעשות את דיאגרמת המעגל. בחרתי כאן mt2492, אבל התעלמתי מפרמטר חשוב הוא זרם ההפעלה של ראש ההדפסה, זרם היציאה המקסימלי של השבב הזה הוא 2A, אבל זרם ההפעלה של ראש ההדפסה של 2.3A, הבדל של 0.3A, ניתן להשתמש בו גם, אבל היעילות לא כל כך גבוהה, נדבר על האפקט הספציפי מאוחר יותר.
אחר כך שבב נהג המנוע שקניתי הוא lv8548, עיין בגיליון הנתונים של ראש ההדפסה, הכולל דיאגרמת תזמון כונן מנוע צעד, בהתאם לתזמון שלו, כדי לספק לו אות pwm בארבעה כיוונים.
ואז שבב הפלאש, עם by25q32bs, קיבולת של 32Mbit הוא די גדול, ומחובר לפיקו, ממתין שיקראו לו על ידי Pico.
לאחר מכן, דיאגרמת המעגלים הכללית היא כזו, הפינה השמאלית העליונה היא שקע התקשורת ושקע אספקת החשמל, מתחת יש זמזם (לא ממש בשימוש במעגל), יש דיודה פולטת אור מימין, ו הפינה הימנית התחתונה היא 30 פינים fpc לחיבור ראש ההדפסה.
לאחר ביצוע וניתן להשתמש בו הוא כפי שמוצג להלן, תוך השארת שקע ראשי פינים על הלוח עבור Raspberry Pi pico, אתה יכול לחבר אליו ישירות.
ה-Raspberry Pi pico
הפעל את המתח, תחילה לא מחובר לפיקו ולראש ההדפסה, מדוד את מתח המוצא של ה-dcdc, במקרה הרגיל אחד הוא בערך 7.5v, השני הוא בערך 5v.
לאחר מכן חבר את ראש ההדפסה, המסך הטורי ופיקו, מדוד את המתח הלוגי הוא בערך 3.3V, לאחר שאין בעיה, אתה יכול לכתוב את התוכנית.
תָכְנִיתאני מתכוון תחילה להתאים את מנוע הצעד, חלק זה קל להתאמה, תסתכל על דיאגרמת התזמון בדף הנתונים, 8 תקופות שעון, כל תקופת שעון צריכה לתת אות לוגי לארבעת הפינים של המנוע, לאחר 8 תקופות המנוע להגביר, ואז להתאים את המהירות, אבל באמצע אנחנו צריכים להוסיף השהיה כדי להתאים את יחס החובה אחרת הוא מסתובב מהר מדי, זמן ההשהיה שהגדרתי הוא בערך 5ms ואז לאחר שנתת לו להסתובב אתה חייב לתת את הרמה ל נמוך, אחרת נראה שהמנוע לא מסתובב למעשה הסליל הפנימי עדיין פועל, לאחר זמן רב אתה יכול להריח את הריח הבוער. לאחר מכן כתוב את הפונקציה, שים את הגוף בלולאה, מספר המחזורים מייצג את אורך סיבוב המנוע, הפונקציה נראית קצת ארוכה, שים אותה במקום אחר לבד וחכה לשיחה.
זוהי הפונקציה לאחר מספר שינויים, המהירות ומשך הזמן ישודרו בתוכנית הראשית. זה עדיין צריך הרבה אופטימיזציה. ואז זה העניין של התאמת ראש ההדפסה, החלק הזה קשה לי, הוא צריך אות שעון, גיליון הנתונים כתוב במקסימום 8M, חשבתי שצריך אות של בערך 8M תדר, זה קשה, תחילה מדדתי את התדר עם רמת היפוך io, ההבדל גדול מדי. ואז אני רוצה להשתמש ב-pio, וחקרתי יום שלם אבל התוצאה לא טובה, הכישורים האישיים שלי מוגבלים, כנראה שאני צריך ללמוד לעומק את המדריך של שבב rp2040. לאחר מכן הפוך את תקופות רמה 384 כדי לנסות, זה זרימת עבודה כזו, אתחל את כניסת הנתונים 1 פין, תפס 1 פין, אות שעון 1 פין, 6 פינים של יחידת הדפסה, ולאחר מכן בנוסף לבריח כל השאר למשוך נמוך, ולאחר מכן לשלוח נתונים אחד בתוך תקופת שעון אחת, לאחר מחזור 384 פעמים כדי להגדיר את התפס ל-0, כדי להגדיר את יחידת ההדפסה 6 ל-1, ולאחר מכן לאיזו נקודה יש נתונים איזו נקודה תחמם. לאחר היישום של הסט, משוך את הרמה אחורה. ואז אחרי שהתוכנית נכתבה והתחילה לבדוק, זה ממש לא עבד, בעצם בגלל שנשלטו יותר מדי יחידות הדפסה אבל הזרם לא הספיק, ואז שנה אותו כדי לתת פחות שתי יחידות הדפסה ברמה גבוהה ובדוק שוב.
זה באמת עובד! זה הדפיס קו אופקי. זה אומר שאין הגבלה נמוכה יותר על תדר השעון, אז אתה יכול להפעיל את מנוע הצעד כדי להדפיס קו אנכי. פיקו חוט כפול, ואז תן לחוט השני להפעיל את המנוע סינכרוני, ואז לכתוב את התוכנית ולהפעיל. הקו האנכי יוצא החוצה.
עם הקווים האופקיים והאנכיים, קבל קו אלכסוני, שימו לב ליחידת הדפסה אחת שיש לה 64 נקודות, שמגדירה אורך, כגון 32, ולאחר מכן מחזור 32 כפול 384 נקודות, כל נקודה רק קבע את 64 הנתונים הראשונים ל-1 והגדר את 320 הנתונים הבאים ל-0, ולאחר מכן 32 פעמים בכל פעם רק ביחידה הראשונה כדי להדפיס נקודה ולאחר מכן לבצע מחזור אינקרמנטלי, בשילוב עם המהירות של מנוע הצעד כדי להתאים, ולבסוף כוונן את הגודל של 64*32 קו אלכסוני, אתה יכול גם קודם לאיית אות Z.
אז המתאר של התוכנית נמצא שם, אם אתה רוצה להדפיס את המילה אתה צריך לעשות את הגופן קודם. תחילה תעשה אות גדולה בגודל 32*32, עם רשימת הגדרות, אני מתכנן לעשות כאן עם pin.value (), אז תעשה את הגופן, ואז השתמש ב-32 שורות ו-32 עמודות של ערכים בינאריים שיקראו, מוציאים לעשות תזוזה ואז עוברים ל-pin.value (), אז זה תהליך היישום.
עם 0 כרקע ו-1 כרקע, תהליך היישום בפועל נראה כך.
המחזור הגדול החיצוני ביותר 32 מייצג את המחזור של 32 שורות, כלומר הדפס 32 שורות, ואז 32 המחזורים הראשונים בפנים הם לחמם חצי מיחידת החימום הראשונה, ואז 352 התקופות הנותרות יוגדרו ל-0, ו לאחר מכן מינוס 1 מ-31 בכל פעם עד 0, אתה יכול לספור את השורה הראשונה של הנקודות שצריך לחמם משמאל לימין, ולאחר מכן כל 384 פרקים שיש להשלים ברגע שהתפס קבעו 0 ויחידת החימום קבעו 1 ואז אתה יכול להדפיס, ולאחר מכן מילה אחת לאחר לולאה 32 פעמים שוב.
עדיין מודגש, סוג זה של מילת מטריצת נקודות, יש כלים באינטרנט שניתן לעשות ישירות, הקדמי פלוס 0b ואז להוסיף פסיק מאחור, ואז אתה משחק לפי הרעיונות שלך, הגופן למעשה נועד להיות בהתחלה מאוחסן בשבב הבזק, אבל אני מכוון זמן רב עדיין לא ניתן לפתוח אותו.
אני לא יודע איפה הבעיה, אחרי שיהיה לי זמן אסתגל שוב, הדבר הטוב הוא שלפיקו עצמו יש פלאש בגודל 16mbit, אחסון ספריית ascii זה עדיין מספיק, ואז אני כל כך מאוחסן.
הגדירו אותו באמצעות מילון, הכניסו אותו ליצירה נפרדת והתקשרו אליו בחזרה בתוכנית הראשית. 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()
מקור: Plato Data Intelliigence