برنامه نویسی رباتیک چیست؟ – هر آنچه باید بدانید

ربات‌ها یکی از جذاب‌ترین و کاربردی‌ترین ساخته‌های دست بشر به حساب می‌آیند. اکنون نزدیک به ۳ دهه است که علم رباتیک پدید آمده است و انواع ربات‌ها ساخته می‌شوند. برنامه نویسی رباتیک در بسیاری از حوزه‌های مختلف کاربرد دارد. مثلاً در خط تولید کارخانه‌ها یا برای انجام عملیات سنگین فیزیکی در معادن یا سایر تاسیسات صنعتی از ربات‌ها استفاده می‌شود. همچنین مهندسان برای استفاده خانگی هم برنامه نویسی ربات‌هایی را انجام داده‌اند که می‌توانند خانه را نظافت کنند یا دیگر وظایف خانه‌داری را بر عهده بگیرند. در این نوشته ابتدا به این پرسش پاسخ داده می‌شود که برنامه نویسی رباتیک چیست و سپس آموزش گام به گام و به بیان ساده ارائه شده است که در آن فرایند ساخت و برنامه نویسی ربات خودکار ابتدایی متحرک (جابجاپذیر در محیط) شرح داده می‌شود. در انتها نیز به آموزش مقدماتی برنامه نویسی رباتیک با پایتون پرداخته‌ایم.

برنامه نویسی رباتیک چیست ؟

برنامه نویسی رباتیک فرایند تعریف دستوراتی مشخص به وسیله کد نویسی با استفاده از زبان‌های برنامه نویسی مختلف با هدف پیاده‌سازی کاربردی خاص برای یک ربات عموماً صنعتی به منظور خودکارسازی آن است.

دستورالعمل‌های آن کاربرد خاص وارد سیستم کنترلی ربات می‌شوند و سپس این سیستم، گام‌های مورد نیاز را تفسیر می‌کند و اطلاعات نوشته شده به زبان برنامه نویسی رباتیک را به «PLC» (کنترل‌گر منطق برنامه نویسی) یا میکروکنترلر ربات مربوطه انتقال می‌دهد. سپس، PLC یا میکروکنترلر ربات مربوطه، محرک‌های (موتورهای) ربات را حرکت می‌دهد و محورهای ربات طبق دستورات نرم‌افزار برنامه نویسی شده تحت کنترل قرار می‌گیرند.

در حال حاضر با برنامه نویسی رباتیک می‌توان ربات‌هایی را تولید کرد تا وظایف روزانه نسبتاً ساده را انجام دهند. چالش‌های خاصی در برنامه نویسی رباتیک وجود دارد، زیرا ساخت رباتی برای خانه یا دفتر کار که کاملاً عملیاتی و قابل استفاده باشد، نیازمند «۶ درجه از آزادی» (Six Degrees of Freedom) یا همان «6DoF» است تا بتواند در فضای سه بعًدی دنیای واقعی فعالیت کند.

بنابراین، مسیر یادگیری برنامه نویسی رباتیک را باید با مبحث «6DoF» آغاز کرد. این شامل قابلیت‌های رباتیک برای حرکت به جلو و عقب، بالا و پایین و همچنین پیچیدن به چپ و راست می‌شود. همچنین ربات باید بتواند در ۳ محور عمود بر هم نیز چرخش داشته باشد؛ به این سه چرخش عمود بر هم، «Pitch» (پیچ و تاب افقی)، «Yaw» (چرخش عمودی) و «Roll» (غلتیدن) می‌گویند. برای درک بهتر این حرکت‌ها، در ادامه تصویری آمده است.

یادگیری برنامه نویسی رباتیک برای ساخت رباتی که بتواند تمام این حرکات را اجرا کند و همچنین بتواند عملیات مورد نظر را تنها با استفاده از تعداد محدودی از حسگر‌ها انجام دهد، چندان آسان نیست. در این راهنمای مقدماتی برنامه نویسی رباتیک، مباحث ساده و پایه برای شروع به کار و برنامه نویسی اولین ربات شرح داده می‌شود.

اصول و مبانی برنامه نویسی رباتیک چیست ؟

لازم است آموزش برنامه نویسی رباتیک را با ذکر این نکته آغاز کنیم که درک افراد از ربات به عنوان ماشینی هوشمند اشتباه است. اول از همه، ربات ممکن است فقط قطعه‌ای نرم افزاری باشد که در دنیای واقعی هیچ حضور فیزیکی ندارد. مثلاً از برنامه نویسی رباتیک با زبان جاوا برای ساخت ربات‌های تجارت ارز خارجی (فارکس) استفاده می‌شود.

چنین ربات‌هایی روی سخت‌افزارهای مختلفی مثل کامپیوترها، تبلت‌ها و گوشی‌های هوشمند قابل اجرا و استفاده هستند. هیچ یک از این ربات‌های تجارت ارز در فارکس، دارای بدنه فیزیکی نیستند، بلکه تنها الگوریتم‌هایی به حساب می‌آیند که برای تجارت ارزهای مختلف مطابق با قوانین تعیین شده به کار گرفته می‌شوند. البته به ربات‌های نرم‌افزاری بیشتر «بات» (Bot) گفته می‌شود که در مطلب «رباتیک چیست» هم به این نکته اشاره شده است.

همچنین ربات‌های خودکار و ربات‌های دیگری هم هستند که تنها نیاز به میزانی از خودمختاری دارند یا برخی دیگر برای اجرای وظایف مورد نظر اصلاً هیچ نیازی به مستقل بودن ندارند.

چگونه برنامه نویسی رباتیک انجام دهیم؟

برنامه نویسی رباتیک به نوع رباتی بستگی دارد که قرار است تولید شود و برای ساخت ربات‌های مختلف، برنامه نویسی آن هم متفاوت است. مثلاً اگر بخواهیم رباتی خودکار و غیر وابسته بسازیم، برنامه نویسی آن با ساخت رباتی که تنها عملیاتی تکراری و محدود را انجام می‌دهد، بسیار تفاوت دارد. برای مثال می‌توان ربات‌هایی را نام برد که به وسیله جوشکاری، قطعات خودروها را در خط تولید به هم متصل می‌کنند.

مسئله و چالش برنامه نویسی رباتیک به این بستگی دارد که نیاز است چه چیزی طراحی شود. به احتمال زیاد، ساخت ربات خودکار نیازمند به کارگیری برخی از قابلیت‌های یادگیری ماشین و درجه‌هایی از هوش مصنوعی خواهد بود. بنابراین احتمالاً ناچار خواهیم بود از زبان برنامه نویسی متفاوتی در مقایسه با ربات برنامه نویسی شده به منظور اجرای تعدادی از قابلیت‌های تعیین شده محدود استفاده کنیم.

زبان های برنامه نویسی مخصوص رباتیک کدامند؟

بحث‌های زیادی در خصوص نحوه برنامه نویسی ربات وجود دارد و اینکه برای برنامه نویسی رباتیک از چه زبان برنامه نویسی استفاده کنیم، یکی از داغ‌ترین بحث‌ها در این خصوص به حساب می‌آید. در واقع همیشه انتخاب زبان برنامه نویسی به هدف نهایی فرد بستگی دارد. اگر شخص بداند چه می‌خواهد و چگونه باید به آن برسد، از هر زبانی می‌توان استفاده کرد و محدودیتی در این خصوص وجود ندارد.

اجماع و اتفاق نظری در این خصوص وجود دارد و آن هم این است که برنامه نویسی رباتیک باید بیشتر بر زبان‌هایی مثل زبان برنامه نویسی C، سی‌پلاس‌پلاس و پایتون تکیه داشته باشد. C و C++‎ زبان‌هایی هستند که افراد تازه‌کار برای شروع می‌توانند یاد بگیرند و استفاده کنند، اما اگر افراد بخواهند به عنوان یک دانشمند توانمند رباتیک به توسعه و ساخت ربات‌ها بپردازند، نمی‌توان تنها به یادگیری و کار با این زبان‌ها بسنده کرد.

کدنویسی برای رباتیک همچنین شامل تعداد زیادی از زبان‌های برنامه نویسی صنعتی ساخته شده توسط تولید کنندگان تجهیزات رباتیک می‌شود. یادگیری پاسکال نقطه شروع خوبی است. این نرم‌افزار با برخی از این زبان‌های برنامه نویسی اختصاصی سر و کار دارد. اما همچنان لازم است هر یک زبان‌های برنامه نویسی را با جزئیات یاد بگیریم.

برای یادگیری نحوه برنامه نویسی ربات‌ها، «متلب» (MATLAB) هم ابزار دیگری است که باید حتماً در آن حرفه‌ای شویم. ریاضیات و تجزیه و تحلیل داده هم در برنامه نویسی رباتیک بسیار کاربرد دارد. برای پردازش داده‌ها نیاز است دسترسی به ابزارهای مناسب وجود داشته باشد و همچنین اگر بخواهیم ربات ما مطابق انتظار عمل کند، باید بتوان نتایج قابل اطمینانی را از حسگرهای سخت‌افزاری و نرم‌افزاری دریافت کرد.

پس از آنکه دانش و مهارت مقدماتی در خصوص برنامه نویسی با C/C++‎، پایتون، جاوا یا سایر زبان‌های برنامه نویسی مورد استفاده در رباتیک بدست آمد، نوبت به برنامه نویسی اولین ربات فرا می‌رسد. توصیه می‌شود افراد کار را با ساخت ربات نرم‌افزاری یا همان بات شروع کنند، زیرا نوشتن کدهای برنامه‌ای که شامل توابع و عملکردهای غیر مرتبط با کنترل فیزیکی دستگاه نمی‌شوند نسبتاً آسان‌تر است.

برنامه نویسی رباتیک برای مبتدیان

بازشناسی تصویر و اخیراً پردازش زبان طبیعی (NLP) جزء مسائل اساسی هستند که دانشمندان رباتیک باید حل کنند تا بتوانند طراحی ربات‌هایی را انجام دهند که رفتار و حرکت‌های انسان‌ها را تقلید می‌کنند.

به منظور آموزش برنامه نویسی رباتیک برای مبتدیان در این بخش، الگوریتم ساده‌ای برای افزایش امنیت خانه یا دفتر کار مورد استفاده قرار می‌گیرد. در این آموزش، رباتی ساخته می‌شود که دوربینی را برای شناسایی چهره به کار می‌گیرد. چگونه می‌توان چنین باتی را ساخت؟ تمام آنچه لازم است را می‌توان به وسیله گام‌های زیر انجام داد.

1. حسگر حرکتی در مقابل درِ ورودی نصب می‌شود و سپس لازم است این حسگر را به دوربین متصل کنیم.
2. دستورالعمل‌های لازم برای حسگر حرکتی به منظور فعالسازی دوربین در زمان عبور فردی از محل مورد نظر تعیین می‌شوند.
3. دوربین تصویری را به عنوان ورودی الگوریتم از چهره فرد مربوطه به ثبت می‌رساند.
4. باید تصویر مربوطه برای جمع‌آوری مجموعه‌ای مشخص از ویژگی‌ها مرور و بررسی (اسکن) شود.
5. سپس لازم است این ویژگی‌ها با کتابخانه‌ای از چهره‌های افراد آشنا و مجاز مقایسه شوند.
6. در صورتی که همتایی پیدا شود، باید دستوری برای باز شدن در به آن ارسال کرد.
7. اگر همتایی پیدا نشد، باید روند را به وسیله انجام کاری دیگر ادامه داد.

اینکه برای برنامه نویسی نرم‌افزاری به منظور اجرای این مجموعه از دستورات کدام زبان برنامه نویسی را به کار بگیریم چندان اهمیتی ندارد. در این الگوریتم برنامه نویسی رباتیک ، گام‌های بالا بارها و بارها اجرا خواهند شد تا زمانی که شرط فعال کننده برقرار شود (یعنی فردی حسگر حرکتی نصب شده در محل ورودی را فعال کند).

این ربات تشخیص چهره، ربات ساده‌ای است که از سخت‌افزارهای قابل برنامه نویسی شدن استفاده می‌کند. در این مورد به خصوص، سخت‌افزار مربوطه شامل حسگر حرکتی، دوربین و کامپیوتری می‌شود که پایگاه داده حاوی تصاویر افراد آشنا و مجاز را در خود نگهداری می‌کند. این کامپیوتر مخصوصاً برای اجرای عملیات بسیار ساده باز کردن قفل در مورد نیاز خواهد بود.

می‌توان این برنامه را تنها با ۱۰۰ خط کُد نوشت. اگرچه، این تنها زمانی امکان‌پذیر است که مدل‌های نرم‌افزاری از قبل آماده شده‌ای را داشته باشیم تا فرایند تشخیص چهره را انجام دهند. در حقیقت اما، این کسب و بدست آوردن مهارت‌های لازم برای نوشتن کدهای بازشناسی چهره است که برنامه نویس نرم‌افزار را به فردی متخصص و حرفه‌ای تبدیل می‌کنند.

ادامه مسیر یادگیری برنامه نویسی رباتیک

اکنون پس از آنکه برنامه نویسی ربات تشخیص چهره انجام شده و می‌توان به وسیله آن هویت افراد را شناسایی کرد، ممکن است تصمیم بگیریم بازوی رباتیکی را هم تعبیه کنیم که کُت‌های بازدیدکنندگان را تحویل می‌گیرد و آن‌ها در جا رختی قرار می‌دهد.

آنچه نیاز داریم، مدیریت سیستمی پویا است که شامل تعدادی حسگر و یک بازوی رباتیک می‌شود. آنچه بازوی رباتیک باید انجام بدهد این است که پوشاک مربوطه را شناسایی کند، آن را از صاحبش دریافت کند و آن را در جایی قرار دهد. این موارد چطور انجام می‌شوند؟ برنامه نویسی رباتیک برای بازوی مربوطه شامل گام‌های زیر خواهد شد:

1. استفاده از سیگنال‌های کنترلی
2. اندازه‌گیری نتایج
3. تولید سیگنال‌های کنترلی جدید محاسبه شده برای نزدیک‌تر کردن بازوی رباتیک مربوطه به اهداف مورد نظر

اگر بخواهیم بازوی رباتیک ما لباس‌های افراد را از آن‌ها تحویل بگیرد و آن‌ها را برای مهمانان در جا رختی قرار دهد، این فرایند نیازمند استفاده از میزان زیادی ریاضیات و جریان ثابتی از داده‌های قابل اطمینان است. در این فرایند لازم است داده‌های حسگر در زمان واقعی پردازش شوند و سپس عملگرهای منطقی بنیادی «if» و «then» به کار گرفته شوند تا بتوان بازوی رباتیک خود را تحت کنترل در آورد.

در صورتی که بخواهیم این فرایند را بیشتر ساده‌سازی کنیم، در واقع باید برنامه نویسی را این‌طور انجام دهیم که «اگر خیلی سمت چپ بود، باید حرکت به سمت راست انجام شود» و «اگر خیلی پایین است، باید به سمت بالا حرکت کرد»، بنابراین برنامه نویسی رباتیک اینگونه کار می‌کند.

 

برنامه نویسی رباتیک با پایتون

در این بخش نحوه استفاده از یک فریمورک توسعه ربات پایتون برای توسعه نرم‌افزار کنترلی رباتی شبیه‌سازی شده آموزش داده می‌شود. همچنین در این قسمت از مطلب نشان داده شده است که ربات مجازی مربوطه چگونه به وسیله برنامه نویسی رباتیک با پایتون با محیط خود تعامل می‌کند و به اهدافش دست می‌یابد و برخی از چالش‌های بنیادین برنامه نویسی رباتیک که معمولاً در مسیر یادگیری و پیاده‌سازی با آن مواجه می‌شویم نیز مورد بحث و بررسی قرار گرفته است.

پیش نیازهای آموزش برنامه نویسی رباتیک با پایتون چیست ؟

برای اینکه آموزش برنامه نویسی رباتیک با پایتون برای مبتدیان را در این بخش دنبال کنید، باید دانش بنیادی نسبت به دو مورد وجود داشته باشد که این دو مورد در ادامه فهرست شده‌اند.

• ریاضیات: در این آموزش از برخی توابع و بردارهای مثلثاتی استفاده خواهد شد.
• پایتون: به دلیل آنکه پایتون جز زبان‌های برنامه نویسی رباتیک محبوب‌تر به حساب می‌آید، در این بخش از کتابخانه‌ها و توابع اساسی پایتون استفاده شده است.

قطعه کدهای نمایش داده شده در این بخش از مطلب، تنها بخشی از تمام شبیه‌ساز مربوطه هستند که به کلاس‌ها و واسط‌ها وابسته‌اند، بنابراین برای اینکه مستقیماً کدها را بخوانیم، نیاز به داشتن مقداری تجربه در برنامه نویسی پایتون و همچنین شی‌گرایی وجود دارد.

پیش نیازهای اختیاری یادگیری برنامه نویسی رباتیک با پایتون چه هستند؟

در نهایت، مباحث اختیاری که پیش‌نیاز این بخش از آموزش برنامه نویسی رباتیک (با پایتون) به حساب می‌آیند و به شما کمک خواهند کرد تا بهتر این آموزش‌ها را دنبال کنید در ادامه فهرست شده‌اند.

• داشتن دانش کافی در خصوص چیستی «ماشین حالت» (State Machine)
• نحوه کارکرد حسگرهای تخمین مسافت و انکُدرها

 

چالش های ربات قابل برنامه نویسی: ادراک در برابر واقعیت و شکنندگی سلطه بر ربات

بنیادی‌ترین و اساسی‌ترین چالش در تمام بخش‌های رباتیک این است که آیا هیچ وقت امکان دارد وضعیت یا حالت واقعی محیط را بدانیم. نرم افزار کنترل ربات تنها می‌تواند وضعیت جهان واقعی را بر اساس تخمین‌های بازگردانده شده به وسیله حسگرها حدس بزند. با برنامه نویسی رباتیک تنها می‌توان نسبت به تغییر وضعیت جهان واقعی از طریق تولید سیگنال‌های کنترلی اقدام کرد.

بنابراین، یکی از اولین گام‌ها در طراحی کنترل ربات‌ها این است که انتزاعی از دنیای واقعی را پدید آوریم که به آن «مدل» (Model) می‌گویند. با استفاده از مدل می‌توان خوانش‌های حسگرها را تفسیر کرد و بر اساس آن تصمیم‌گیری لازم را به عمل آورد. تا زمانی که جهان واقعی طبق فرضیات مدل رفتار کند، می‌توان تخمین‌های خوبی زد و کنترل لازم را در اختیار گرفت. اما به محض اینکه جهان واقعی از این فرضیات منحرف می‌شود، دیگر قادر به تصمیم‌گیری مناسب نخواهیم بود و سلطه لازم از دست خواهد رفت. اغلب وقتی کنترل از دسترس خارج می‌شود، دیگر قابل بازگشت نیست (مگر اینکه نیروی خارجی خیرخواهانه‌ای آن را بازیابی کند).

این یکی از دلایل کلیدی است که برنامه نویسی رباتیک را نسبتاً دشوار می‌سازد. اغلب، فیلم‌هایی از آخرین تحقیقات پیرامون ربات‌ها در آزمایشگاه‌ها می‌بینیم که در آن‌ها شاهکارهایی فوق‌العاده از مهارت ربات‌ها، مسیریابی آن‌ها یا کار تیمی مشاهده می‌شود. در چنین مواقعی این سوال به وجود می‌آید که چرا در جهان واقعی از این ربات‌های خارق‌العاده استفاده نمی‌شود؟ دلیلش این است که محیط آزمایشگاه به شدت کنترل شده است.

در اکثر مواقع، این ربات‌ها تنها می‌توانند این وظایف تاثیر گذار و تحسین‌برانگیز را تا زمانی انجام دهند که شرایط محیطی در محدوده کوچک مدل داخلی آن‌ها باقی بماند. بنابراین، یکی از کلیدی‌ترین نکته‌ها در پیشرفت رباتیک، توسعه مدل‌های پیشرفته‌تر، قدرتمندتر و انعطاف‌پذیرتر است. چنین پیشرفت‌هایی وابسته به محدودیت‌های منابع محاسباتی در دسترس خواهد بود.

شبیه ساز ربات قابل برنامه ریزی

شبیه‌سازی که برای این آموزش ساخته شده، به زبان پایتون نوشته شده است و به طور بسیار هوشمندانه‌ای مشابه شبیه‌ساز «Sobot Rimulator» است که می‌توان آن را در گیت‌هاب یافت [+].

این ربات شبیه‌سازی شده چندان ویژگی های اضافی یا تزئینات جذابی ندارد، اما به گونه‌ای ساخته شده است که می‌تواند یک کار را به خوبی انجام دهد؛ آن هم این است که شبیه‌سازی دقیق از رباتی متحرک را فراهم کند و به یک محقق و دانشمند مشتاق رباتیک چارچوبی ساده برای تمرین برنامه نویسی رباتیک ارائه دهد. در حالی که همیشه بهتر است رباتی واقعی برای آزمایش داشته باشیم، یک شبیه‌ساز ربات خوب پایتون بسیار قابل دسترس‌تر است و نقطه‌ای عالی برای شروع به حساب می‌آید.

در ربات‌های جهان واقعی، نرم‌افزاری که سیگنال‌های کنترلی را تولید می‌کند (یعنی همان کنترلر) برای اجرا در سرعت‌های بسیار بالا و برای انجام محاسبات پیچیده مورد نیاز است. این مسئله انتخاب اینکه کدام زبان‌های برنامه نویسی رباتیک بهترین هستند را تحت تاثیر قرار می‌دهد. معمولاً برای چنین سناریوهایی از زبان C++‎ استفاده می‌شود، اما در کاربردهای ساده‌تر رباتیک، پایتون نقطه تعادل بسیار مناسبی میان سرعت اجرا و آسان بودن برنامه نویسی و تست به حساب می‌آید.

نرم‌افزاری که برای این آموزش نوشته شده است، یک ربات جستجوگر واقعی را به نام Khepera شبیه‌سازی می‌کند، اما می‌توان آن را برای دسته‌ای از ربات‌های متحرک با ابعاد و حسگرهای مختلف سازگار ساخت. با توجه به اینکه سعی شده است تا این شبیه‌ساز تا حد امکان مشابه قابلیت‌های ربات واقعی باشد، منطق کنترل را می‌توان با کمترین بازسازی در یک ربات Khepera واقعی بارگذاری کرد و عملکردش مشابه ربات شبیه‌سازی شده خواهد بود. قابلیت‌ها و ویژگی‌های خاص پیاده‌سازی شده به ربات Khepera III مربوط می‌شوند، اما می‌توان به سادگی این قابلیت‌ها را در ربات جدید Khepera IV هم به کار گرفت.

به بیان دیگر، برنامه نویسی ربات شبیه‌سازی شده، مشابه برنامه نویسی ربات واقعی است. این مسئله در در صورتی اهمیت دارد که قرار باشد شبیه‌ساز برای رویکردهای مختلف توسعه و ارزیابی نرم‌افزارهای کنترلی مورد استفاده قرار بگیرد و در این مسیر کاربردی و مفید واقع شود.

در ادامه آموزش برنامه نویسی رباتیک با پایتون معماری نرم افزار کنترل رباتی توصیف شده است که به همراه نسخه v1.0.0 از Sobot Rimulator می‌آید و همچنین قطعه کدهایی با کد منبع پایتون (با کمی تغییرات به منظور وضوح و سادگی بیشتر) ارائه شده است.

اگرچه توصیه می‌شود علاقه‌مندان عمیق‌تر به بررسی کدها بپردازند و آن‌ها را تغییر دهند و نتیجه را وارسی کنند تا بتوانند بهتر یاد بگیرند. شاخه‌ای (Fork) از این شبیه‌ساز ایجاد و از آن برای کنترل ربات‌های متحرک مختلف، شامل Roomba2 از iRobot استفاده شده است. شما هم می‌توانید از این پروژه شاخه‌ای را ایجاد کنید یا به اصطلاح آن را Fork کنید و پروژه را بهبود دهید.

کلاس های مورد استفاده در منطق کنترل ربات

منطق کنترل ربات به کلاس‌ها یا فایل‌های پایتون زیر محدود می‌شود.

• models/supervisor.py

   : این کلاس، مسئولیت تعامل میان جهان شبیه‌سازی شده حول ربات و خودِ ربات را بر عهده دارد. این کلاس، ماشین حالت ربات را پرورش می‌دهد و کنترل‌گرهای مربوطه را برای محاسبه رفتار مورد انتظار راه‌اندازی می‌کند.

• models/supervisor_state_machine.py

   : این کلاس مربوط به حالت‌های مختلفی می‌شود که ربات می‌تواند بسته به تفسیر حسگرهایش داشته باشد.

• فایل‌های موجود در شاخه models/controllers

   : این کلاس‌ها رفتارهای مختلف ربات را با در نظر گرفتن حالت شناخته شده‌ای از محیط پیاده‌سازی می‌کنند. به خصوص، بسته به ماشین حالت، کنترل‌گر خاصی انتخاب می‌شود.

هدف ربات برنامه نویسی شده با پایتون در این آموزش چیست ؟

ربات‌ها، مثل انسان‌ها به هدف و مقصود در زندگی نیاز دارند. هدف از برنامه نویسی و توسعه نرم افزار ما در این آموزش، بسیار ساده خواهد بود: ربات ما سعی خواهد کرد تا راهش را به سمت یک نقطه هدف از قبل مشخص شده پیدا کند و به آن نقطه برسد.

این معمولاً ویژگی و قابلیتی است که همه ربات‌های متحرک، از خودروهای خودران گرفته تا جاروبرقی‌های رباتیک باید داشته باشند. پیش از آنکه ربات فعال شود، مختصات نقطه هدف در نرم‌افزار کنترل ربات برنامه نویسی شده است. همچنین نقطه هدف می‌تواند به وسیله اپلیکیشن پایتون دیگری که بر حرکت‌های ربات نظارت می‌کند نیز تولید شود. مثلاً می‌توان حرکت ربات در طول نقطه‌های مختلف را متصور شد.

اگرچه، برای پیچیده کردن شرایط، می‌توان موانعی را در محیط ربات قرار داد و ربات نباید در حرکتش به سمت نقطه هدف با آن موانع برخورد کند. بنابراین، اگر ربات با مانعی مواجه شود، ناچار خواهد بود راهی را برای عبور از آن پیدا کند. بنابراین، ربات می‌تواند راهش را به سمت رسیدن به نقطه هدف ادامه دهد.

معرفی ربات قابل برنامه نویسی با پایتون

هر رباتی دارای قابلیت‌های متفاوت و درگیری‌های کنترلی متفاوتی است. با مطالعه این بخش، آشنایی لازم با رباتی حاصل می‌شود که قصد برنامه نویسی آن با پایتون در این آموزش وجود دارد.

اولین موردی که باید به آن توجه کرد این است که در این راهنمای آموزشی، ربات مربوطه یک «ربات خودران متحرک» خواهد بود. این یعنی ربات مربوطه آزادانه در محیط حرکت خواهد کرد و این کار را به تنهایی و تحت کنترل خودش انجام خواهد داد. این نوع ربات مثلاً با ربات‌های کنترل از راه دور (که خودران نیست) یا بازوهای رباتیک در کارخانه‌ها (که قابل جابجایی نیستند و ثابت هستند) تفاوت دارد.

رباتی که در این آموزش ساخته می‌شود باید خودش بتواند راه رسیدن به اهدافش را پیدا کند و در محیط خود ادامه بقا بدهد. ثابت شده است که این رویکرد، چالشی بسیار دشوار برای برنامه‌نویسان رباتیک تازه‌کار به حساب می‌آید.

حسگر ها به عنوان ورودی های کنترل ربات

راه‌ها و روش‌های مختلف بسیاری وجود دارند که می‌توان به وسیله آن‌ها ربات‌ها را برای نظارت بر محیط اطرافشان تجهیز کرد. این تجهیزات می‌توانند شامل هر چیزی از «حسگرهای مجاورتی» (Proximity Sensor) و حسگرهای نوری گرفته تا ضربه‌گیرها، دوربین‌ها و سایر موارد را شامل شوند.

به علاوه، ربات‌ها ممکن است با حسگرهای خارجی ارتباط داشته باشند که در خصوص مواردی که خودشان مستقیماً نمی‌توانند مشاهده کنند به آن‌ها اطلاعات می‌دهند.

ربات مرجع ما در این آموزش، با ۹ حسگر مادون قرمز تجهیز شده است. البته مدل جدیدتر آن دارای ۸ حسگر مادون قرمز و ۵ حسگر مجاورتی فراصوت است که به صورت دور تا دور در هر جهت تعبیه شده‌اند. حسگرهای بیشتری در جلوی ربات نسبت به پُشت آن وجود دارند، زیرا معمولاً اینکه ربات بداند چه چیزی در مقابلش قرار دارد نسبت به آگاهی داشتن نسبت آنچه پُشت آن قرار گرفته اهمیت بیشتری دارد.

علاوه بر حسگرهای مجاورتی، ربات دارای ۲ «تیک تیک کننده چرخ» (Wheel Ticker) است که پایش حرکت‌های چرخ‌های آن را بر عهده دارند. این تیکرها امکان شمارش و بررسی تعداد چرخش هر یک از چرخ‌های ربات را به ما می‌دهند؛ به این صورت که هر چرخش رو به جلوی یک چرخ برابر با ۲۷۶۵ تیک است.

چرخش‌هایی که در خلاف جهت انجام می‌شوند، باید برعکس شمرده شوند که به جای افزایش، باعث کاهش تعداد تیک‌ها می‌شود. نیازی نیست در این آموزش نگران برخی ارقام خاص باشیم، زیرا نرم‌افزاری که برنامه نویسی خواهیم کرد از مسافت پیمایش شده به صورت متر استفاده خواهد شد. بعداً در این آموزش نشان داده خواهد شد که چگونه می‌توان متراژ را با استفاده از یک تابع ساده پایتون از تعداد تیک‌ها استخراج کرد.

جابجایی حاصل شده از خروجی های کنترل

برخی از ربات‌ها به وسیله پا به اطراف حرکت می‌کنند، برخی مثل توپ به اطراف می‌غلتند و برخی دیگر هم مثل مار می‌خزند. ربات شبی‌سازی شده در این آموزش، رباتی با «راندن دیفرانسیلی» (Differential Drive) است، یعنی روی ۲ چرخ به اطراف حرکت می‌کند.

وقتی هر ۲ چرخ با سرعتی یکسان می‌چرخند، ربات در خط مستقیم حرکت خواهد کرد. وقتی چرخ‌ها با سرعت‌های متفاوتی حرکت می‌کنند، ربات می‌پیچد. بنابراین کنترل کردن حرکت این ربات این‌طور خواهد بود که باید میزان نرخ چرخش هر یک از چرخ‌ها را کنترل کنیم.

API تعامل با ربات

در Sobot Rimulator جداسازی میان کامپیوتر ربات و جهان فیزیکی (شبیه‌سازی شده) به وسیله فایل robot_supervisor_interface.py

 گنجانده شده است. کل API یا همان واسط برنامه نویسی اپلیکیشن مربوط به تعامل با حسگرها و موتورهای ربات مربوطه در این فایل تعریف شده است.

• read_proximity_sensors()

    آرایه‌ای را باز می‌گرداند که دارای ۹ مقدار در قالب بومی حسگرها است.

• read_wheel_encoders()

    هر آرایه‌ای با ۲ مقدار را باز می‌گرداند که تمام تیک‌ها را از ابتدا نشان می‌دهد.

• set_wheel_drive_rates( v_l, v_r )

   : دو مقدار (را در واحد رادیان بر ثانیه) دریافت می‌کند و سرعت چرخ‌های چپ و راست را به آن دو مقدار تنظیم می‌کند.

این واسط به صورت داخلی از شیً رباتی استفاده می‌کند که داده‌های بدست آمده از حسگرها و امکان حرکت دادن موتورها یا چرخ‌ها را فراهم می‌سازد. اگر قصد این را داشته باشیم که ربات متفاوتی را بسازیم، به سادگی تنها باید کلاس پایتون متفاوتی را فراهم کنیم که به وسیله واسط یکسانی قابل استفاده باشد و باقی کدها (کنترل‌گرها، نظاره‌گر و شبیه‌ساز) از همان ابتدا کار خواهند کرد و مشکلی نخواهند داشت.

شبیه ساز ربات برای برنامه نویسی رباتیک با پایتون

با توجه به اینکه در این آموزش فرض بر این است که از رباتی در دنیای واقعی بدون توجه زیاد به قوانین فیزیک مربوطه استفاده می‌شود، می‌توان از درک نحوه شبیه‌سازی ربات چشم‌پوشی کرد و مستقیماً به سراغ نحوه برنامه نویسی نرم افزار کنترل کننده ربات رفت.

دلیلش این است که برنامه نویسی کنترل‌گر در دنیای واقعی تقریباً با دنیای شبیه‌سازی شده یکسان است. اما اگر در این خصوص کنجکاو هستید، این فرایند در ادامه به طور خلاصه معرفی و شرح داده شده است.

فایل world.py یک کلاس پایتون به حساب می‌آید که دنیای شبیه‌سازی شده را به همراه ربات‌ها و موانع داخل آن نمایندگی می‌کند. تابع پلکانی داخل این کلاس، رسیدگی به امور تغییر و تحولات جهان ساده ما را به وسیله انجام موارد زیر بر عهده می‌گیرد.

• اِعمال قوانین فیزیک بر حرکت‌های ربات
• در نظر گرفتن برخوردها با موانع
• فراهم کردن مقادیر جدید برای حسگرهای ربات

در پایان، پایش‌گرهای ربات فراخوانی خواهند شد که مسئولیت اجرای نرم‌افزار مغز ربات را بر عهده دارند.

تابع پلکانی در یک حلقه اجرا می‌شود تا تابع robot.step_motion()

ربات را با استفاده از سرعت چرخ محاسبه شده به وسیله پایش‌گر در گام شبیه‌سازی قبلی حرکت دهد.

# step the simulation through one time interval
def step( self ):
dt = self.dt
# step all the robots
for robot in self.robots:
# step robot motion
robot.step_motion( dt )

# apply physics interactions
self.physics.apply_physics()

# NOTE: The supervisors must run last to ensure they are observing the "current" world
# step all of the supervisors
for supervisor in self.supervisors:
supervisor.step( dt )

# increment world time
self.world_time += dt

تابع apply_physics()

  به صورت داخلی مقادیر هم‌جواری حسگرهای ربات را به‌روزرسانی می‌کند تا پایش‌گر بتواند برآوردی از محیط را در گام فعلی شبیه‌سازی بدست آورد. همین مسئله در خصوص کدگذارها یا همان انکدرها هم صدق می‌کند.

مدلی ساده و ابتدایی برای ربات شبیه سازی شده

در ابتدا، ربات مربطه دارای مدلی بسیار ساده خواهد بود. ربات ما گمانه‌زنی‌های بسیاری را در خصوص جهان اطرافش خواهد داشت.

برخی از این گمانه‌زنی‌های مهم شامل موارد زیر می‌شوند.

• سطح جهان ربات همواره صاف و هموار است.
• موانع هیچگاه گِرد نیستند.
• چرخ‌ها هیچ‌وقت لیز نمی‌خورند.
• هیچ چیز ربات را به اطراف هُل نخواهد داد.
• حسگرها هیچ وقت از کار نخواهند افتاد یا خوانش‌های اشتباه انجام نخواهند داد.
• چرخ‌ها همیشه هر وقت فرمان می‌گیرند خواهند چرخید.

اگرچه اکثر این فرضیات در محیطی شبیه به داخل یک خانه منطقی و معقول هستند، با این حال ممکن است موانع گِرد (دایره‌ای) هم وجود داشته باشند. نرم‌افزار اجتناب از موانع در این آموزش پیاده‌سازی ساده‌ای دارد و برای اینکه ربات از اطراف مانع‌ها عبور کند، مرز و حاشیه موانع را دنبال خواهد کرد.

پیاده سازی حلقه کنترل ربات با پایتون

حالا وارد هسته نرم‌افزار کنترل ربات می‌شویم و در این بخش رفتارهایی شرح داده شده‌اند که قصد برنامه نویسی آن‌ها در داخل ربات وجود دارد. رفتارهای افزوده‌ای را هم می‌توان به این چارچوب اضافه کرد و می‌توان ایده‌های خود را پس از اتمام مطالعه این مقاله در این خصوص مورد آزمایش قرار داد.

نرم‌افزار «رباتیک مبتنی بر رفتار» (Behavior Based Robotics) بیش از ۲۰ سال پیش عرضه شده است و همچنان ابزاری قدرتمند برای رباتیک متحرک به حساب می‌آید. به عنوان مثال، در سال ۲۰۰۷ مجموعه‌ای از رفتارها در «چالش شهری دارپا» (DARPA Urban Challenge) به کار گرفته شدند. چالش شهری دارپا اولین رقابت ماشین‌های خودران به حساب می‌آید.

ربات، سیستمی پویا محسوب می‌شود. وضعیت و حالت ربات، خوانش‌های حسگرهای آن و تاثیرات سیگنال‌های کنترلی آن در حال تغییراتی پیاپی و دائمی است. کنترل کردن نحوه وقوع رویداد‌ها شامل سه گام زیر می‌شوند.

1. اِعمال کردن سیگنال‌های کنترلی
2. اندازه‌گیری نتایج
3. تولید سیگنال‌های کنترلی جدید محاسبه شده برای نزدیک‌تر کردن ما به هدفمان

این گام‌ها بارها تا زمانی تکرار می‌شوند که به هدفمان برسیم. هر چه بیشتر بتوان این کار را در ثانیه انجام داد، کنترل بهتری روی سیستم خواهیم داشت. ربات Sobot Rimulator این گام‌ها را ۲۰ بار در ثانیه (‎۲۰ Hz‎) تکرار می‌کند، اما بسیاری از ربات‌ها باید این کارها را هزاران میلیون بار در ثانیه انجام دهند تا بتوانند کنترل کافی را داشته باشند. باید آنچه پیشتر بیان شد را به یاد داشته باشیم و اینکه زبان‌های برنامه نویسی رباتیک مختلفی برای سیستم‌های رباتیک گوناگون وجد دارند و ملزومات مربوط به سرعت را در نظر داشت.

به طور کلی، هر بار که ربات ما اندازه‌گیری‌های لازم را با حسگرهای خود انجام می‌دهد، از این اندازه‌گیری‌ها برای به‌روزرسانی تخمین‌های داخلی از وضعیت جهان اطراف استفاده می‌کند. برای مثال می‌توان فاصله ربات از هدفش را نام برد. ربات مربوطه وضعیتش را با یک «مقدار مرجع» (Reference Value) از آنچه می‌خواهد حالتش مطابق با آن باشد مورد مقایسه قرار می‌دهد (مثلاً در خصوص مسافت، ربات می‌خواهد این مسافت صفر شود) و خطای بین وضعیت مطلوب و وضعیت فعلی را محاسبه می‌کند. وقتی که این اطلاعات مشخص می‌شوند، تولید سیگنال‌های کنترلی جدید را می‌توان به مسئله کمینه کردن خطا تقلیل داد که در نهایت ربات را به سمت هدفش سوق می‌دهد.

ترفندی کاربردی برای ساده سازی مدل

برای کنترل کردن رباتی که می‌خواهیم آن را برنامه نویسی کنیم، باید سیگنالی را به چرخ سمت چپ بفرستیم و برایش مشخص کنیم با چه سرعتی باید بچرخد و حرکت کند. همچنین سیگنال جداگانه‌ای برای چرخ سمت راست لازم است تا سرعت لازم برای این چرخ هم معین شود. می‌توان این سیگنال‌ها را vL و vR نامید.

اگرچه، اینکه بخواهیم دائماً به این سیگنال‌ها با نام‌های vL و vR بیاندیشیم، می‌تواند کمی دشوار باشد. به جای اینکه بپرسیم «می‌خواهیم چرخ سمت چپ با چه سرعتی حرکت کند» یا «می‌خواهیم چرخ سمت راست با چه سرعتی بچرخد» طبیعی‌تر است که بپرسیم «می‌خواهیم ربات با چه سرعتی به جلو حرکت کند» یا «می‌خواهیم ربات ما با چه سرعتی دور بزند یا مسیرش را تغییر دهد».

می‌توان این پارامترها را «سرعت» (Velocity) با مخفف «v» و «سرعت زاویه‌ای یا چرخشی» (Angular Velocity) با مخفف «$$ omega $$» (اُمگا) نامید. به نظر می‌رسد می‌توان اساس کُل مدل را به جای vL و vR، مبتنی بر v و $$ omega $$ قرار داد. همچنین تنها زمانی این ۲ مقدار را به صورت ریاضیاتی به vL و vR تبدیل خواهیم کرد که مشخص کرده باشیم ربات برنامه نویسی شده ما چگونه حرکت خواهد کرد تا بتوانیم واقعاً چرخ‌های ربات را کنترل کنیم. این رویکرد با عنوان «مدل کنترلی تک‌چرخی» (Unicycle Model) شناخته می‌شود. تفاوت این مدل با مدل «راندن دیفرانسیلی» در ادامه به تصویر کشده شده است.

در ادامه کدهای پایتونی آمده است که برای پیاده‌سازی تبدیل نهایی در فایل supervisor.py

 استفاده می‌شوند. باید در نظر داشته باشیم که اگر $$ omega $$ برابر با صفر باشد، هر دو چرخ با سرعت یکسانی خواهند چرخید.

# generate and send the correct commands to the robot
def _send_robot_commands( self ):
  # ...
  v_l, v_r = self._uni_to_diff( v, omega )
  self.robot.set_wheel_drive_rates( v_l, v_r )

def _uni_to_diff( self, v, omega ):
  # v = translational velocity (m/s)
  # omega = angular velocity (rad/s)

  R = self.robot_wheel_radius
  L = self.robot_wheel_base_length

  v_l = ( (2.0 * v) - (omega*L) ) / (2.0 * R)
  v_r = ( (2.0 * v) + (omega*L) ) / (2.0 * R)

  return v_l, v_r

تخمین وضعیت برای شناخت ربات از شرایط محیطی خود

ربات باید با استفاده از حسگرهایش سعی در تخمین وضعیت محیط و همچنین موقعیت خودش در محیط داشته باشد. این تخمین‌ها هرگز بی‌نقص نخواهند بود، اما باید به میزان قابل قبولی مطلوب باشند، چون ربات اساس تمام تصمیم‌های خود را مبتنی بر این تخمین‌ها قرار خواهد داد.

تنها با استفاده از حسگرهای هم‌جواری و تیک‌زن‌های چرخ، ربات ما باید سعی کند موارد زیر را حدس بزند.

• جهت موانع
• فاصله از موانع
• موقعیت ربات
• سر و جهت حرکت ربات

دو ویژگی اول به وسیله حسگر همجواری اندازه‌گیری می‌شوند و نسبتاً آسان و سر راست است. تابع API یعنی read_proximity_sensors()

 آرایه‌ای حاوی ۹ مقدار را باز می‌گرداند  که هر کدام از آن‌ها مربوط به یکی از حسگرها می‌شود. پیش از موعد می‌دانیم که برای مثال، هفتمین خوانش مربوط به حسگری می‌شود که به ۷۵ درجه سمت راست ربات نشانه رفته است.

بنابراین، اگر این مقدار خوانشی را با مقدار فاصله ۰.۱ متر نشان دهد، آنگاه خواهیم دانست که مانعی با فاصله ۰.۱ متری در ۷۵ درجه به سمت چپ مقابل ربات قرار دارد. اگر هیچ مانعی وجود نداشته باشد، حسگر خوانشی از دامنه بیشینه ۰.۲ متری را از حسگر شماره ۷ خواهد داشت که یعنی هیچ مانعی در آن جهت وجود ندارد.

به دلیل نحوه کارکرد حسگرهای مادون قرمز (که انعکاس مادون قرمز را اندازه‌گیری می‌کنند)، اعدادی که باز می‌گردانند تبدیلی غیرخطی از مسافت واقعی شناسایی شده هستند. لذا تابع پایتون برای مشخص کردن فاصله نشان داده شد باید این خوانش‌ها را به متر تبدیل کند که در فایل supervisor.py

  به صورت زیر انجام می‌شود.

# update the distances indicated by the proximity sensors
def _update_proximity_sensor_distances( self ):
    self.proximity_sensor_distances = [ 0.02-( log(readval/3960.0) )/30.0 for
        readval in self.robot.read_proximity_sensors() ]

باز هم لازم به ذکر است که مدل خاصی از حسگر را در این فریمورک ربات پایتونی داریم، در حالی که در دنیای واقعی حسگرها به همراه نرم‌افزاری ارائه می‌شوند که باید توابع تبدیل مشابهی را برای مقادیر خطی به متر ارائه دهند.

مشخص کردن موقعیت و سر ربات تا حدودی چالش‌برانگیزتر است. موقعیت مکانی و سر ربات به همراه هم در برنامه نویسی رباتیک به عنوان «ژست» (Pose) شناخته می‌شود. ربات شبیه‌سازی در این آموزش برای تخمین زدن ژستش از نوعی «کیلومترشمار» (Odometry) استفاده می‌کند. در اینجا است که تیک‌زن‌های چرخ یا همان Wheel Tickerها به صحنه می‌آیند. به وسیله اندازه‌گیری اینکه هر چرخ از زمان آخرین تکرار حلقه کنترل چقدر چرخیده، می‌توان تخمین خوبی نسبت به این مسئله بدست آورد که ژست ربات چگونه تغییر کرده است، البته تنها در صورتی که تغییر مربوطه کوچک باشد.

این یکی از دلایلی است که تکرار مداوم حلقه کنترل ربات در جهان واقعی بسیار اهمیت دارد، چون در جهان واقعی موتورهایی که چرخ‌ها را می‌چرخانند کاملاً دقیق و بی‌نقص نیستند. اگر برای مدتی بیش از حد طولانی برای اندازه‌گیری تیک‌زن‌های چرخ صبر می‌کردیم، هر دو چرخ احتمالاً زیاد فعالیت می‌کردند و تخمین اینکه موقعیت به چه صورت است غیر ممکن می‌شد.

با در نظر گرفتن شبیه‌سازی نرم‌افزاری فعلی، می‌توان محاسبات کیلومترشماری را با نرخ ‎۲۰ Hz، یعنی همان فرکانس کنترل‌گرها انجام داد. اما داشتن رشته پایتون مجزایی که سریع‌تر اجرا می‌شود تا حرکت‌های کوچک‌تر تیک‌زن‌ها را ثبت کند، احتمالاً ایده خوبی است.

در ادامه تمام کدهای کیلومترشمار در فایل supervisor.py

 آمده است. این کدهای کیلومترشمار مربوط به به‌روزرسانی تخمین ژست ربات می‌شوند. باید توجه داشت که ژست ربات از مختصات x

و y

  و هدینگِ theta

 تشکیل شده است که بر حسب رادیان از محور x مثبت اندازه‌گیری می‌شود. مثبت x به سمت شرق و مثبت y به سمت شمال است. بنابراین، هدینگ 0

 نشان می‌دهد که سوی ربات مستقیماً به سمت شرق است. ربات همیشه فرض می‌کند که ژست اولیه‌اش (0, 0), 0‎

 خواهد بود.

# update the estimated position of the robot using it's wheel encoder readings
def _update_odometry( self ):
  R = self.robot_wheel_radius
  N = float( self.wheel_encoder_ticks_per_revolution )
  
  # read the wheel encoder values
  ticks_left, ticks_right = self.robot.read_wheel_encoders()
  
  # get the difference in ticks since the last iteration
  d_ticks_left = ticks_left - self.prev_ticks_left
  d_ticks_right = ticks_right - self.prev_ticks_right
  
  # estimate the wheel movements
  d_left_wheel = 2*pi*R*( d_ticks_left / N )
  d_right_wheel = 2*pi*R*( d_ticks_right / N )
  d_center = 0.5 * ( d_left_wheel + d_right_wheel )
  
  # calculate the new pose
  prev_x, prev_y, prev_theta = self.estimated_pose.scalar_unpack()
  new_x = prev_x + ( d_center * cos( prev_theta ) )
  new_y = prev_y + ( d_center * sin( prev_theta ) )
  new_theta = prev_theta + ( ( d_right_wheel - d_left_wheel ) / self.robot_wheel_base_length )
  
  # update the pose estimate with the new values
  self.estimated_pose.scalar_update( new_x, new_y, new_theta )
  
  # save the current tick count for the next iteration
  self.prev_ticks_left = ticks_left
  self.prev_ticks_right = ticks_right

اکنون که ربات ما قادر است تخمین خوبی نسبت به جهان واقعی خود داشته باشد، می‌توان از این اطلاعات برای بدست آوردن اهداف مورد نظر استفاده کرد.

روش های برنامه نویسی رباتیک با پایتون ، رفتار حرکت به سمت هدف Go-to-Goal Behavior

هدف والا و ارزشمند در موجودیت ربات کوچک ما در این آموزش برنامه نویسی رباتیک این است که رباتمان را به نقطه هدف برسانیم. حالا چطور باید چرخ‌ها را حرکت بدهیم تا ربات به نقطه هدف برسد؟ بهتر است کار را با کمی ساده‌سازی جهان‌بینی خود آغاز و فرض کنیم هیچ مانعی بر سر راه ما وجود ندارد.

سپس این به وظیفه‌ای ساده تبدیل می‌شود و به راحتی می‌توان برنامه نویسی آن را در پایتون انجام داد. اگر در حالی که جلوی ربات به سمت هدف است به پیش برویم، به مقصد خواهیم رسید. به لطف کیلومترشمار در خصوص مختصات فعلی و سمت روبه‌روی ربات آگاهی لازم وجود دارد.

همچنین می‌دانیم مختصات هدف چیست، چون از پیش برنامه‌ریزی شده است. بنابراین، با کمی استفاده از جبر خطی، می‌توان بردار مربوطه را از موقعیت فعلی ربات به سمت هدف رسم کرد که کدهای آن در ادامه آمده است و این کدها در فایل go_to_goal_controller.py

 ذخیره می‌شوند.

# return a go-to-goal heading vector in the robot's reference frame
def calculate_gtg_heading_vector( self ):
  # get the inverse of the robot's pose
  robot_inv_pos, robot_inv_theta = self.supervisor.estimated_pose().inverse().vector_unpack()
  
  # calculate the goal vector in the robot's reference frame
  goal = self.supervisor.goal()
  goal = linalg.rotate_and_translate_vector( goal, robot_inv_theta, robot_inv_pos )
  
  return goal

باید توجه شود که ما بردار هدف را نه در مختصات جهانی، بلکه در فریم مرجع ربات دریافت می‌کنیم. اگر نقطه هدف در محور X در فریم مرجع ربات باشد، این یعنی هدف مستقیماً در مقابل ربات قرار دارد. بنابراین، زاویه این بردار از محور x اختلاف بین مقابل ربات و جهتی است که باید در آن قرار بگیرد.

به بیان دیگر، این زاویه همان خطای بین وضعیت فعلی و وضعیتی است که می‌خواهیم در آن قرار بگیریم. بنابراین لازم است میزان دور زدن ربات یعنی $$ omega $$ را تنظیم کنیم، به گونه‌ای که زاویه بین جهت فعلی ربات و هدف به سمت 0 سوق داده شود. در واقع قصد داریم خطار را کمینه کنیم.

# calculate the error terms
theta_d = atan2( self.gtg_heading_vector[1], self.gtg_heading_vector[0] )

# calculate angular velocity
omega = self.kP * theta_d

در قطعه کد بالا از پیاده‌سازی کنترل‌گر ربات با پایتون ، self.kP

 سود و بهره کنترل به حساب می‌آید. self.kP

ضریبی است که مشخص می‌کند به نسبت میزان فاصله از هدف چقدر سریع پیچیده‌ایم. اگر خطای روبه‌رویی ربات به سمت هدف برابر با 0

شود، آنگاه نرخ پیچیدن هم 0

 است. در تابع واقعی پایتون داخل فایل go_to_goal_controller.py

 ، بهره‌های مشابه‌تری مشاهده خواهد شد، چرا که به جای یک ضریب تناسب ساده از کنترل‌گر PID استفاده شده است.

اکنون که سرعت زاویه‌ای یا همان $$ omega $$ را داریم، چگونه سرعت حرکت به جلو یا همان v را محاسبه کنیم؟ یک روش کلی مطلوب، قاعده‌ای است که احتمالاً به طور غریزی می‌دانید؛ اگر در حال پیچیدن نیستیم، می‌توان با حداکثر سرعت به سمت جلو حرکت کرد و بعد هر چه سرعت چرخش ما بیشتر است، باید سرعت حرکت را کاهش داد.

این روش به طور کلی کمک می‌کند تا سیستم پایدار باقی بماند و فعالیت لازم در حد و حدود مدل انجام شود. بنابراین، v تابعی از $$ omega $$ است. در فایل go_to_goal_controller.py معادله یا همان فرمول v به صورت زیر ارائه شده است.

# calculate translational velocity
# velocity is v_max when omega is 0,
# drops rapidly to zero as |omega| rises
v = self.supervisor.v_max() / ( abs( omega ) + 1 )**0.5

توصیه‌ای برای بسط دادن و ارتقای فرمول بالا این است که وقتی نزدیک به هدف هستیم سرعت را کم کنیم تا وقتی ربات به نقطه هدف رسید، سرعتش صفر و متوقف شود. برای اضافه کردن این قابلیت، فرمول بالا چگونه باید تغییر کند؟ این فرمول باید به نوعی حاوی جایگزینی برای v_max()

  با چیزی متناسب با فاصله باشد.

به این ترتیب تقریباً حلقه کنترلی واحدی را تکمیل کرده‌ایم. تنها چیزی که انجامش باقی مانده این است که این دو پارامتر تک‌چرخی را به سرعت‌های چرخ دیفرانسیلی تبدیل کنیم و سیگنال‌ها به چرخ‌ها ارسال شوند. در ادامه نمونه‌ای از خط سیر ربات تحت کنترل‌گر «حرکت به سمت هدف» (Go-to-Goal) بدون مانع آورده شده است.

همان‌طور که در تصویر فوق مشاهده می‌شود، بردار به سمت هدف مرجعی موثر به حساب می‌آید تا محاسبات کنترلی خود را بر اساس آن انجام دهیم. این نمایشی داخلی از این است که «کجا می‌خواهیم برویم».

جمع‌بندی

علم رباتیک به سرعت در حال پیشرفت است. همگام شدن با آخرین پیشرفت‌ها در حوزه ماشین‌های قابل برنامه نویسی نیازمند تلاش‌هایی است که از آشنایی با یک زبان یا زبان مناسب دیگری برای ربات‌ها فراتر می‌رود. به فرایند کدنویسی برای کنترل رفتار ربات‌های مختلف با هدف و کاربردی مشخص برنامه نویسی رباتیک می‌گویند.

اگر واقعاً بخواهیم در حوزه برنامه نویسی رباتیک متخصص شویم، باید نیازمندی‌های ساخت ربات‌ها را هم در سطح سخت‌افزاری و هم نرم‌افزاری درک کنیم. خوشبختانه تعدادی از پلتفرم‌ها وجود دارند که امکان یادگیری بهتر برنامه نویسی رباتیک را برای افراد تازه‌کار فراهم می‌کنند. این کار به وسیله حذف بسیاری از دشواری‌های مربوط به شناخت نحوه کارکرد ربات‌ها انجام می‌شود. همچنین این کار می‌تواند به وسیله برنامه نویسی سیستم‌هایی در سطح صفر و یک انجام شود.

آنچه اساساً در آموزش برنامه نویسی رباتیک برای افراد تازه‌کار نیاز داریم، داشتن سخت‌افزار قابل برنامه نویسی یا ماژول‌های نرم‌افزاری از پیش برنامه‌نویسی شده است. پس از آن، می‌توان برای اجرای برخی از عملیات خاص برنامه نویسی لازم را انجام داد. در هر صورت لازم است حتی برای ساده‌ترین کارهای مربوط به ربات‌ها، یک یا بیش از یک زبان برنامه نویسی را مثل C++‎ ،C، پایتون، LISP یا جاوا مورد استفاده قرار داد. وقتی که بیشتر در برنامه نویسی رباتیک پیشرفت می‌کنیم، توصیه می‌شود آشنایی لازم با ابزارهایی مثل متلب کسب شود. یادگیری MATLAB باعث می‌شود بتوان کنترل کامل‌تر و دقیق‌تری را در برنامه نویسی رباتیک بدست آورد.