سوئیچ – وبلاگ آردوینو

جلسه نوزدهم : راه اندازی رله

به نام خدا
این جلسه قصد دارم در مورد راه اندازی رله باهاتون صحبت کنم .
قدم اول اصلا این که رله چیه؟ به طور خیلی خیلی خیلی کلی بخوام بگم رله یه سوئیچه . سوئیچ هایی که تو جلسه های قبلی استفاه می کردیم رو یادتونه ؟ اگه قرار بود سوئیچ زده بشه (اصطلاحا میگیم سوئیچ تحریک بشه )، ما باید با انگشت روی دکمه کلید فشار می آوردیم تا زده بشه .
اما رله ها سوئیچ هایی هستن که با یه سری فعل و انفعالات الکترونیکی و مکانیکی کار سوئیچینگ رو انجام میدن. به عبارت دیگه ما برای قطع و وصل کردن سوئیچ داخلی رله نیازی نداریم که با دست فشار بدیم یا هر نوع کار فیزیکی دیگه بکنیم، بلکه با استفاده از میکروکنترلر و کد نویسی این کار رو انجام می دیم.
یه کم واضح تر بگم منظورم چیه :
یه LED رو تصور کنید که می خوایم روشنش کنیم . یه راه حل اینه که دو تا ولتاژ VCC و GND داشته باشیم مثلا باتری (اینجوری:)

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

اما بریم سراغ معرفی قسمت های مختلف یه رله که باهشون کار داریم. شما می تونید انواع ماژول های رله رو از اینجا ببینید. مدلی که من امروز باهاش کار می کنم این هست:
همونطور که می بینید این رله 3 قسمت مهم داره که دونه به دونه معرفیشون می کنم :

خب ما توسط این قسمت به رله میگیم خاموش بشه یا روشن بشه. یعنی همون بخش تحریکش در واقع. برای این کنترل یا بازهم می تونیم مثل مثال باتری بریم سیم برداریم و هر موقع خواستیم وصل کنیم و هر موقع نخواستیم قطع کنیم (یعنی به صورت دستی و فیزیکی )، یا این که می تونیم این قسمت رو به یه میکروکنترلر مثل آردوینو وصل کنیم و از طریق دستورهای کدنویسی این کار رو انجام بدیم. اگر دقت کنید این قسمت سه تا پایه داره . یکی DC+ که در واقع همون پایه VCC هست و باید بهش 5 ولت اردوینو رو وصل کنیم. پایه دیگه DC- هست که نقش گراند (GND) رو داره که به پین زمین آردوینو وصلش می کنیم. یه پایه دیگه داره به اسم IN. از طریق این پایه روشن یا خاموش بودن رله کنترل میشه. یعنی کل کاری که ما در کنترل یک رله انجام میدیم اینه که با ولتاژ این پین رله بازی کنیم . چون این بازی کردن یه وضعیت دوحالته هست یعنی خاموش و روشن (معادل 0 و 1 ) ، این پین رله رو به یکی از پین های دیجیتال دلخواه آردوینو وصل می کنیم. شماره پین مهم نیست چون فقط قصد داریم 0 و 1 کنیم و نم یخوایم PWM بدیم. حالا سوالی که پیش میاد اینه که باید به پین رله رو 0 کنیم تا رله روشن شه یا 1 کنیم تا روشن شه ؟ جواب این سوالتون رو تو بخش سوم همین توضیحات خواهم داد.

این قسمت از رله رو باید به وسیله ای وصل کنیم که قصد داریم تحت کنترلش بگیریم. مثلا به یه موتور با LED توان بالا. خب اگه به عکس دقت کنید میبینید که این قسمت از رله سه تا ترمینال داره که به صورت زیر نام گذاری می شن:

پایه normally close پایه ای هست که در حالت عادی که رله خاموشه به پایه common (یعنی پایه کناریش) وصله . این اتصال رو می تونید از طریق یک مولتی متر هم چک کنید. پایه normally open پایه ای هست که وقتی رله روشن میشه به پایه common وصل میشه در این حالت پایه common از پایه normally close جدا میشه که باز هم می تونید از طریق مولتی متر تست بگیرید. در همین حد برای ما کافیه که از این قسمت بگیم و لی اگه سوال دارید که اصلا پایه normally close چیه و چرا در حالت خاموش رله می چسبه به common این لینک رو مطالعه کنید.

این قسمت تعیین میکنیم که سطح تحریکمون high باشه یا low باشه. یعنی چی ؟
یادتونه تو معرفی قسمت یک همین جلسه گفتم حالا برای روشن کردن رله باید به پایه IN صفر بدیم یا یک بدیم؟ توی این قسمت رله داریم همین رو تعیین می کنیم. اگه وضعیت جامپر زرد رنگ به همین صورت الانش باشه (یعنی روی H باشه ) برای روشن کردن رله باید به پایه IN منطق HIGH وصل کنیم اگه وضعیت جامپر رله بر عکس باشه یعنی روی L باشه باید برای روشن کردن رله بهش LOW بدیم. اصطلاحا به حالت اول میگن رله 1 فعاله و به حالت دوم میگن 0 فعاله.

خب این جا معرفی رله تموم شد از اینجا به بعد پروژمون رو انجام میدیم .

************************************************************************************************

خب تو پروژمون قصد داریم فقط رله رو روشن و خاموش کنیم. برای این کار مطابق توضیح زیر مدار رو ببندید:

پایه DC+ رله به پایه 5v آردوینو
پایه DC- رله به پایه GND آردوینو
پایه IN رله به پایه دیجیتال شماره 8 آردوینو (به جای این پین دیجیتال هر پین دیجیتال دلخواه دیگه ای رو هم می تونید استفاده کنید)

سادست دیگه مگه نه ؟
خب حالا میریم سراغ مرحله کد نویسی :
کد زیر رو آپلود کنید تا هر قسمتش رو توضیح بدم :

قسمت 1 : معرفی پین 8 (پین متصل به رله ) به نام relay_pin
قسمت 2 :کانفیگ ارتباط سریال
قسمت 3 :شرط if . این شرط که در جلسات پیش به تفصیل توضیح داده شده معین می کنه که آیا داده ای در کنسول سریال دریافت شده یا نه.
قسمت 4: :در این خط کد، داده کنسول سریال توسط دستور Serial.read خونده می شه. بعد از آن ،عدد 48 از این داده کم می شه. علت کم شدن عدد 48 چیه ؟
اگه همین کد رو بدون -48 پروگرام کنید و اجرا کنید وقتی تو کنسول عدد 0 تایپ بشه تو خروجی کنسول عدد 48 دیده می شه ( چی شد ؟ من 0 تایپ کردم ولی داره 48 نشون میده ). در صورتی که عدد 9 تایپ بشه در خروجی کنسول عدد 57 دیده می شه. داستان چیه ؟
با کمی جست و جو معلوم می شه که خروجی دستور Serial.read در واقع کد اسکی عدد 0 و 9 هست. یعنی 48 کد اسکی عدد 0 هست و 57 کد اسکی عدد 9 ! یعنی وقتی ما 0 تایپ می کنیم تو ورودی کنسول ، آردوینو میره عدد 48 که معادل کد اسکی 0 هست رو به عنوان خروجی دستور Serial.read تحویل میده.
بنابراین ما برای این که بتونیم از این خروجی اسکی (که مطلوبمون نیست ) به خروجی واقعی خودمون برسیم لازمه از کد اسکی (که الان خروجی دستور Serial.read هست ) عدد 48 رو کم کنیم .به همین سادگی. در نهایت خروجی این خط کد که تو متغیر data ریخته میشه همون عددی هست که ما توی کنسول تایپش کردیم یعنی 0 یا 9 . به نظر من یه بار بدون -48 کد رو تست کنید و ببینید.
قسمت 5 :داده ای که توی کنسول تایپ کردیم تو قسمت خروجی کنسول برامون نشون داده میشه.
قسمت 6 : داده توی متغیر data مستقیما به پین متصل به رله فرستاده میشه.

حالا کد رو تست کنید.
اگه جامپر روی قسمت H باشه وقتی 1 میدید رله روشن میشه و وقتی 0 میدید رله خاموش میشه .
اگه جامپر روی قسمت L باشه وقتی 0 میدید رله روشن میشه و وقتی 1 میدید رله خاموش میشه .

این جلسه هم همینجا تموم شد.
سوالتتون رو تو انجمن بپرسید لطفا .

جلسه پانزدهم : رسم نمودار ( پلات ) با استفاده از آردوینو

سلام
تو این جلسه قصد دارم بهتون یاد بدم چجوری با استفاده از آردوینو نمودار رسم کنید. چیزی که شاید خیلی از جاها به دردتون بخوره . ورژنای قدیمی نرم افزار آردوینو این امکان رو نداشت که بتونیم باهاش پلات کنیم (نمودار رسم کنیم ) ولی خب تو ورژنای جدید (از 1.6.6 به بالا) شکر خدا عقلشون کار کرده و این آیتم رو گذاشتن. یعنی ما تنها با استفاده از نرم افزار آردوینو و بدون نیاز به نصب هیچ نرم افزاری می تونیم نمودار تغییرات رو ببینیم.

یه توضیح کلی: اول بزارید ببینیم این امکانی که داریم ازش حرف می زنیم کجای نرم افزاره . از منوی Tools وارد Serial plotter میشیم:

همونطور که می بیند اسم این آیتم سریال پلاتر هست و ما هم از این به بعد به این آیتم پلاتر میگیم. یه نمای کلی هم بخواید ازشکل رسم نمودارش ببینید این شکلیه:

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

ما هم نمودار دیجیتال رو رسم می کنیم هم نمودار آنالوگ رو.
اول سوئیچ مدار و کد جلسه سیزدهم رو آماده کنید. مدار آخر رو ببندید که با دیبانس نوشتیم. همچین کدی داشتیم اگه یادتون باشه (البته من برای این که کد کوتاه بشه خط های کامنت ها رو پاک کردم)

ما تو این کد برای این که ارتباط سریال داشته باشیم لازمه یه تغییراتی رو توی کد نویسیمون اعمال کنیم.

چون لازم داشتیم ارتباط سریال استفاده کنیم خب تو تابع setup کانفیگش کردیم. اگه یادتون باشه گفتیم اساس کار سریال پلاتر ارتباط سریال هست که خدارو شکر تو آردوینو ایجاد ارتباط سریال بین آردوینو و کامپیوتر فقط با یک خط کد انجام میشه یعنی دستور Serial.print. هر آرگومانی که توی این دستور نوشته بشه عینا به صورت سریال (از طریق همون کابل USB که بین آردوینو و کامپیوتر هست ) به کامپیوتر شما ارسال میشه. بنابراین توی این کد هر جا منطق پین دیجیتال شماره 2 صفره ما هم 0 رو سریال پرینت می کنیم هر جا منطق پین یکه ما هم 1 رو سریال پرینت می کنیم.

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

دقت کنید در فیلم جاهایی که یهو یه تغییر دامنه داریم لحظاتی هست که کلید رو فشار دادیم.

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

همونطور که می بینید دقیقا داره متناسب با تغییر ولوم پتانسیومتر (که دست من بود و شما نمی دیدید) نمودار تغییر می کنه.

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

پایان جلسه

جلسه سیزدهم : استفاده از کتابخانه Bounce2

سلام

اگه یادتون باشه توی آموزش جلسه 11 استفاده از پین دیجیتال آردوینو به عنوان ورودی و تو جلسه 12 نحوه اضافه کردن کتابخونه به محیط آردوینو رو یاد گرفتیم.
این جلسه تلفیقی از 2 جلسه قبله. یعنی قراره داده یه سوئیچ رو بخونیم ولی نه با یه digitarRead معمولی بلکه با استفاده از کتابخونه Bounce2.
مهم ترین سوالی که برتون پیش میاد اینه که خب مگه digitalRead معمولی چشه که بخوایم بریم کتابخونه اضافه کنیم و از لحاظ نرم افزاری کارمون رو یه کم مشکل تر کنیم.

برای این که دلیل این کار رو بدونید ترجیح میدم انجامش بدید تا خودتون بفهمید.
برای این کار اول سخت افزارمون رو می بندیم یه آردوینو می خوایم (هر مدلی دارید فرقی نمی کنه ) و یه سوئیچ و یه برد بورد کوچیک .

خب وقتی سوئیچ رو نگاه کنید می بینید 4 تا پایه داره! داستان چیه؟ داستان اینه که این پایه ها مطابق عکس زیر 2 تا 2 تا به هم وصلن:

حالا مطابق عکس زیر مدار رو ببندید:

یعنی یه پایه رو به 5 ولت و یه پایه رو به پین دیجیتال شماره 2 وصل کنید. دقت کنید که پایه های متصل به هم به صورت عکس زیرهستن و سوئیچ باید درست توی مدار قرار بگیره:
می دونید که هیچ اصراری به پین شماره 2 نداریم هر پین دیجیتال دلخواهی میشه. دقت کنید بین پایه شماره 2 آردوینو (که به سوئیچ هم وصله )و زمین یه مقاومت قرار داده شده. این مقاومت برای این گذاشته شده که زمانی که کلید فشار داده نشده روی پین شماره 2 دقیقا ولتاژ 0 ولت بیفته و زمانی که کلید فشار داده میشه دقیقا ولتاژ 5 ولت و منطق باینری HIGH بیفته.
یه کم دقیق تر حرف بزنیم:
زمانی که کلید رو فشار ندادیم بین دو قسمت مشخص شده سوئیچ در شکل اول هیچ ارتباطی وجود نداره. یه طرف که مستقیم به 5 ولت وصله خب تکلیفش معلومه. ولی اون طرف سوئیچ که به پین دیجیتال آردوینو وصله داستان داره. اگه مقاومت نزاریم یعنی پین آردوینو رو مستقیم به اون سر سوئیچ وصل کنیم پین وضعیت آزاد داره یعنی مختاره روش منطق باینری 0 یا 1 بیفته چون هیچ کس نیست بهش فرمانی دستوری چیزی بده. اونم مختاره هر چی خواست باشه که اصلا پدیده خوشایندی نیست و اگه مدار رو همینطوری ببندید بینهایت پر خطا خواهد بود. بنابراین یه مقاومت بر می داریم و اون پین رو به واسطه این مقاومت زمین می کنیم. با این کار یه مسیر بین این پین و زمین برقرار میشه . این مسیر طبق قوانین مداری باعث میشه روی پین دیجیتال شماره 2 آردوینوهم ولتاژ 0 ولت معادل منطق باینری LOW بیفته و هر چی که خواست نباشه. به این مقاومت ، مقاومت Pull-down گفته میشه . برای دریافت توضیحات بیشتر این لینک رو بخونید.
اما زمانی که کلید رو وصل می کنیم بین دو قسمت نشون داده سوئیچ تو شکل اول یه ارتباط به وجود میاد و دو تا قسمت به هم وصل می شن. بنابراین اون قسمتی که به پین شماره 2 وصل بود الان به خاطر این اتصال ولتاژی معادل 5 ولت و منطق باینری HIGH خواهد داشت.

خب حالا این کد رو آپلود کنید:

روال این کد به این صورته که به محض فشار داده شدن کلید در کنسول سریال پیغام Pressed نمایش داده میشه. دقت کنید شرط if رو چجوری نوشتم. نوشتم اگه داده پین دیجیتال HIGH بود (که معادل فشار داده شدنه کلیده ) برو رو کنسول سریال چاپ کن.
خب کد رو آپلود کنید و کنسول سریال رو باز کنید و یک بار کلید رو فشار بدید . با این نتیجه دلخراش در کنسول مواجه خواهید شد:

می بینید شما یک بار کلید رو فشار دادید ولی این طفلک بیشتر از 10 بار اینو چاپ کرده چرا؟
علتش اینه که فرض کنید مدت زمانی که شما کلید رو فشار می دید مثلا 10 میلی ثانیه باشه ( این عددها همش مثاله و دقیق نیست ) . آردوینو هر 1 میلی ثانیه یک بار میاد این پین شماره 2 رو سرکشی می کنه که مقدارش چقدره ( به خاطر دستور digitalRead که خودمون نوشتیم ) . بنابراین اون 10 میلی ثانیه ای که دست شما روی کلیده آردوینو 10 بار اون پین رو خونده و هر 10 بار هم منطق باینری اون رو HIGH دیده ( چون دست روی کلید بوده و طبق مدار ما در زمان اتصال کلید 5 ولت معادل منطق باینری HIGH روی پین افتاده ) . بنابراین طبق دستوری که ما نوشتیم عین 10 بار پیام Pressed نمایش داده میشه. خب این اصلا خوب نیست. ما به نظر خودمون یه بار کلید رو فشار دادیم ولی 10 بار پیام چاپ شده.

حالا باید دنبال راه حل بگردیم تا این مشکل رو حل کنه:
یکی از راه حل ها استفاده از دستور delay هست به صورت زیر:

این ساده ترین راه حل هست که الان اگر کد رو آپلود کنیم با هر بار فشار دادن کلید فقط 1 بار پیام Pressed چاپ می شه. با دستکاری مقدار آرگومان تابع delay می تونید دقت های متفاوتی رو به دست بیارید .

راه حل دوم استفاده از خطوط کدنویسی پیچیده تر با استفاده از دستور millis و غیره هست که خب چون ما اول کاریم سراغ این مورد نمیریم.

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

خب حالا مطابق تصویر زیر به مثال bounce برید:

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

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

قسمت اول پین متصل به سوئیچ به عنوان ورودی پول آپ تعریف شده است. یعنی چی؟ اگه یادتون باشه تو قسمت سخت افزاری این پروژه ما اومدیم اون پایه ای که به پین دیجیتال آردوینو وصل بود رو با یه مقاومت به زمین وصل کردیم (Pull-down کردیم ). حالا اگه لینک آموزش رو خونده باشید در مقابل Pull-down یه Pull-Up داریم. یعنی به جای این که اون سر مقاومت رو زمین کنیم به 5 ولت وصل کنیم .

حالا یه نکته جالب وقتی Pull-down کردیم خودمون رفتیم یه مقاومت برداشتیم و به صورت خارجی تو مدار قرار دادیم. شاید این تصور به وجود بیاد که پول آپ هم همینه دیگه یعنی یه مقاومت بر میداریم منتها به جای این که زمین کنیم 5 ولت می کنیم. اما یه اتفاق خوب این وسط وجود داره .وقتی با آردوینو کار می کنیم دیگه نیازی نیست مقاومت پول آپ رو به صورت خارجی بزاریم بلکه تو خود سخت افزار آردوینو یه فکرایی کردن که سر راه پایه های دیجیتال مقاومت داخلی گذاشتن. فقط باید از آردوینو بخوای این مقاومت داخلی رو بیاره تو مدار که با فرمت INPUT_PULLUP موقع کانفیگ پین دیجیتال بهش میگیم این کار رو بکنه. همونطور که می بینید این اسم دو قسمته: اول INPUT که بهش میگیم این پایه دیجیتال ورودیه و بخش دوم PULLUP هست که بهش میگیم سر راه این پایه دیجیتال یه مقاومت بزار. بنابراین در مقوله Pull-Up ( نه Pull-down ) نیازی به مقاومت خارجی نداریم فقط خود کلید رو میزاریم تو مدار و یکی از پایه هاش رو به پین دیجیتال مورد نظرمون وصل می کنیم.
اما اگه از Pull-Up استفاده کردیم باید به یه نکته حواسمون رو جمع کنیم. وقتی پول آپ می کنیم داریم ولتاژ اون پایه ای از سوئیچ رو که به آردوینو وصله (در حالتی که کلید فشار داده نشده ) رو 5 ولت نگه می داریم (یا همون منطق HIGH ) . بنابراین اون یکی سر سوئیچ رو باید گراند کنیم . منطقیه دیگه مگه نه ! اگه قرار بود اون یکی سر سوئیچ هم مثل مدار اول 5 ولت باشه وقتی سوئیچ رو فشار بدیم به خاطر اتصال دو پایه سوئیچ ، 5 ولت رو به پین دیجیتال وصل می کنه. خب با پول آپ کردن که خودش 5 ولت شده بود .بنابراین برای این که با فشار داده شدن کلید اختلاف سطح منطقی روی پین دیجیتال به وجود بیاد باید اون سر سوئیچ رو به زمین وصل کنیم مطابق عکس زیر:

و اما دستور debouncer.attach:
این دستور یه آرگومان داره که از شما شماره پینی که سوئیچ رو بهش وصل کردید می خواد . تو کد ما در قسمت هدر این پین BUTTON_PIN معرفی شده بنابراین آرگومان ورودی این دستور رو هم BUTTON_PIN قرار دادیم.

دستور debouncer.interval :
این دستور هم یه آرگومان میگیره که زمان اینتروال هست . واحد این آرگومان میلی ثانیه است و مثلا وقتی نوشته 5 یعنی 5 میلی ثانیه زمان نویز نوگیری در نظر گرفته بشه. خب به نظر من که کمه می تونید تا حدود 50 (در اکثر کدها روی 50 تنظیم میشه) افزایشش بدید.

تابع setup هم تموم شد و اما میریم سر وقت تابع loop :

خب اول دستور debouncer.update :
با این کار وضعیت پین دیبانس که در حال نمونه برداریه به روز می شه بعد از اون با دستور debouncer.read این مقدار خونده میشه. اگه این داده ای که خونده سطح منطقی LOW باشه LED شماره 13 آردوینو رو که همون LED داخلی آردوینو هست روشن میکنه. دقت کنید چون مدارمون رو عوض کردیم وقتی کلید وصل بشه پایه دیجیتال شماره 2 آردوینو به زمین متصل میشه و سطح منطقیش برابر LOW میشه (به همین دلیل این مدلی کد نویسی شده).

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

*************************

کتابخونه دیبانس 2 تا دستور دیگه داره fell و rise که اگه کسی خواست بدونه اینا چیکار می کنن می تونه تو انجمن سوالش رو مطرح کنه.

جلسه یازدهم : میکروسوئیچ

به نام خدا
سلام به دوستان

راستش قصد داشتم جلسه بعد برم سراغ سروو . ولی یه کم فکر کردم دیدم هنوز پروژه بیس زیاد داریم که بهتره اول اونا رو بگم بعد بریم سراغ سروو و ادامه ماجرا.
یه روند جدید: اول هر کاری که میشه با پین های دیجتال آردوینو کرد رو یاد میگیریم بعد میریم سراغ آنالوگ ها.
تا الان هر پروژه ای که انجام دادیم از پین های دیجیتال آردوینو به صورت خروجی استفاده کردیم. مثلا موقعی که یه LED ساده روشن کردیم، یا موقعی که RGB LED روشن کردیم و یا تو پروژه آخر یعنی موتور DC. همه جا پین دیجیتال خروجی بود یعنی ما ( آردوینو ) به فلان پایه دستور می دادیم 0 شو، یا 1 شو یا در مواقع pwm عدد متغیر می دادیم( انشاءالله که یادتونه).

الان نه! می خوایم از پایه دیجیتال بخونیم. فرض کنید یه سنسور دیجیتال داریم مثلا تشخیص حرکت . روش کار این سنسور دیجیتال اینطوریه که اگه کسی از جلوش رد بشه 1 رو بر میگردونه و در حالت عادی هم روی پایه سیگنالش 0 می افته. حالا این سنسور با این شرح عملکرد تو محیط قرار گرفته. اگه بخوایم داده سنسور رو با استفاده از آردوینو بخونیم مسلما باید بریم سراغ پین های دیجیتال ( چون سنسور دیجیتاله) و پین دیجیتال رو به عنوان ورودی استفاده کنیم . حالا این که اصن چرا اصرار دارم ورودی باشه؟
ببینید وقتی می خواستیم یه LED رو روشن کنیم ما دستور می دادیم که روش بشه در نتیجه فرمان دهنده ما بودیم. الان داستان کاملا برعکسه. الان سنسور داره دستور میده . وقتی روی پایه سیگنالش عدد 1 بیفته یعنی داره خبر میده که یکی از جلوش رد شده. بنابراین ما در نقش پذیرنده فرمان هستیم و به همین علت ساده پین دیجیتال متصل به سنسور از نوع ورودی تعریف میشه.

حالا تو این جلسه به جای این که از سنسور به عنوان تولید کننده پالس دیجیتال استفاده کنیم از سوئیچ استفاده می کنیم. سوئیچ ها خیلی متنوع هستن چند نمونش رو ببینید:

ولی ما از هیچ کدوم اینا استفاده نمی کنیم. از این ماژول استفاده می کنیم.

سوئیچ های معمولی فقط بهت میگن فشار داده شدن یا نه ولی این سوئیچ علاوه بر اون قابلیت بهت میگه در کدوم جهت فشار داد شده. اگه به عکس پشت ماژول نگاه کنین علاوه بر پایه VCC (پایه ولتاژ) و GND (زمین) 5 تا پایه دیگه هم بیرون کشیده شده که به این صورتن:
Right (راست)، Down (پایین)، Left (چپ)، Center (مرکز) و Up (بالا).
حالا اگه کلید به سمت بالا فشار داده بشه پایه منطق پایه Up یک میشه ( از نظر ولتاژی یعنی ولتاژ این پایه ماژول 5 ولت میشه ) ، اگه کلید به سمت چپ فشار داده بشه پایه منطق پایه Left یک میشه و الی آخر.

برای اتصال این ماژول به آردوینو باید علاوه بر اتصال VCC و GND ، بقیه پین ها رو به 5 تا پین دیجیتال وصل کنیم.
اگه یادتون باشه (آیا؟) جلسه های قبل برای اتصال LED و موتور با یه سوال بزرگ مواجه می شدیم و سوال این بود که آیا به هر پین دیجیتالی می تونیم وصل کنیم؟ اونجا متناسب با پروژه جواب فرق داشت یا آره بود یا نه بود. اما تو مقوله استفاده از پین دیجیتال به عنوان ورودی هیچ استثنایی وجود نداره و از هر پین دیجیتالی میشه استفاده کرد بنابراین راحت باشید.

بنابراین اتصال ماژول به آردوینو به صورت زیر خواهد بود:

5 تا پین دیجیتال استفاده شده در این مدار می تونن هر 5 پین دیجیتال دلخواهی باشن.
مدار رو بستید؟
تمام؟
خب میریم سراغ کد نویسی
نرم افزار آردوینو رو باز کنید تا شروع کنیم.
پروژه ما اینه: هر جهتی که سوئیچ فشار داده شد تو کنسول آردوینو اون جهت نوشته بشه، مثلا اگه کلید به سمت پایین فشار داده شد تو کنسول نوشته بشه Down.
قدم اول نوشتن هدر برنامه هست:
ببینید تو هدر برنامه صرفا معرفی می کنیم، حالا این معرفی میتونه پین های مورد استفاده باشه، می تونه کتابخونه های مورد استفاده باشه و یا متغیرهایی که در طول برنامه قراره روشون کار کنیم. تو این پروژه ما از هیچ کتابخونه خاصی استفاده نمی کنیم بنابراین فقط پین هایی رو که استفاده کردیم براشون اسم انتخاب می کنیم(همون معرفی)
مثلا شماره پینی که به پین راست ماژول سوئیچ وصل شده پین شماره 6 آردوینو هست. تو هدر برنامه اسم این پین رو right_pin گذاشتیم. با این کار تا آخر برنامه هر بار با این پین کار داشته باشیم از اسم right_pin استفاده می کنیم. در مورد 4 پین دیجیتال دیگه هم همین قانون حاکمه.

مرحله بعد تابع setup هست. قرارمون این بود که هر چی کانفیگ داریم رو بزاریم تو این تابع. الان چند تا کانفیگ داریم یا به زبون دیگه چیا رو باید کانفیگ کنیم؟
چون قراره خروجی کار رو تو کنسول ببینیم یکی از کانفیگ ها تنظیم نرخ داده (Baude Rate) هست که روی 9600 تنظیمش می کنیم.
از طرف دیگه داریم 5 تا پین دیجیتال رو استفاده می کنیم که طبق قوانین مطرح شده تو جلسات قبل لازمه ورودی بودنشون تو تابع setup بیان بشه.
بنابراین دو تا کانفیگ لازم داریم که به صورت زیر کد نویسی می کنیم:

و اما تابع loop:
خب روند کار تو این تابع اینطوری هست که اول مقدار پایه دیجیتال رو می خونیم و توی یه متغیر نگهش می داریم .اگه مقدار 1 بود ( که یعنی کلید فشار داده شده) کامند مناسب اون رو تو کنسول چاپ می کنیم. من کد برای یه پین رو می نویسم که به صورت زیر میشه:

کد رو با 4 قسمت مختلف از هم جدا کردم که تک به تک میریم جلو:

1.هر خطی که با دو تا اسلش شروع بشه (//) جزء دستور و خط برنامه به حساب نمیاد و اصطلاحا بهش میگن کامنت (بعدا خودمون هم کامنت میزاریم)
2.روند رو یادتونه؟ گفتم اول پایه دیجیتال آردوینو رو می خونیم. تو این خط برنامه دقیقا داریم همین کار رو می کنیم. به کمک دستور digitalRead مقدار پین دیجیتال رو می خونیم. همونطور که میبیند این دستور یه ورودی داره که همون پین دیجتالی هست که قراره خونده بشه. الان تو ورودی تابع right_pin نوشته شده که اسم دیگه همون پین دیجیتال شماره 6 هست. مقدار خونده شده توسط دستور digitalRead (که یا 0 هست یا 1) درون متغیر right_value ریخته شده.
3.قدم بعد باید چک کنیم داده خونده شده از پین دیجیتال 1 بوده یا نه؟ هر جا شرطی ایجاد میشه یعنی تابع if : الان تو تابع if گفتیم اگه مقدار متغیر right_value ( که همون داده پین دیجیتال رو داره) مساوی با 1 بود (یعنی کلید به سمت راست فشار داده شده بود) بیا کل دستورهای بین دو آکولاد رو اجرا کن.

4.در صورتی که کلید به سمت راست فشار داده شده باشه بنابراین برنامه وارد این تابع if میشه و با دستور Serial.println ما کلمه Right رو توی کنسول چاپ می کنیم و تمام.

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

Tag Archives: سوئیچ