👨🏿‍🍳 👩‍👩‍👦 👨🏼‍🔬 "अर्डुइनो" की मदद से तिब्बती गायन के कटोरे का स्वचालन। साधु की जगह स्टीपर मोटर। वायरलेस प्रोग्रामिंग ⛏️ 👸🏼 ❗️

और तीन बार ईएसपी 6२६६ के अंतरिम समय से पहले के यात्रियों का स्थानांतरण।
भाग चार

तो यह सब हुआ। सबसे पहले, मैंने एक स्टेपर मोटर द्वारा नियंत्रित पर्दे के बारे में गाइटेम्स पर एक लेख देखा। मुझे याद आया कि मेरे पास एक ही इंजन दूसरे साल बेकार पड़ा था। फिर मेरी निगाह गायन के कटोरे पर पड़ी, जो अब पांच साल से शेल्फ पर धूल जमा रहा था। और फिर मेरे दिमाग में तरह-तरह के चतुर विचार आने लगे ...

नहीं, निश्चित रूप से, कभी-कभी मेरे मनोदशा के अनुसार, मैंने इस कप को अपने हाथों में ले लिया और कुछ समय के लिए इसमें से कई तरह की भड़कीली आवाजें निकालीं, लेकिन यह वह नहीं था जो मैं चाहता था। और मैं समानांतर में कुछ करना चाहता था, और उस समय कप को खुद ही आवाज़ देना चाहता था। यह स्पष्ट है कि एक हजार साल पहले इसके लिए एक अलग ~~गुलाम~~ आदमी की आवश्यकता होती थी, तीन सौ साल पहले यह एक परिष्कृत घड़ी की कलई का काम होगा, और अब ... खैर, अब हमारे पास एक स्टेपर मोटर और एक Arduino ProMini बोर्ड और अन्य ~~गैर-~~ परिष्कृत इलेक्ट्रॉनिक्स हैं। यह केवल ~~मवेशियों~~ पर थोड़ा कोड करने के लिए रहता है। और एक ही समय में सुनिश्चित करें कि यह तिब्बती छेनी एक ही समय में सटीक समय से लड़ता है - व्यर्थ, या ऐसा कुछ जो इतने सटीक समय सर्वर का उत्पादन करता है। और ESP8266 को उनके साथ संवाद करने दें, वह जानती है कि कैसे।

इसलिए ...

एक ताली के साथ एक गायन कटोरा है।

कटोरे के किनारे के खिलाफ मैलेट को हिट करना आवश्यक है। स्वचालित रूप से। साथ ही रिमोट कंट्रोल (और रिप्रोग्रामिंग!) की संभावना के साथ। और बस एक पुरानी घड़ी की तरह समय को हराने के लिए, लेकिन आधुनिक परिशुद्धता के साथ।

आगे देखते हुए, मैं दिखाऊंगा कि अंत में क्या हुआ। बेहतर ध्वनि के साथ देखें।

लेकिन चलिए शुरू करते हैं। पहले मुझे यह समझना था कि मैकेनिक कैसे दिखेंगे और काम करेंगे। इलेक्ट्रॉनिक्स और सॉफ्टवेयर के लिए, मैं शांत था - तीन लेखों के पीछे कि कैसे दूर से आर्डिंकी से निपटने के लिए।

मुख्य चलती तत्व एक सरल 28YBJ-48 स्टेपर मोटर होना था और मुझे यह समझने की जरूरत थी कि क्या वह मैलेट को संभाल सकता है।

डुडिगुन का अर्डुइनो से बहुत संबंध मुश्किल नहीं है, सौभाग्य से, यह एक तैयार ULN2008 चालक के साथ बेचा गया था। यह केवल 5 वोल्ट के लिए एक अलग बिजली की आपूर्ति और 200-300 एमए के एक रिजर्व प्रदान करने के लिए आवश्यक था, क्योंकि आप निश्चित रूप से आर्डिनो पर पर्याप्त कनवर्टर नहीं करेंगे। फिर, किसी भी चार डिजिटल पोर्ट पर (मैंने PB1, PB2, PB3, PB4 लिया) हम निम्नलिखित बिट नोटबुक को आठ टुकड़ों की मात्रा में स्थानांतरित करते हैं।

PORTB=0b00000010;//     PORTB=0b00000110; PORTB=0b00000100; PORTB=0b00001100; PORTB=0b00001000; PORTB=0b00011000; PORTB=0b00010000; PORTB=0b00010010;

विपरीत दिशा में रोटेशन के लिए, हम एक ही नोटबुक को स्थानांतरित करते हैं, लेकिन रिवर्स ऑर्डर में।

  PORTB=0b00010010; PORTB=0b00010000; PORTB=0b00011000; PORTB=0b00001000; PORTB=0b00001100; PORTB=0b00000100; PORTB=0b00000110; PORTB=0b00000010;

केवल एक चीज जो उत्पन्न होती है वह है गति जिसके साथ डेटा संचारित होता है। यह स्पष्ट है कि अधिक बार, तेजी से मोटर शाफ्ट घुमाएगा, लेकिन किस सीमा तक? विवरण में 100 हर्ट्ज की एक रहस्यमय आवृत्ति है, लेकिन वास्तव में इसका क्या मतलब है - एक पूर्ण चक्र या प्रत्येक कुतरने की अवधि अलग से?

प्रयोगों के दौरान, यह पता चला कि, जाहिरा तौर पर, ठीक टेट्राड्स के परिवर्तन की आवृत्ति थी। अधिकतम करने के लिए, मैंने इस आवृत्ति को 147 हर्ट्ज तक तेजी लाने में कामयाब रहा, जिस पर इंजन शाफ्ट ने लगभग एक या दो सेकंड में क्रांति की। मैंने इसे बिल्कुल नहीं मापा था, लेकिन आप अपने लिए निर्णय ले सकते हैं कि इस गियरबॉक्स वाला यह मॉडल विशेष चपलता में भिन्न नहीं है। लेकिन मेरे मैलेट के लिए, ऐसा लगता था, सिद्धांत रूप में, उपयुक्त।

लेकिन आखिरकार, यह न केवल गति है जो हमारे लिए महत्वपूर्ण है (या बल्कि, यह बहुत महत्वपूर्ण नहीं है) लेकिन बल जिसके साथ इंजन कार्यशील तरल पदार्थ को प्रभावित कर सकता है। इस इंजन को समर्पित पदों में, यह तर्क दिया गया था कि वे एक हाथ से नहीं रुक सकते। जैसा कि यह निकला, शाफ्ट ही, हां, आप नहीं रुकेंगे, लेकिन पहले से ही एक छोटा लीवर (और मैंने लीवर सिस्टम का उपयोग करने का फैसला किया है) शाब्दिक रूप से 10 सेमी लंबा, स्टॉप और बहुत आसानी से एक छोटे से स्थानीय प्रभाव के साथ स्टॉल भी।

इसलिए, प्रारंभिक सरलतम विकल्प, जब शाफ्ट पर लीवर बोल्ट को निलंबन पर धकेलता है, जो तदनुसार कटोरे को पाउंड करता है, पास नहीं हुआ। आवाज बहुत कमजोर थी। इसलिए मैंने मदद करने का फैसला किया गुरुत्वाकर्षण (शेल्डन कूपर के शब्दों में बहुत ही "हृदयहीन कुतिया")। इस अवतार में, लीवर ने पृथ्वी के केंद्र की दिशा के सापेक्ष लगभग 30 डिग्री के कोण तक एक क्लैपर खींचा, और फिर इससे विमुख होकर कटोरे के रास्ते पर भेज दिया। मुझे वास्तव में ध्वनि पसंद आई, दोनों नीचे से और मेरे पड़ोसियों के लिए। रिलीज तंत्र लीवर के अंत में स्थित एक चुंबक पर बनाया गया था। जैसा कि वे चढ़े, गुरुत्वाकर्षण ने चुंबकीय को हराया और ताला जारी किया गया। फिर मैंने एक यांत्रिक सहायता बंद कर दी - एक क्रॉस बार जिसके साथ मैलेट उठने के चरम बिंदु के पास मिला। इंजन घूमता रहा, लीवर खींचा और चुंबकीय ताला को जबरन उखाड़ फेंका। यहाँ, इंजन को गुरुत्वाकर्षण द्वारा मदद की गई थी, इसलिए विघटन के प्रयास की बहुत कम आवश्यकता थी।

डिजाइन को ही एफिल टॉवर के बच्चों के डिजाइनर के विवरण के आधार पर इकट्ठा किया गया था। मैंने इसे लंबे समय तक खरीदा और समय-समय पर अपने शिल्प के लिए इसके हिस्सों का इस्तेमाल किया। टॉवर, बेशक, एफिल नहीं निकला, लेकिन मेरी राय में यह किसी भी तरह से बदतर नहीं है :)

लगभग एफिल टॉवर

सब कुछ पूरी तरह से काम करता है, लेकिन एक माइनस के साथ - ध्वनि हमेशा एक ही शक्ति थी। यह समय की धड़कन के लिए सामान्य है, लेकिन नि: शुल्क मोड में मैं न केवल समय में अलग-अलग ठहराव सुनना चाहता हूं, बल्कि अलग-अलग ताकत की आवाज़ भी सुनना चाहता हूं। इसलिए, एक इलेक्ट्रोमैग्नेट लागू करना आवश्यक था, जो बहुत उपयोगी भी था। परम्परागत चुम्बक भी उपयोगी थे - पांच छोटे चुम्बकों का एक स्तंभ, जिसका उपयोग मैंने कटोरे से टकराने के बाद जानवर के कंपन को रोकने के लिए एक स्पंज के रूप में किया था।

सबसे पहले मैंने इसे लीवर के अंत में स्थापित किया था, लेकिन डिजाइन बोझिल था और अविश्वसनीय था। इसलिए, इलेक्ट्रोमैग्नेट एक मैलेट में चला गया। उन्होंने लगभग 300 mA का उपभोग किया और निश्चित रूप से, इसे arduino के बंदरगाह से नियंत्रित करना असंभव था। मुझे एक छोटे से ब्रेडबोर्ड पर एक साधारण ट्रांजिस्टर कुंजी रखनी थी।

आर 1 - 560 ओम, वीडी 1 - 1 एन 4007, वीटी 1 - बीडी 13 9

मैंने "Arduino ProMini" और ESP8266-07 मॉड्यूल पर मुख्य इलेक्ट्रॉनिक भाग को इकट्ठा किया, जिस फर्मवेयर को मैंने अपने पुराने लेख के अनुसार चरण दर चरण पूरी तरह से पूरा किया। नतीजतन, मुझे, हमेशा की तरह, Arduino को वायरलेस तरीके से प्रोग्राम करने और इसके साथ दूरस्थ रूप से संवाद करने का अवसर मिला, डेटा का आदान-प्रदान, जिसे मैंने अंततः सफलतापूर्वक उपयोग किया। चित्र, हालांकि, ऐतिहासिक कारणों से अरुडिनो नैनो को दर्शाता है, लेकिन इसका कनेक्शन अलग नहीं है।

तो, मैंने क्या इच्छा की और फिर कार्यक्रम कोड में अवतार लिया।

जब आप सिस्टम चालू करते हैं तो स्वतंत्र रूप से वॉच मोड में जाना चाहिए।
ऑपरेटिंग मोड बदलने और आवश्यक डेटा स्थानांतरित करने के लिए कंप्यूटर (स्मार्टफोन) पर एक आवेदन होना चाहिए।
मोड सरल होना चाहिए - एक घड़ी, यादृच्छिक मम्बल और मैनुअल कंट्रोल।

मैंने शुरू किया, जैसा कि लग रहा था, सबसे सरल चीज के साथ - घंटे। दरअसल, कोई भी शुरुआत करने वाला शौकिया रेडियो पहले एक जांच, और फिर एक इलेक्ट्रॉनिक घड़ी एकत्र करता है। और फिर, हालांकि, वह आश्चर्यचकित होता है कि यह घड़ी प्रति मिनट एक मिनट से क्यों पीछे रहती है - ऐसा लगता है कि उसने सैद्धांतिक रूप से सब कुछ सही ढंग से गणना की है।

मेरे पास पहले से ही इकट्ठी हुई इलेक्ट्रॉनिक घड़ी थी।

और मेरे लिए उनकी मुख्य विशेषता अब उसी ESP8266 microcircuit का उपयोग करके NTP सर्वर से सटीक समय खींचने की क्षमता थी, अपने पहले और सबसे सरल अवतार के व्यक्ति में।

मैं भी कुछ साल पहले इस विषय पर एक लेख दर्ज करना चाहता था, लेकिन यह देखने के बाद कि यह कितनी बार किया गया था, मैंने अपना विचार बदल दिया। वे सब के बाद हँसेंगे। लेकिन इस पोस्ट के संदर्भ में उनके काम का विश्लेषण काफी उपयुक्त है। जैसा कि मैंने पहले लेखों में उल्लेख किया है, मैं एलयूए भाषा में ईएसपी 8266 के लिए कार्यक्रम लिखता हूं। ऐसा ही हुआ।

इसलिए, उस ईएसपी मॉड्यूल में लोड कोड ऐसा था।

 uart.setup(0,9600,8,0,1,0) timezone = 3 --  tmr.alarm(1,5000,0,function() -- try once connect to NTP-server sk=net.createUDPSocket() sk:send(123,"130.149.17.21",string.char( 227, 0, 6, 236, 0,0,0,0,0,0,0,0, 49, 78, 49, 52, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)) sk:on("receive", function(sck, payload) ntp = payload:byte(41) * 128 * 256 * 256 + payload:byte(42) * 128 * 256 + payload:byte(43) * 128 + payload:byte(44) /2 + timezone * 1800 hour =ntp % 43200 / 1800 minute = ntp % 1800 / 30 secund = ntp % 60 uart.write(0,hour) uart.write(0,minute) uart.write(0,secund) sk:close() end ) end)

नीचे की रेखा सरल है। एक बार (या नहीं), यूडीपी क्लाइंट सेट करने वाले फ़ंक्शन को कहा जाता है, जो सटीक समय सर्वर को कॉल करता है और उसी के अनुसार सटीक समय पूछता है। प्रतिक्रिया में, सर्वर बत्तीस बाइट्स को डंप करता है, जिसमें से वांछित चार बाइट्स डेटा प्राप्त करना आवश्यक है। दुर्भाग्य से, यह मांग मिनटों और घंटों की नहीं है, बल्कि 1 जनवरी 1900 से अब तक आए सेकंड की संख्या है। इसलिए, फिर आपको विभिन्न जटिल जोड़तोड़ के साथ इन सेकंड के चार बाइट्स से वर्तमान समय की गणना करनी होगी।

इसके अलावा, सब कुछ सरल है। UART ट्रांसमीटर शुरू करें और इसमें तीन बार बाइट्स - घंटे, मिनट और सेकंड के हिसाब से गणना करें।

और मैंने इस कोड को फिर से डाला, पहले से ही मेरे LUA बूटलोडर (लिंक) में, उस जगह पर जहां WI-FI नेटवर्क का कनेक्शन पहले से ही बना हुआ है, लेकिन आगे का काम अभी तक शुरू नहीं हुआ है।

पूर्ण रूप से, यह इस तरह दिखता है।

 function InstrProgrammingEnable () -- instruction for MC "enable programming" p=0 while p<31 do p=p+1 pin=8 gpio.write(pin, gpio.LOW) spi.send(1, 0xAC,0x53) read = spi.recv( 1, 8) spi.send(1,0,0) gpio.write(pin, gpio.HIGH) if (string.byte(read)== 83) then --print("connection established") p=33 if(p==31) then --print("no connection") end end end end function ProgrammingDisable () pin=2--END OF ESET FOR MK GPIO4 gpio.mode(pin, gpio.INPUT) pin=8 gpio.mode(pin, gpio.INPUT) -- CE chip enable not used GPIO15 pin=5--CLK MASTER for SPI GPIO14 used gpio.mode(pin, gpio.INPUT) pin=6--MISO MASTER for SPI GPIO 12 may not used gpio.mode(pin, gpio.INPUT) pin=7--MOSI MASTER for SPI //GPIO13 used gpio.mode(pin, gpio.INPUT) end --PROGRAMMING ENABLE function ProgrammingEnable () pin=2-- RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) pin=2--POZITIV FOR 4MSEC RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(4) gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) tmr.delay(25000) end function InstrFlashErase() --FFFFFFFFFFFFFFFFFF pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0xAC,0x80,0,0) gpio.write(pin, gpio.HIGH) tmr.delay(15000) pin=2--RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(20000) gpio.write(pin, gpio.LOW) --print( "FLASH is erased") InstrProgrammingEnable () end function InstrStorePAGE(H, address, data) pin=8 gpio.write(pin, gpio.LOW) spi.send(1,H,0,address,data) gpio.write(pin, gpio.HIGH) tmr.delay(500) end function InstrWriteFLASH(page_address_low,page_address_high) pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0x4C,page_address_high,page_address_low,0) gpio.write(pin, gpio.HIGH) tmr.delay(5000)--        end function Programming (payload) pin=8--CS MASTER for SPI gpio.mode(pin, gpio.OUTPUT, gpio.PULLUP) pin=4--LED LIGHTS ON LOW gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) --print(string.len(payload)) page_count = 7 --  1  for k =0 ,page_count ,1 do--quantity of pages for i=0 , 127, 2 do-- -1 address = i/2 data=payload:byte(i+1+128*k) if data == nil then data = 0xff end InstrStorePAGE(0x40,address,data) -- tmr.delay(100)-- otherwise not in time write data =payload:byte(i+1+1+128*k) if data == nil then data = 0xff end InstrStorePAGE(0x48,address,data) -- tmr.delay(100) end page_address_low=bit.band(k ,3)*64 -- 3   11 page_address_high=k/4+frame1024*2 tmr.delay(1000) InstrWriteFLASH(page_address_low,page_address_high) tmr.wdclr() end pin=4--LED gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) end --MAIN BLOCK wifi.setmode(wifi.STATION) --wifi.sta.config("mixa","M1sh8111") -- set SSID and password of your access point station_cfg={} tmr.delay(30000) station_cfg.ssid="mixa" tmr.delay(30000) station_cfg.pwd="M1sh8111" tmr.delay(30000) wifi.sta.config(station_cfg) tmr.delay(30000) wifi.sta.connect() tmr.delay(1000000) --print(wifi.sta.status()) --print(wifi.sta.getip()) while ( wifi.sta.status()~=1 ) do if( wifi.sta.status()==5) then break end end uart.setup(0,9600,8,0,1,0) --     NTP      AVR timezone = 3 --  tmr.alarm(1,5000,0,function() -- try once connect to NTP-server sk=net.createUDPSocket() sk:send(123,"130.149.17.21",string.char( 227, 0, 6, 236, 0,0,0,0,0,0,0,0, 49, 78, 49, 52, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)) sk:on("receive", function(sck, payload) ntp = payload:byte(41) * 128 * 256 * 256 + payload:byte(42) * 128 * 256 + payload:byte(43) * 128 + payload:byte(44) /2 + timezone * 1800 hour =ntp % 43200 / 1800 minute = ntp % 1800 / 30 secund = ntp % 60 uart.write(0,100)-- AVR    uart.write(0,hour) uart.write(0,minute) uart.write(0,secund) sk:close() end ) end) prog_address=""; sv=net.createServer(net.TCP,30) tmr.delay(100) --print("SERVER READY") sv:listen(40000,function(c)-- ,   c:on("receive", function(c, payload) --print(payload) if (payload =="program\r\n") then c:send("ready\r\n") --print("ready for program\r\n") tmr.wdclr() spi.setup(1, spi.MASTER, spi.CPOL_LOW, spi.CPHA_LOW, spi.DATABITS_8,80,spi.FULLDUPLEX) --  SPI 320  115 000  ProgrammingEnable ()---------------------------------------------------------------------  80    1  tmr.delay(100) InstrProgrammingEnable () tmr.delay(100) InstrFlashErase() tmr.delay(100) frame1024=0--   st=net.createServer(net.TCP,30)--         AWR,   stop program st:listen(40001,function(c) c:on("receive", function(c, payload) tmr.wdclr() Programming (payload) frame1024=frame1024+1 end) end) end if (payload =="data\r\n") then tmr.wdclr() c:send("ready\r\n") -- print("ready for data\r\n") c:on("receive", function(c, prog_address_payload) prog_address=prog_address_payload-- IP  UDP       -- print(prog_address) c:send(prog_address) srv=net.createUDPSocket()--     ,   data stop srv:listen(50000) -- uart.setup(0,9600,8,0,1,0) srv:on("receive", function(srv, pl) --      UDP pl=pl*1 -- print(pl) uart.write(0,pl) --    UART  AVR end) uart.on("data", 1, function(data) --    UART  AVR srv:send(50000,prog_address,data) --    UDP   end, 0) tmr.wdclr() end) end if (payload =="stop data\r\n") --      then ready = false if(srv~=nil) then srv:close() -- print("stop data") end collectgarbage() end if (payload =="stop program\r\n") then if(st~=nil) then st:close() frame1024=0 ProgrammingDisable () -- print("stop program") end collectgarbage() end end) end)

बेशक, यह मेरी अवधारणा के लिए काउंटर चलाता है, जहां ESP8266 एक साफ वायरलेस ब्रिज है, और ATMEL माइक्रोकंट्रोलर बाकी काम करता है, लेकिन जैसा कि वे कहते हैं: "एक बार, नहीं ..."।

इसलिए, हमें प्रारंभिक सटीक समय (सीधे एनटीपी सर्वर से या अप्रत्यक्ष रूप से कंप्यूटर पर एप्लिकेशन के माध्यम से, इससे कोई फर्क नहीं पड़ता), तो हम स्वयं समय पर विचार करना चाहेंगे। सबसे पहले, नेटवर्क को लोड करने के लिए कुछ भी नहीं है, और दूसरी बात, ATMEL सैद्धांतिक रूप से आपको अच्छी सटीकता के साथ सेकंड की गणना करने की अनुमति देता है। सैद्धांतिक रूप से, हाँ। लेकिन व्यवहार में, नुकसान होते हैं।

AVR पर वास्तविक समय की घड़ी के बारे में एक छोटा सा विषयांतर।

सिद्धांत रूप में, AVR माइक्रोकंट्रोलर पर एक घड़ी के निर्माण में कुछ भी जटिल नहीं है। इसके लिए सबसे अधिक कठोर डिजाइनरों ने 32768 हर्ट्ज पर क्लॉक क्वार्ट्ज को सर्किट में झटका दिया। लेकिन वास्तव में, यह आवश्यक नहीं है। वास्तव में, एक घड़ी क्वार्ट्ज आवश्यक है ताकि एक सेकंड के एक से अधिक के बीच व्यवधान उत्पन्न हो और एक नींद (नोट) माइक्रोकंट्रोलर को जगाया जा सके। यदि आपका डिवाइस लगातार काम करता है, और घड़ी आमतौर पर काम करती है, तो मौजूदा क्वार्टर में अतिरिक्त क्वार्टर डालना और इसके तहत दो इनपुट-आउटपुट पैर लेना लापरवाह है। एक क्वार्ट्ज गुंजयमान यंत्र का उपयोग करना संभव है, जो वहां पहले से ही है, वहां आठ या सोलह मेगाहर्ट्ज़। इसकी मात्रा का सटीकता आपकी आंखों के लिए पर्याप्त है, और टाइमर-काउंटर के रूप में एक सेकंड की गिनती भी आसान होगी।

वास्तव में, एवीआर माइक्रोकंट्रोलर में पहले से ही इसके लिए सब कुछ है। जैसा कि आप जानते हैं, इनपुट क्लॉक सिग्नल (उदाहरण के लिए, 8 मेगाहर्ट्ज) चिप के अंदर आता है (उदाहरण के लिए, एवेरमेगा 328P, आर्कडिनो के लिए सबसे आम है) तथाकथित प्री-स्प्लिटर पर, जहां इसे प्रोग्रामर की इच्छा से विभाजित किया जा सकता है (आमतौर पर 8, 64, 256, 1024)। और फिर वह किसी तरह के टाइमर-काउंटर (टी 1 कहो) पर पहुंचता है, जो तुरंत बढ़ाना शुरू कर देता है।

तो, चलो 8 मेगाहर्ट्ज लेते हैं और 256 से विभाजित करते हैं। हम क्रमशः काउंटर 31250 हर्ट्ज की घड़ी आवृत्ति प्राप्त करते हैं। तदनुसार, चूंकि टी 1 काउंटर सोलह अंकों का है और 65535 तक तदनुसार गणना कर सकते हैं, तो एक सेकंड में 31250 तक गिनने का समय होगा। हमें क्या चाहिए। इसके अलावा, हमारे टाइमर में एक और बहुत उपयोगी तुलना रजिस्टर है। यदि हम वहां संख्या 31250 लिखते हैं, तो कुछ शर्तों के तहत इसे T1 काउंटर की सामग्री के साथ लगातार तुलना की जाएगी, और अंत में, जब यह समान होगा, तो काउंटर एक रुकावट संकेत उत्पन्न करेगा, कहते हैं, अपना दूसरा रखें।

यह आसानी से बदल जाता है, लेकिन, दुर्भाग्य से, पूरी तरह से सटीक नहीं है। हमारे काउंटर को २५६ / ,,०००,००० के परिमाणीकरण त्रुटि के साथ गिना जाएगा, जो ३२ माइक्रोसेकंड में एक सेकंड की गणना में एक बड़ी त्रुटि देता है। और इससे प्रति दिन 2.8 सेकंड (0.000032 * 3600 * 24) की त्रुटि होती है।
लेकिन अगर हम मूल 8 मेगाहर्ट्ज को एक छोटी राशि से विभाजित करते हैं, उदाहरण के लिए, 64 से, तो परिमाणीकरण सटीकता 4 गुना बढ़कर 8 μs हो जाएगी और परिणामस्वरूप त्रुटि 0.33 सेकंड प्रति दिन कम हो जाएगी। लेकिन, दुर्भाग्य से, इस मामले में काउंटर को 125,000 तक गिनने की आवश्यकता होगी, और सोलह-बिट रजिस्टर में ऐसी संख्या दर्ज नहीं होगी। हमें तुलना रजिस्टर (62500 अभी भी फिट हो सकते हैं) में एक छोटी संख्या लिखनी होगी और कार्यक्रम में एक लूप जोड़ना होगा, जहां एक सेकंड को एक नहीं बल्कि दो इंटरप्ट से गिना जाएगा।

लेकिन हमने एक आदर्श मामला लिया, और एक वास्तविक क्वार्ट्ज गुंजयमान यंत्र, जिसे विशेष रूप से "चीन में निर्मित" बोर्ड पर स्थापित किया गया था, जो आपको कई आश्चर्यचकित कर सकता है। नहीं, सामान्य तौर पर, यदि आप डेटाशीट पर मानक क्वार्ट्ज को देखते हैं, तो सैद्धांतिक रूप से सब कुछ इतना बुरा नहीं है।

जैसा कि हम देख सकते हैं, मिड-रेंज क्वार्ट्ज बहुत अच्छा व्यवहार करता है। 25 पीपीएम (या दूसरे शब्दों में 25 पीपीएम) पर उनकी खुद की ट्यूनिंग की एक अस्थिरता है, अर्थात, वह 8 मेगाहर्ट्ज की आवृत्ति पर नहीं गूंजेंगे, लेकिन, उदाहरण के लिए, 8, 0002 मेगाहर्ट्ज की आवृत्ति पर, जो हमें 2.1 सेकंड की त्रुटि देगा। प्रति दिन। लेकिन यह एक निरंतर त्रुटि है और इसे ध्यान में रखा जा सकता है। इस तरह के क्वार्ट्ज 5-10 डिग्री प्रति डिग्री के तापमान पर भी तैर सकते हैं, लेकिन डिवाइस के कमरे के ऑपरेटिंग परिस्थितियों में, त्रुटि भी छोटी होगी। उम्र बढ़ने के रूप में अभी भी ऐसा एक कारक है, लेकिन यह बहुत डरावना है और क्वार्ट्ज की विशेषताओं को कम से कम कुछ ध्यान देने योग्य स्थिति में बदल देता है, ठीक है, शायद पांच साल। या दस।

और यहाँ हम हर्षित हैं कुछ चीनी क्लोन के अरुदिनो, उदाहरण के लिए ARDUINO UNO।

हम उस पर समय गिनने के लिए एक परीक्षण कार्यक्रम चलाते हैं और इसे शुरू करते हैं। एक मिनट के लिए प्रति घंटे बैकलॉग? आराम से! दूसरा Arduino UNO बोर्ड? कोई बेहतर नहीं।

Arduino ProMini को लें।

और यहाँ बेहतर है, हाँ। त्रुटि प्रति घंटे बीस सेकंड तक कम हो गई। खैर, पहले से ही एक कोयल यांत्रिक घड़ी के लिए तुलनीय है।

आखिरी बोर्ड जो मेरे हाथ में था वह था अरुडिनो नैनो।

और वह एकमात्र ऐसा व्यक्ति था जिसने कम या ज्यादा परिणाम दिखाए।

लेकिन इस तरह के बोर्ड के साथ, केवल सैद्धांतिक निर्माणों का उपयोग करते हुए, आप खुद ही समझते हैं कि आपने एक सटीक घड़ी नहीं बनाई है। बोर्ड को कॉन्फ़िगर करने की आवश्यकता है और मैं, एक आह के साथ आस्टसीलस्कप के पीछे चढ़ गया।

जैसा कि यह निकला, Arduino बोर्डों में एक अप्रिय विशेषता है - आउटपुट जो क्वार्ट्ज गुंजयमान यंत्र से जुड़ा हुआ है, उसमें पिन कंघी का आउटपुट नहीं है, हालांकि यह पोर्ट पीबी 7 से मेल खाती है। जैसे, चूंकि पोर्ट पर क्वार्ट्ज का कब्जा है, तो आप उससे चिपके नहीं हैं। और बस माइक्रोकंट्रोलर के पैर तक सतह के बढ़ते और टर्मिनलों के बीच 0.5 मिमी की पिच के लिए आस्टसीलस्कप की जांच करना बहुत मुश्किल है। लेकिन दाहिने पैर के जुड़ने से भी मुझे कुछ नहीं मिला। या तो क्योंकि मैंने गलत तरीके से पोक किया है, या गलत जगह पर पोक किया है, क्योंकि क्वार्ट्ज गुंजयमान यंत्र का उत्पादन, शायद घड़ी जनरेटर का आउटपुट नहीं है, और सामान्य तौर पर, यह स्वयं माइक्रोकंट्रोलर के अंदर है। इसलिए, मुझे वर्कअराउंड के चारों ओर जाना था - न्यूनतम विभाजन गुणांक पर प्रीस्कूलर डाल दिया - एक, तुलना रजिस्टर में शून्य लिखें ताकि रुकावट तुरंत झटके और एक विशेष मोड में माइक्रोकंट्रोलर में प्रवेश करें जिसमें पोर्ट लेग पीबी प्रत्येक इस तरह के अवरोध के साथ अपनी तार्किक स्थिति को बदलता है।
तार्किक रूप से, जब आप Arduino नैनो 16 MHz बोर्ड को चालू करते हैं, तो इस पोर्ट के आउटपुट पर एक 8 मेगाहर्ट्ज मेन्डियर दिखाई देना चाहिए।

जो हुआ वही हुआ। आस्टसीलस्कप ने 8. 002 31 मेगाहर्ट्ज की आवृत्ति दिखाई। इसके अलावा, अंतिम निर्वहन ने अपना जीवन व्यतीत किया और मुझे अभी तक समझ नहीं आया कि क्या आस्टसीलस्कप की सटीकता में कमी है, या क्या क्रिस्टल ऑसिलेटर की आवृत्ति इस तरह तैर रही है। एक सेकंड की तरह।

वहाँ भी अच्छा थर्मल स्थिरता, गंध नहीं था। यदि आप बोर्ड पर सांस लेते हैं (शायद, वैसे, कंटेनर अभी भी नमी से आते हैं?) या एक टांका लगाने वाला लोहा (बहुत दूर से) लाते हैं, तो क्वार्ट्ज तुरंत पचास हर्ट्ज से आगे बढ़ सकता है। और ये माप अभी भी लगभग दोगुना है, क्योंकि प्रारंभिक आवृत्ति 16 मेगाहर्ट्ज है।

इस प्रकार, अरुडिनो बोर्ड (कम से कम चीनी मूल के) में 16 मेगाहर्ट्ज की घड़ी आवृत्ति पर 200 हर्ट्ज से अधिक सटीकता प्राप्त करना असंभव है। जो हमें इस तरह के बोर्डों पर इकट्ठी हुई घड़ियों की अंतिम सटीकता प्रति दिन एक सेकंड से अधिक नहीं देता है। और यह अच्छा है।

क्योंकि पहले से ही मेरे द्वारा पहले से ही उल्लेख किए गए Arduino UNO के चीनी क्लोन हैं, जिसके साथ, सामान्य तौर पर, सब कुछ खराब है। और वे बहुत आम हैं, क्योंकि वे सस्ते और सुविधाजनक हैं।

तो, उनकी आवृत्ति सौ किलोहर्ट्ज़ से अधिक की घोषणा से भिन्न हो सकती है! जो कि सबसे खराब चीनी क्वार्ट्ज के लिए भी अप्राप्य है।

पहेली इस तथ्य से शुरू होती है कि 12 मेगाहर्ट्ज क्वार्ट्ज पर ही लिखा गया है! और विक्रेताओं के विवरण में भी।

लेकिन वहाँ 12 मेगाहर्ट्ज नहीं है, यह सुनिश्चित करने के लिए है। यदि आप बोर्ड पर UART सीरियल पोर्ट को सक्षम करते हैं, तो आप अपने लिए देखेंगे। चूंकि UART ने इस आवृत्ति को देखते हुए आप काम नहीं करेंगे। और 16 मेगाहर्ट्ज की आवृत्ति के लिए ट्यून किया जाएगा - होगा। इसके अलावा, मैंने व्यक्तिगत रूप से अपने दोनों Arduino Uno बोर्डों पर तरंगों को देखा। पहले बोर्ड में 15.8784 मेगाहर्ट्ज की जनरेटर आवृत्ति थी, और दूसरी 15.8661 मेगाहर्ट्ज की।

लेकिन फिर अचानक यह पता चला कि 12 मेगाहर्ट्ज क्वार्ट्ज सीधे एवीआर माइक्रोकंट्रोलर से संबंधित नहीं है, लेकिन यूएसबी (स्केच डाउनलोड करने के लिए) के माध्यम से कंप्यूटर के साथ सीरियल पोर्ट को संचालित करने के लिए डिज़ाइन किया गया है। इसलिए, यह धारणा कि अंदर क्वार्ट्ज नहीं था, लेकिन खराब ट्यून वाली आरसी चेन, भौतिक नहीं थी। और हमें जो क्वार्ट्ज चाहिए वह आकार में बहुत छोटा है और माइक्रोकंट्रोलर चिप के बगल में स्थित है। लेकिन यह बहुत छोटा है और इस पर कोई शिलालेख नहीं है।

नतीजतन, मैं अभी भी समझ नहीं पा रहा था कि इस तरह की भयानक गुणवत्ता के क्वार्ट्ज गुंजयमान यंत्र कैसे और कहां मिलेंगे। लेकिन जाहिर है, चीन में सब कुछ संभव है। और किसी तरह मैंने डेयरडेविल्स के बारे में सोचा कि वे गंभीर व्यवसाय के लिए अर्डुंकी का उपयोग कर रहे हैं। ठीक है, सॉफ्टवेयर को स्वयं लिखा जा सकता है, लेकिन मॉड्यूल की गुणवत्ता के साथ क्या करना है? जाहिर है, इलेक्ट्रॉनिक उपकरणों से, चीनी सभी सबसे सस्ते और खारिज कर दिए गए हैं।

AVR के लिए गायन बाउल कार्यक्रम।

अंत में, सभी कठिनाइयों को सटीक समय के साथ पराजित करते हुए, मैंने अपने Arduino ProMini के लिए निम्न कोड लिखा

AVRmega328P माइक्रोकंट्रोलर के लिए सी कार्यक्रम

 /* * Tibetian_Bowl.c * * Created: 07.06.2018 0:29:57 * Author: User */ #define F_CPU 8000000 #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h>//    #include <math.h> //  #include <stdio.h> // - #include <avr/eeprom.h> #include <stdbool.h> #include <setjmp.h> #include <stdlib.h> volatile bool change_mode = false; volatile bool boom =false; volatile bool go_ahead=true; volatile bool go_back=false; volatile bool gerkon=false; volatile uint8_t latency=2;//     latency = 1 volatile uint8_t hour=12; volatile uint8_t hour24=12;//       12 volatile uint8_t minute=0; volatile uint8_t secund=0; volatile uint8_t power=0; volatile uint8_t pause_between_boom=0; volatile uint8_t first_byte=0; volatile uint8_t second_byte=0; volatile uint8_t third_byte=0; volatile uint8_t firth_byte=0; volatile uint8_t fifth_byte=0; volatile uint8_t cSREG; ISR(USART_RX_vect) { //     ,  //   –  ,    . if (first_byte==0) { first_byte=UDR0; change_mode=true; goto ret; } if (second_byte==0) { second_byte=UDR0; goto ret; } if (third_byte==0) { third_byte=UDR0; goto ret; } if (firth_byte==0) { firth_byte=UDR0; goto ret; } if (fifth_byte==0) { fifth_byte=UDR0; goto ret; } cSREG=UDR0; ret: return; } ISR(PCINT1_vect )//PC2 int 10 //    { if (go_ahead) { UDR0=44; //      44 } if (go_back) { gerkon=true; } } ISR(TIMER1_COMPA_vect) { //        secund++; if (secund ==60) { secund=0; minute++; if(minute==60) { minute=0; hour++; if(hour==12) { hour=1;//     12  } hour24++; if(hour24==24) { hour24=1; } boom=true; } } } void time_delay(long dell)//       { long i; dell=dell*796;//  8  for(i=0;i<dell;i++){;;}; sei();//    ,  -    .WTF ?????????????????????? } void turn_onkward()//       { uint8_t legnth=170;//    ( 0  170) for(uint16_t i =0;i<=legnth;i++) { go_ahead=true; PORTB=0b00000010;//       time_delay(latency); PORTB=0b00000110; time_delay(latency); PORTB=0b00000100; time_delay(latency); PORTB=0b00001100; time_delay(latency); PORTB=0b00001000; time_delay(latency); PORTB=0b00011000; time_delay(latency); PORTB=0b00010000; time_delay(latency); PORTB=0b00010010; time_delay(latency); if (i>140) { PORTD |=(1<<PORTD2);//     , 1 -   } } time_delay(100); go_ahead=false; } void turn_backward(uint8_t pause, uint8_t force_of_sound)//     // //       { uint8_t legnth=170;//       ( 0  170) for(uint16_t i =0;i<=legnth;i++) { go_back=true; PORTB=0b00010010; time_delay(latency); PORTB=0b00010000; time_delay(latency); PORTB=0b00011000; time_delay(latency); PORTB=0b00001000; time_delay(latency); PORTB=0b00001100; time_delay(latency); PORTB=0b00000100; time_delay(latency); PORTB=0b00000110; time_delay(latency); PORTB=0b00000010;//16 ms   ,  latency = 2 time_delay(latency); if (i==force_of_sound*17) { PORTD &=~(1<<PORTD2);//     , 0 -   } if (gerkon) { gerkon=false; break; } } time_delay(50); time_delay(pause*1000);//       go_back=false; } void sound(uint8_t force,uint8_t pause) //       1  10           { turn_onkward(); turn_backward(pause,force); } int main(void) { sei(); // UART  9600    8  time_delay(2000);//  , esp     -  UCSR0A=0; UCSR0B=0b10011000;// a UART UCSR0C=0b00000110; UBRR0L=51;// 8  9600  UART UBRR0H=0; //   INT0   2   10 //        PCICR|=(1<<PCIE1);//   14-8 PCMSK1|=(1<<PCINT10);//    INT10 DDRC&=~(1<<PORTC2); DDRB=0b00111110;//PB1-PB4    , PB5      DDRD=0b00000100; // PD2      //SET INTERRUPT FROM TIMER1 AND SET TIMER1 GTCCR=0;//RESET PRESCALER TCCR1A=0;//I/O NORMAL WORK TCCR1C=0; TCCR1B=0B00001100;//1/256 PRESCALING AND CTC MODE TCNT1H=0;//RESET TIMER1 TCNT1L=0; TIMSK1=0B00000010;//SET COMPARE A INTERRUPT ENABLED OCR1AH=0x79;//SET TIME CONSTANT IN COMPARE REGISTER OCR1AL=0xa7;// 31143    7 972 608  TCCR0B=0b00000010;// 8        0  255 while (1) { begining: time_delay(1000); if (first_byte!=0) { UDR0=first_byte;//      .     (100,101,102)    } if (first_byte==100)//   (     NTP  { hour=second_byte;//  if (hour>12)//      12  (24  ) { hour=hour-12; } if (hour==0) { hour=12; } minute=third_byte;//  secund=firth_byte;//  power=fifth_byte;//   first_byte=0;//   second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; change_mode=false; goto clock_mode; } if (first_byte==101)//   { power=second_byte; pause_between_boom=third_byte; first_byte=0; second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; change_mode=false; goto random_mode; } if (first_byte==102)//  { power=second_byte; first_byte=0; second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; change_mode=false; goto hand_mode; } //     ,      first_byte=0; second_byte=0; third_byte=0; firth_byte=0; fifth_byte=0; goto begining; clock_mode: while(change_mode==false) { if (boom)//   { for(uint8_t i =0;i<hour;i++) { if ((hour24>21)|(hour24<10))//  { sound(3,0);//   10 (),  0  boom=false; } else { sound(power,0);//   10 (),  0  boom=false; } } } } goto begining; random_mode: while(change_mode==false) { uint8_t random_power = TCNT0;//      1 uint8_t random_pause = TCNT1L;//      1 random_pause=TCNT0;//      1 random_power=random_power/25; if (random_power<5) { random_power=random_power+2;//      } random_pause=(random_pause/25)+pause_between_boom; UDR0=random_pause; time_delay(100); sound(random_power,random_pause); } goto begining; hand_mode: sound(power,0); goto begining; } }

सब कुछ बस काम करता है। बाह्य उपकरणों को शुरू करने के बाद, माइक्रोकंट्रोलर एक अंतहीन लूप में जाता है, जो UART कमांड की प्रतीक्षा कर रहा है। कमांड कोड इस प्रकार हैं:

100 घड़ी
मोड 101 यादृच्छिक
मोड 102 मैनुअल मोड।

चूंकि AVR कोई बात नहीं करता है कि कमांड कहां से है, इसलिए ESP8266 से पहला कमांड चालू होता है। जैसा कि पहले ही उल्लेख किया गया है, नेटवर्क के लिए ईएसपी मॉड्यूल चिपकता है, एनटीपी सर्वर से सटीक समय खींचता है और इसे माइक्रोकंट्रोलर को भेजता है। इस प्रकार, सबसे पहले आर्डिंका घड़ी की बीट मोड में प्रवेश करती है। T1 टाइमर-काउंटर को बाधित करके, सेकंड, मिनट और घंटे गिने जाते हैं और, यदि आवश्यक हो, तो कार्यों को समय को हरा देने के लिए स्टेपर मोटर को आगे और पीछे सेट करने के लिए कहा जाता है।

रीड स्विच से रुकावट एक ही शून्य बिंदु सेट करता है, अगर समय के साथ क्लैपर को खींचने वाला लीवर मोटर शाफ्ट के सापेक्ष स्थानांतरित होने लगता है।

कंप्यूटर के लिए आवेदन।

यह समान पुराने कार्यक्रमों पर सभी समान है , केवल दृश्य प्रतिनिधित्व यहां बदलता है।

सभी समान, AVR के साथ संचार चैनल HTTP और UDP कनेक्शन के माध्यम से उगता है। फिर, यदि आवश्यक हो, आवश्यक नियंत्रण आदेश और संबंधित डेटा यूडीपी पैकेट के रूप में भेजे जाते हैं। बेशक, विभिन्न चैनलों पर नियंत्रण और डेटा को अलग करना अधिक सही होगा, लेकिन, सबसे पहले, इसके लिए आपको बूटलोडर में एलयूए कोड को संपादित करने की आवश्यकता है, और दूसरी बात, इसमें कोई मतलब नहीं है, क्योंकि माइक्रोकंट्रोलर और कमांड और डेटा एक-एक करके प्राप्त होते हैं। वही UART और फिर भी हाँ, कभी-कभी (शायद ही कभी) AVR उन्हें भ्रमित करता है। लेकिन यह डरावना नहीं है, क्योंकि यदि माइक्रोकंट्रोलर कमांड को नहीं पहचानता है, तो वह इसे निष्पादित नहीं करेगा, और यह कंप्यूटर एप्लिकेशन पर इसके बारे में भी nabbed करेगा, जो बदले में आपको इनपुट दोहराने के लिए प्रेरित करेगा।

कोड Github पर उपलब्ध है ।

पुनश्च

सामान्य तौर पर, तिब्बती भिक्षु न केवल गायन के कटोरे में ताली पीटते हैं। यदि आप सावधानी से कटोरे के रिम के साथ मैलेट ड्राइव करते हैं, तो बिना किसी दस्तक के एक अद्भुत ध्वनि पैदा होगी, जिसके नीचे प्रतिध्वनि की ~~दिव्य~~ प्रकृति है। लेकिन यह Arduino के लिए एक बहुत गंभीर चुनौती है।

"अर्डुइनो" की मदद से तिब्बती गायन के कटोरे का स्वचालन। साधु की जगह स्टीपर मोटर। वायरलेस प्रोग्रामिंग

More articles: