वास्तविक समय के अनुप्रयोगों में ब्रेसेनहैम का एल्गोरिथ्म - भाग दो

पोस्ट की निरंतरता " वास्तविक समय के अनुप्रयोगों में ब्रेसेनहैम का एल्गोरिथ्म ।"

स्मरण करो कि हम लेजर स्कैनर के लिए एक आउटपुट प्रोग्राम लिख रहे हैं


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

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

putXY(x,y, wait); // , x=32000, y=32000 putXY(x0,y0, wait); // y, x0=100, y0=100 -   

हम किसी भी "zigzags" या "लूप्स" को एक अच्छे स्कैनर में नहीं देखेंगे। कम से कम आंख से।

यद्यपि अगर पास में मोबाइल फोन जैसे इलेक्ट्रो-मैग्नेटिक हस्तक्षेप का स्रोत है, तो आप यह प्राप्त कर सकते हैं


लेपित कागज के बिना हम कोई निष्क्रिय स्थानांतरण नहीं देखेंगे


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


बाईं ओर वह है जो हम देखेंगे (यह फ़ोटोशॉप है, विवेक ने हमें नियंत्रक को गलत प्रोग्राम अपलोड करने की अनुमति नहीं दी), दाईं ओर - जिसे हम देखने की उम्मीद करते थे।
छोटी चमकदार रेखाएँ बताती हैं कि स्कैनिंग की गति कभी-कभी कम हो जाती है। अगर हमारे पास कोई मल्टीटास्किंग और हमारे नियंत्रक में ऑपरेटिंग सिस्टम नहीं है तो यह कैसे घट सकता है? बहुत सरल - हमारे पास रुकावटें हैं! भले ही नियंत्रक डीएसी को जारी करने के अलावा किसी अन्य कार्य से लोड नहीं है, फिर भी हमारे पास नियंत्रण कंप्यूटर के साथ संचार से जुड़े व्यवधान हैं। उदाहरण के लिए, UART (COM पोर्ट) या ईथरनेट के माध्यम से। ऐसा लगता है कि रुकावटों को इतना समय नहीं लगता है और ऐसा लगता है कि हम एक सर्वेक्षण में ऐसा नहीं करते हैं। रेखाएं छोटी हो सकती हैं, बिंदुओं में बदल सकती हैं, लेकिन देरी के ऐसे कार्यान्वयन से पूरी तरह से छुटकारा पाना असंभव है

 void putpixel(int x, int y, int wait)) { outPortX(x); //    X  x outPortY(y); //    Y  y delay(wait); //  wait   } 

अक्सर प्रोग्रामिंग माइक्रोकंट्रोलर्स में देरी एक साधारण काउंटर पर की जाती है

 void delay(int wait) //  wait  "" { int i; for(i=0;i<wait; i++); } 

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

 void delay(int wait) { unsigned int t0; t0 = /LPC_TIM1->TC //LPC_TIM1->TC -          LPC 17xx while(LPC_TIM1->TC - t0 < wait); } 

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

 /* real time Bresenham alg. implementation */ void Line(int x1, int y1, int x2, int y2, int wait) { int x1,y1,dx,dy,sx,sy,d,d1,d2; unsigned int t0 = LPC_TIM1->TC; int i, x,y; if( x2 >= x1) { dx = x2 - x1; sx = 1; } else { dx = x1 - x2; sx = -1; } if( y2 >= y1) { dy = y2 - y1; sy = 1; } else { dy = y1 - y2; sy = -1; } /****************************/ if(dy <= dx) { d = (dy << 1) - dx; d1 = dy << 1; d2 = (dy - dx) << 1; for(x=x1+sx,y=y1,i=1; i <= dx ; i++,x+=sx) { if(d > 0) { d += d2; y += sy; putXY(x,y,wait,&t0); } else { d += d1; putX(x, wait, &t0); } } } else { d = (dx << 1) - dy; d1 = dx << 1; d2 = (dx - dy) << 1; for(x=x1,y=y1+sy,i=1;i <= dy ; i++,y += sy) { if(d > 0) { d += d2; x += sx; putXY(x,y,wait, &t0); } else { d += d1; putY(y, wait, &t0); } } } /* endif(dy <=dx) */ } void putXY(int x, int y, int wait, unsigned int *pT0) { outPortXY(x,y); //    X  Y  x  y //    #define outPortXY(x,y) outPortX(x); outPortY(y); /*  wait   */ while(LPC_TIM1->TC - *pT0 < wait); *pT0 += wait; } void putX(int x, int wait, unsigned int *pT0) { outPortX(x); //    X  x /*  wait   */ while(LPC_TIM1->TC - *pT0 < wait); *pT0 += wait; } void putY(int y, int wait, unsigned int *pT0) { outPortY(y); //    Y  y /*  wait   */ while(LPC_TIM1->TC - *pT0 < wait); *pT0 += wait; } 

ध्यान दें कि इस विकल्प में, एक चैनल या दो चैनलों के लिए DAC के लिए आउटपुट के लिए दोनों अलग-अलग समयों को स्वचालित रूप से ध्यान में रखा जाता है, साथ ही आउटपुट समय का उपयोग अगर आउटपुट तैयार होने तक उपयोग किया जाता है।

इस कार्यान्वयन में, लाइन () फ़ंक्शन के अंदर संभावित अवरोधों को ध्यान में रखा जाता है, इस फ़ंक्शन के बाहर, निष्पादन समय पर रुकावटों का प्रभाव अभी भी प्रकट हो सकता है। मुझे उम्मीद है कि पाठक के लिए यह अनुमान लगाना मुश्किल नहीं होगा कि सामान्य मामले में क्या किया जाना चाहिए।

और अंत में - यदि आपको प्रोग्राम के साथ धोखा दिया जाता है, तो आप अपेक्षित परीक्षण सर्कल और वर्ग के बजाय सबसे अप्रत्याशित स्किगल देख सकते हैं।

इस मामले में, "सब कुछ लगभग काम किया," केवल अजीब दांत दिखाई दिए। जैसा कि यह निकला, एक पंक्ति y + = sy है; x + = sx द्वारा प्रतिस्थापित कर दिया गया है ; । वैसे, लैपटॉप पर एक यादृच्छिक टचपैड के कारण।