रास्पबेरी पाई पिको और स्टोन टीएफटी एलसीडी पर आधारित पार्किंग प्रबंधन प्रणाली के लिए थर्मल प्रिंट हेड

संक्षिप्त परिचय

थर्मल प्रिंटर हमारे दैनिक जीवन में बहुत आम हैं, और रेस्तरां, पार्किंग स्थल और खरीदारी में थर्मल प्रिंटर के उदाहरण हैं। यह लेख पार्किंग सिस्टम में थर्मल प्रिंटर के अनुप्रयोग पर केंद्रित होगा।

रास्पबेरी पाई पिको और स्टोन टीएफटी एलसीडी आईओटी प्लेटोब्लॉकचैन डेटा इंटेलिजेंस पर आधारित पार्किंग प्रबंधन प्रणाली के लिए थर्मल प्रिंट हेड। लंबवत खोज। ऐ.

उपयोग की जाने वाली सामग्री

स्टोन STWI101WT-01
एफ़टीपी थर्मल प्रिंटर हेड
रास्पबेरी पाई पिको
- सिक्का संचालित मशीन
समारोहनियंत्रण फ़ंक्शन सीरियल स्क्रीन पर प्रदर्शित होता है, मुख्य इंटरफ़ेस फर्श का चयन करता है, मुख्य इंटरफ़ेस में प्रवेश करने के बाद पार्किंग स्थान का चयन करता है, साथ ही यह शीर्ष दाईं ओर टेक्स्ट बॉक्स में पार्किंग स्थान संख्या प्रदर्शित करेगा, फिर चयन करेगा रुकने का समय, यह दो स्क्रॉलिंग टेक्स्ट चयनकर्ता हैं, फिर वही निश्चित इकाई मूल्य के अनुसार शीर्ष दाईं ओर टेक्स्ट बॉक्स में ऑर्डर की जानकारी प्रदर्शित करेगा जो कुल मूल्य प्राप्त करने के लिए ठहरने के समय से गुणा करता है। तभी जब पार्किंग की जगह और ठहरने का समय चुना जाता है, तो आप भुगतान बटन पर जा सकते हैं, अन्यथा यह अमान्य है। भुगतान स्क्रीन में प्रवेश करने के बाद, एक सिक्का स्वीकर्ता का उपयोग किया जाएगा। फिर स्क्रीन में डाले जाने वाले सिक्कों की संख्या और पहले से डाले गए सिक्कों की संख्या दिखाई देगी। सिक्के डालने के बाद, एक भुगतान सफलता संदेश प्रदर्शित होगा। फिर आप थर्मल पेपर पर स्थान संख्या और समय प्रिंट करने के लिए एक छोटा टिकट प्रिंट करना चुन सकते हैं।डिजाइन प्रक्रियासबसे पहले मैं का उपयोग करना चाहता था रास्पबेरी पाई पिको एक छोटा प्रिंटर बनाने के लिए। फिर घटकों के चयन की प्रक्रिया में मुझे लगता है कि थर्मल प्रिंटर हासिल करना अधिक सुविधाजनक है, कार्यक्रम का निर्धारण करने के बाद, मैंने हार्डवेयर खरीदना शुरू किया। वास्तव में, ऑनलाइन खरीद की प्रक्रिया में मैंने पाया कि अच्छे ड्राइवर सर्किट वाले कई थर्मल प्रिंटर हैं, उनमें से अधिकांश एसटीएम की चिप का उपयोग करके बनाए गए हैं, और वे अपने स्वयं के निर्देशों के सेट के साथ डिज़ाइन किए गए हैं। उदाहरण के लिए, उसके निर्देशों का उपयोग करके प्रिंटर को अक्षर प्रिंट करने दें या कागज़ पर जाने दें, लेकिन यह प्रिंटर व्यावहारिकता बहुत अधिक है, लेकिन सीखने का कोई मूल्य नहीं है। यह लाइन पर सीरियल पोर्ट के माध्यम से निर्देश भेजने के लिए है, आप प्रिंटर में हेरफेर कर सकते हैं। इसलिए मैंने सोचा कि मैं एक प्रिंट हेड खरीदूंगा और इसे स्वयं विकसित करूंगा। फिर प्रिंट हेड के बारे में, मैंने एक ftp थर्मल प्रिंट हेड चुना।एफ़टीपी थर्मल प्रिंट हेड
यह प्रिंट हेड अंतरराष्ट्रीय स्तर पर उपलब्ध होना चाहिए, मूल सिद्धांत समान हैं। बाईं ओर एक स्टेपर मोटर है। फिर मध्य शीर्ष 6 ताप इकाइयाँ हैं। प्रत्येक हीटिंग यूनिट में 64 हीटिंग पॉइंट होते हैं। तो कुल 384 ताप बिंदु। फिर नीचे एक कुंडी है। कुंडी के नीचे एक शिफ्ट रजिस्टर है। अंत में, एक घड़ी संकेत प्रदान किया जाना है। तो ऑपरेशन का पूरा सिद्धांत प्रिंट हेड को एक घड़ी संकेत प्रदान करना है और फिर हर घड़ी की अवधि में एक डेटा भेजना है, 384 घड़ी संकेत और 384 डेटा भेजने के बाद, शिफ्ट रजिस्टर में डेटा कुंडी में संग्रहीत किया जाएगा। फिर कुंडी को निम्न स्तर पर सेट किया जाता है। फिर 384 हीटिंग पॉइंट्स प्रत्येक डेटा 0 या 1 के अनुसार गर्म करने के लिए गर्मी का चयन करेंगे या नहीं। साथ ही, वांछित चरित्र को डिजाइन करने के लिए थर्मल पेपर को चलाने के लिए स्टेपर मोटर को घुमाने दें। थर्मल प्रिंट मिलने के बाद सिर, मैंने आगे बढ़कर एक डेटाशीट मांगी और यह एक 30pin fpc केबल थी। तो स्पष्ट रूप से इसके साथ सीधे पिको से जुड़ना बहुत सुविधाजनक नहीं है। तो मैंने सोचा कि मैं एक बैकप्लेन सर्किट को बेहतर तरीके से डिजाइन करूंगा। मेरे पास एक है स्टोन सीरियल स्क्रीन 12v बिजली की आपूर्ति है, और फिर मैं संदर्भ मान के थर्मल प्रिंट हेड प्रिंटिंग वोल्टेज को 7.6v देखता हूं, अधिकतम मान 8v है, फिर इसे लगभग 7.6v का वोल्टेज प्रदान करें। इसमें एक तर्क वोल्टेज भी है 3.3v, और फिर रास्पबेरी पाई पिको अधिकतम समर्थन 5v बिजली की आपूर्ति और इसमें 3.3v आउटपुट वोल्टेज है, फिर बिजली आपूर्ति डिजाइन दो dcdc का उपयोग कर सकता है, 12v बिजली की आपूर्ति के साथ, एक dcdc आउटपुट 7.6v थर्मल प्रिंट हेड को पावर देने के लिए, अन्य dcdc आउटपुट 5v पिको को, और फिर थर्मल प्रिंट हेड लॉजिक वोल्टेज को पावर देने के लिए पिको से 3.3v का उपयोग करें। फिर 12v सीधे सीरियल स्क्रीन पर ले जाता है।
वैसे, उस थर्मल प्रिंट हेड के लिए स्टेपर मोटर को भी चलाना पड़ता है। मेरे पास एक एकीकृत डार्लिंगटन ट्यूब इंटीग्रेटर है। लेकिन यह बहुत बड़ा है, और यह सीधे प्लग-इन है, इसलिए बस एक ड्राइवर चिप खरीदें। फिर ड्राइव मोटर का यह पहलू भी ठीक है। प्रिंटिंग के लिए एक फॉन्ट के डिजाइन की आवश्यकता होती है, मूल रूप से हर कोई फॉन्ट स्टोरेज के लिए spi फ्लैश का उपयोग कर रहा है, जो एक बहुत बड़ा प्रोजेक्ट है। केवल एएससीआई कोड 100 से अधिक है, इसलिए आपको एक और एसपीएफ़ फ्लैश खरीदना होगा। फिर पूरी प्लानिंग लगभग ऐसी ही है.
स्टोन डिजाइनर (जीयूआई डिजाइनर सॉफ्टवेयर)से:https://www.stoneitech.com/support/download/software
सर्किट डिजाइन करेंफिर निम्नलिखित ने सर्किट को डिजाइन करना शुरू किया। पहले बिजली की आपूर्ति का पता लगाएं, वास्तव में, शुरुआत में मैंने तीन-टर्मिनल वोल्टेज नियामक का उपयोग किया, क्योंकि सर्किट सरल है, बनाया जाने के बाद, डिबगिंग के दौरान हीटिंग की स्थिति अधिक गंभीर थी, स्पर्श करने के लिए बहुत गर्म, इसलिए मैं उपयोग करने के लिए बदल जाता हूं डीसी डीसी। सर्किट आरेख करने के लिए सीधे चिप डेटा शीट का पालन करें। मैंने यहां mt2492 को चुना, लेकिन मैंने एक महत्वपूर्ण पैरामीटर को नजरअंदाज कर दिया, वह है प्रिंट हेड ऑपरेटिंग करंट, इस चिप का अधिकतम आउटपुट करंट 2A है, लेकिन प्रिंट हेड ऑपरेटिंग करंट 2.3A, 0.3A का अंतर है, इसका उपयोग भी किया जा सकता है, लेकिन दक्षता इतनी अधिक नहीं है, हम बाद में विशिष्ट प्रभाव के बारे में बात करेंगे।
फिर मेरे द्वारा खरीदी गई मोटर ड्राइवर चिप lv8548 है, प्रिंट हेड डेटा शीट देखें, जिसमें स्टेपर मोटर ड्राइव टाइमिंग आरेख है, इसके समय के अनुसार, इसे चार-तरफा pwm सिग्नल प्रदान करने के लिए।
फिर फ्लैश चिप है, by25q32bs के साथ, 32Mbit की क्षमता काफी बड़ी है, और पिको से जुड़ा है, पिको द्वारा कॉल किए जाने की प्रतीक्षा कर रहा है।
उसके बाद, समग्र सर्किट आरेख इस तरह है, ऊपरी बाएँ कोने में संचार सॉकेट और बिजली आपूर्ति सॉकेट है, नीचे एक बजर है (वास्तव में सर्किट में उपयोग नहीं किया जाता है), दाईं ओर एक प्रकाश उत्सर्जक डायोड है, और प्रिंट हेड को जोड़ने के लिए निचला दायां कोना 30pin fpc है।
हो जाने के बाद और उपयोग किया जा सकता है जैसा कि नीचे दिखाया गया है, रास्पबेरी पाई पिको के लिए बोर्ड पर एक पिन हेडर रिसेप्टेक छोड़कर, आप सीधे इसमें प्लग कर सकते हैं।
रास्पबेरी पाई पिको
बिजली चालू करें, पहले पिको और प्रिंट हेड से जुड़ा नहीं है, डीसीडीसी के आउटपुट वोल्टेज को मापें, सामान्य स्थिति में एक लगभग 7.5v है, दूसरा लगभग 5v है।
फिर प्रिंट हेड, सीरियल स्क्रीन और पिको को कनेक्ट करें, लॉजिक वोल्टेज को लगभग 3.3v मापें, बिना किसी समस्या के, आप प्रोग्राम लिख सकते हैं।
कार्यक्रममैं पहले स्टेपर मोटर को समायोजित करने का इरादा रखता हूं, इस हिस्से को समायोजित करना आसान है, डेटा शीट में समय आरेख को देखें, 8 घड़ी की अवधि, प्रत्येक घड़ी की अवधि को अलग से मोटर के चार पिनों को एक तर्क संकेत देना चाहिए, 8 अवधि के बाद मोटर होगा चालू करें, और फिर गति को समायोजित करें, लेकिन बीच में हमें शुल्क अनुपात को समायोजित करने के लिए एक विलंब जोड़ना होगा अन्यथा यह बहुत तेज़ हो जाता है, मेरे द्वारा निर्धारित विलंब समय लगभग 5ms है और फिर इसे चालू करने के बाद आपको स्तर देना होगा कम, अन्यथा मोटर वास्तव में चालू नहीं होती है, वास्तव में आंतरिक कुंडल अभी भी बिजली पर है, लंबे समय के बाद आप जलती हुई गंध को सूंघ सकते हैं। फिर फ़ंक्शन लिखें, शरीर को एक लूप में रखें, चक्रों की संख्या का प्रतिनिधित्व करती है मोटर रोटेशन की लंबाई, फ़ंक्शन थोड़ा लंबा दिखता है, इसे कहीं और अकेले रखें और कॉल की प्रतीक्षा करें।
कुछ बदलावों के बाद यह फ़ंक्शन है, मुख्य कार्यक्रम में गति और अवधि प्रसारित की जाएगी। इसे अभी भी बहुत अधिक अनुकूलन की आवश्यकता है। फिर प्रिंट हेड को समायोजित करने की बात है, यह हिस्सा मेरे लिए मुश्किल है, इसे एक घड़ी संकेत की आवश्यकता है, डेटा शीट अधिकतम 8M में लिखी गई है, मुझे लगा कि इसे लगभग 8M के सिग्नल की आवश्यकता है आवृत्ति, यह मुश्किल है, पहले मैंने आवृत्ति को io फ्लिप स्तर से मापा, अंतर बहुत अधिक है। और फिर मैं पीआईओ का उपयोग करना चाहता हूं, और मैंने पूरे दिन शोध किया लेकिन परिणाम अच्छा नहीं है, मेरे व्यक्तिगत कौशल सीमित हैं, शायद मुझे आरपी 2040 चिप मैनुअल का गहराई से अध्ययन करने की आवश्यकता है। फिर कोशिश करने के लिए स्तर 384 अवधि फ्लिप करें, यह एक है इस तरह से वर्कफ़्लो, डेटा इनपुट 1 पिन, लैच 1 पिन, क्लॉक सिग्नल 1 पिन, 6 प्रिंट यूनिट पिन, और फिर लैच के अलावा अन्य सभी पुल लो को इनिशियलाइज़ करें, और फिर 384 साइकिल चलाने के बाद एक घड़ी की अवधि के भीतर एक डेटा भेजें। कुंडी को 0 पर सेट करने के लिए, 6 प्रिंट इकाई को 1 पर सेट करने के लिए, और फिर किस बिंदु पर डेटा है, किस बिंदु को गर्म किया जाएगा। सेट के कार्यान्वयन के बाद, स्तर को वापस खींचो। फिर कार्यक्रम लिखे जाने और परीक्षण शुरू करने के बाद, यह वास्तव में काम नहीं करता था, वास्तव में क्योंकि बहुत सारी प्रिंट इकाइयां नियंत्रित थीं लेकिन वर्तमान पर्याप्त नहीं था, फिर इसे कम देने के लिए बदलें दो प्रिंट इकाइयाँ उच्च स्तर और फिर से परीक्षण करें।
यह वास्तव में काम कर रहा है! यह एक क्षैतिज रेखा मुद्रित करता है। इसका मतलब है कि घड़ी की आवृत्ति पर कोई निचली सीमा नहीं है, फिर आप एक लंबवत रेखा मुद्रित करने के लिए स्टेपर मोटर चला सकते हैं। पिको डुअल थ्रेड, फिर दूसरे थ्रेड को मोटर को सिंक्रोनस चलाने दें, फिर प्रोग्राम लिखें और चलाएं। खड़ी रेखा निकलती है।
क्षैतिज और लंबवत रेखाओं के साथ, फिर एक विकर्ण रेखा प्राप्त करें, ध्यान दें कि एक प्रिंट इकाई में 64 अंक होते हैं, जो लंबाई को परिभाषित करता है, जैसे कि 32, और फिर चक्र 32 गुना 384 अवधि, प्रत्येक अवधि केवल पहले 64 डेटा को 1 पर सेट करती है और अगले 320 डेटा को 0 पर सेट करें, और फिर 32 बार हर बार केवल पहली इकाई में एक बिंदु मुद्रित करने के लिए और फिर चक्र वृद्धिशील, समायोजित करने के लिए स्टेपर मोटर की गति के साथ संयुक्त, और अंत में 64 * 32 आकार को समायोजित करें विकर्ण रेखा, आप पहले एक अक्षर Z भी लिख सकते हैं।
फिर कार्यक्रम की रूपरेखा है, यदि आप उस शब्द को प्रिंट करना चाहते हैं जो आपको पहले फ़ॉन्ट करने की आवश्यकता है। पहले एक बड़े अक्षर A, 32 * 32 आकार, परिभाषाओं की एक सूची के साथ, मैं यहां पिन.वैल्यू () के साथ करने की योजना बना रहा हूं, इसलिए फ़ॉन्ट बनाएं, फिर 32 पंक्तियों और बाइनरी मानों के 32 कॉलम को कॉल करने के लिए उपयोग करें, शिफ्ट करने के लिए बाहर निकलें और फिर पिन.वैल्यू () को पास करें, इसलिए यह कार्यान्वयन की प्रक्रिया है।
पृष्ठभूमि के रूप में 0 और अग्रभूमि के रूप में 1 के साथ, वास्तविक कार्यान्वयन प्रक्रिया तब इस तरह दिखती है।
सबसे बाहरी बड़ा चक्र 32 32 लाइनों के चक्र का प्रतिनिधित्व कर रहा है, यानी 32 लाइनों को प्रिंट करें, और फिर पहले 32 चक्रों को पहले हीटिंग यूनिट के आधे हिस्से को गर्म करना है, फिर शेष 352 अवधियों को 0 पर सेट किया जाएगा, और फिर माइनस 1 से 31 से हर बार 0 तक, आप उन बिंदुओं की पहली पंक्ति को गिन सकते हैं जिन्हें बाएं से दाएं गर्म करने की आवश्यकता होती है, और फिर प्रत्येक 384 अवधियों को पूरा करने के लिए एक बार कुंडी सेट 0 और हीटिंग यूनिट सेट 1 और फिर आप प्रिंट कर सकते हैं, और फिर 32 बार फिर से लूप करने के बाद एक शब्द आउट कर सकते हैं।
अभी भी बोल्ड, इस तरह के डॉट मैट्रिक्स शब्द, ऑनलाइन उपकरण हैं जिन्हें सीधे किया जा सकता है, फ्रंट प्लस 0 बी और फिर पीठ पर एक अल्पविराम जोड़ें, और फिर आप अपने विचारों के अनुसार खेलते हैं, फ़ॉन्ट वास्तव में शुरू में होने का इरादा है फ्लैश चिप में संग्रहीत, लेकिन मैं इसे लंबे समय तक समायोजित करता हूं फिर भी इसे खोला नहीं जा सकता है।
मुझे नहीं पता कि समस्या कहां है, मेरे पास समय होने के बाद मैं फिर से समायोजित करूंगा, अच्छी बात यह है कि पिको में 16 एमबी आकार का फ्लैश है, एक एसीआईआई पुस्तकालय स्टोर करना अभी भी पर्याप्त है, फिर मैं इतना संग्रहित हूं।
इसे एक शब्दकोश के साथ परिभाषित करें, इसे एक अलग टुकड़े में रखें, और इसे मुख्य कार्यक्रम में वापस बुलाएं। 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()
स्रोत: प्लेटो डेटा इंटेलिजेंस