بنیادی آردوینو پروگرامنگ سیکھنا - نوواردوں کے لئے سبق آموز

اس ٹیوٹوریل میں ہم مثال کے کوڈز اور نمونہ پروگراموں کے ذریعہ بنیادی آرڈینو پروگرامنگ کرنے کا طریقہ سیکھتے ہیں۔ یہ سبق ان سب نئے آنے والوں کے لئے ایک انتہائی قابل نصاب نصاب ثابت ہوسکتا ہے جو آسان ، قابل فہم زبان کے ذریعہ بنیادی باتوں کو سمجھنا چاہتے ہیں۔

تعارف

کے مطابق ویکیپیڈیا مائکروکنٹرولر ایک واحد آئی سی چپ کے اندر منی کمپیوٹر کے برابر ہے ، جس کا اپنا کور پروسیسر ، پروگرام ایبل ان پٹس ، میموری اور آؤٹ پٹ پیریفیرلز ہیں۔

مائکروکونٹرولر صارف کے ل so اتنا مفید ہوجاتا ہے کیونکہ یہ ایک بلٹ میں پروسیسر ، میموری اور ان پٹ / آؤٹ پٹ پورٹ (جسے جی پی آئی او یا عام مقصد ان پٹ / آؤٹ پٹ پن بھی کہا جاتا ہے) پیش کرتا ہے جسے ہم کسی بھی مطلوبہ تفصیلات کے مطابق صارف کے ذریعہ کنٹرول کرسکتے ہیں۔

اس ٹیوٹوریل میں ہم پروگراموں کو سیکھنے اور جانچنے کے لئے ایک ارڈینو یونو بورڈ کے ساتھ کام کریں گے۔ ہارڈ ویئر اسمبلی کی جانچ اور انضمام کے ل For ہم ایک بریڈ بورڈ استعمال کریں گے۔

اب ہم تیزی سے آگے بڑھتے ہیں اور سیکھتے ہیں کہ اریڈینو پروگرامنگ کے ساتھ کیسے شروعات کی جائے۔

1.2 سافٹ ویئر انسٹال کرنا (ونڈوز)

اس کے ل you آپ کو انٹرنیٹ تک رسائی کی ضرورت ہوگی ، جو ظاہر ہے کہ آپ اپنے کمپیوٹر میں موجود ہوں گے۔ براہ کرم مندرجہ ذیل لنک پر جائیں اور IDE سافٹ ویئر ڈاؤن لوڈ کریں۔

غیر منتظم انسٹال کیلئے ونڈوز زپ فائل

ڈاؤن لوڈ کرنے کے بعد آپ کو ڈاؤن لوڈ کے فولڈر میں اردوینو سیٹ اپ کا آئیکن ملے گا ، جو اس طرح نظر آئے گا:

ایک بار جب آپ یہ حاصل کرلیں ، آپ آسانی سے اس پر ڈبل کلک کرسکتے ہیں اور اپنے کمپیوٹر میں آرڈینوینو انٹیگریٹڈ ڈویلپمنٹ ماحولیات (IDE) انسٹال کرسکتے ہیں۔ مکمل عمل کو مندرجہ ذیل ویڈیو میں دیکھا جاسکتا ہے۔

1.4 ہمارے پہلے سرکٹ کے ساتھ شروع ہو رہا ہے

اس سے پہلے کہ ہم پروگرامنگ کی اصل تکنیکوں کو سیکھ لیں ، کسی بھی نئے بچے کے ل an ایک بنیادی جزو جیسے ایل ای ڈی کے ساتھ شروع کرنا مفید ہوگا ، اور یہ سمجھنا ہوگا کہ اسے اریڈوینو کے ساتھ کس طرح جوڑنا ہے۔

جیسا کہ ہم جانتے ہیں کہ ایل ای ڈی ایک روشنی خارج کرنے والا ڈایڈڈ ہے جس میں قطبی خطرہ ہے اور اگر وہ سپلائی کے صحیح ڈنڈوں سے منسلک نہیں ہے تو روشن نہیں ہوگی۔

ایل ای ڈی کے ساتھ ایک اور پہلو یہ ہے کہ یہ ڈیوائس کم کرنٹ کے ساتھ کام کرتی ہیں اور فوری طور پر خراب ہوسکتی ہیں اگر مناسب حساب سے چلنے والا ریسسٹر اس کے پنوں میں سے کسی ایک کے ساتھ سیریز میں شامل نہ ہو۔

انگوٹھے کی ایک قاعدہ کے طور پر ، سپلائی ان پٹ میں ہر 5V اضافے کے لئے 330 اوہم 1/4 واٹ کافی مثالی ہے تاکہ موجودہ کو مطلوبہ محفوظ سطح تک محدود کر سکے۔ لہذا 5V کے لئے یہ 330 اوہس ہوسکتا ہے ، 10V کے لئے یہ 680 اوہم وغیرہ ہوسکتا ہے۔

اسمبلی کے لئے بریڈ بورڈ کا استعمال

براہ کرم یقینی بنائیں کہ آپ کس طرح استعمال کرنا جانتے ہیں بریڈ بورڈ اس باب میں بیان کردہ ٹیوٹوریل کو آزمانے سے پہلے ، کیوں کہ ہم یہاں تمام تجربات کے ل. ایک روٹی بورڈ استعمال کریں گے۔

بنیادی ایل ای ڈی کنکشن سیٹ اپ کا مشاہدہ نیچے کیا جاسکتا ہے:

آپ اوپر 3 بنیادی اجزاء دیکھ سکتے ہیں:

1. ایک 5 ملی میٹر ، 20 ایم اے ایل ای ڈی
2. a 330 اوہم 1/4 واٹ ریزسٹر
3. ایک ارڈینو بورڈ

صرف آریھ کے مطابق نظام کو جمع کریں۔

اگلا ، کمپیوٹر یوایسبی سے اریڈوینو تک 5 وی پلگ ان کریں۔ جیسے ہی آپ یہ کریں گے آپ کو ایل ای ڈی لائٹنگ کو دیکھیں گے۔

میں جانتا ہوں کہ یہ بہت بنیادی ہے ، لیکن یہ شروع سے ہی شروع کرنا اچھا ہے۔ آرام کی یقین دہانی کرانے والی چیزیں آگے بڑھتے ہی مزید دلچسپ اور دلچسپ ہونے لگیں گی۔

1.5 اردوینو کے ساتھ ایل ای ڈی کنٹرول کرنا

اب ہم سیکھیں گے کہ ایک آرڈینو پروگرام کے ذریعہ ایل ای ڈی کو کیسے کنٹرول کیا جائے۔

پروگرام لکھنے کے لئے ہمارے پاس ہر پروگرام میں کم از کم 2 فنکشنز ہونے چاہئیں۔

کسی فنکشن کو پروگرامنگ بیانات کی ایک سیریز کے طور پر سمجھا جاسکتا ہے جسے ایک نام کے ساتھ تفویض کیا جاسکتا ہے ، جیسا کہ ذیل میں دیا گیا ہے:

1. سیٹ اپ () یہ پروگرام کے آغاز کے دوران کہا جاتا ہے یا اس پر عمل درآمد کیا جاتا ہے۔
2. لوپ () اس کو اردوینو کی پوری آپریشنل مدت کے دوران بار بار کہا جاتا ہے یا اس پر عمل درآمد کیا جاتا ہے۔

لہذا ، اگرچہ اس میں عملی فعالیت نہیں ہوسکتی ہے ، لیکن تکنیکی طور پر ایک مختصر ترین جائز اردوینو پروگرام لکھا جاسکتا ہے۔

آسان ترین پروگرام

void setup()
{
}
void loop()
{
}

آپ نے دیکھا ہوگا کہ بہت ساری پروگرامنگ زبانوں میں ، نظام ڈسپلے اسکرین پر ایک عام پرنٹ 'ہیلو ، ورلڈ' دکھا کر شروع ہوتا ہے۔

مائکرو کنٹرولر تشریح میں اس جملے کے لئے الیکٹرانک مساوی ایک ایل ای ڈی کو آن اور آف کرنا ہے۔

یہ سب سے بنیادی پروگرام ہے جسے کوئی لکھ سکتا ہے اور اس پر عمل درآمد کرسکتا ہے تاکہ اس نظام کے صحیح کام کی نشاندہی کی جاسکے۔

ہم مندرجہ ذیل کوڈ کے ذریعے عمل کو سمجھنے اور سمجھنے کی کوشش کریں گے۔

فہرست سازی 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

ٹھیک ہے ، اب ہم یہ سمجھیں کہ کوڈ کی ہر لائن کا کیا مطلب ہے اور یہ فنکشن کو انجام دینے میں کیسے کام کرتا ہے:

const int kPinLed = 13

یہ ایک مستقل کی طرح کام کرتا ہے جو ہمیں مکمل پروگرامنگ کورس کے دوران اس کو استعمال کرنے کی اجازت دیتا ہے ، اصل قیمت کو استعمال کرنے کی ضرورت کے بغیر جو اس کے خلاف مقرر ہے۔

معیاری قواعد کے مطابق ابتدائی خط کے ساتھ اس طرح کے مستقل افراد کی پہچان ہوتی ہے کرنے کے لئے . اگرچہ یہ لازمی نہیں ہے ، لیکن جب بھی آپ کوڈ کوڈ کی تفصیلات سے گذرنے کی طرح محسوس ہوتا ہے تو اس سے چیزیں واضح اور آسانی سے قابل فہم ہوجاتی ہیں۔

void setup()
{
pinMode(kPinLed, OUTPUT)
}

یہ کوڈ مخصوص پن کو مرتب کرتا ہے جس میں ہماری ایل ای ڈی لگائی جاتی ہے۔ دوسرے لفظوں میں ، کوڈ ارڈینو کو 'پن' پڑھنے کی بجائے اس پن پر 'تحریر' پہلو پر قابو پانے کے لئے کہتا ہے۔

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

مذکورہ بالا لائنیں درخواست کی اصل عملدرآمد کی نشاندہی کرتی ہیں۔ کوڈ کا آغاز متعلقہ ایل ای ڈی کنکشن کے بارے میں ایک HIGH کو تحریری شکل میں دے کر اور ایل ای ڈی کو موڑنے سے ہوتا ہے۔

یہاں ، ایچ ای ایچ کی اصطلاح کا سیدھا مطلب ہے کہ اردوینو کے متعلقہ پن پر +5 وی بننا ہے۔ اضافی اصطلاح LOW صرف نامزد پن پر ایک صفر یا 0V کی نشاندہی کرتا ہے۔

اگلا ، ہم delay() فون کرتے ہیں جس کا کام ملی سیکنڈ (ایک سیکنڈ کا 1/1000 ویں) کے ذریعہ تاخیر پیدا کرنا ہے۔ چونکہ اعداد و شمار 500 داخل کیا گیا ہے ، اس لئے جو تاخیر کی گئی ہے وہ 1/2 سیکنڈ کے لئے ہوگی۔

جیسے ہی یہ 1/2 سیکنڈ ختم ہوجاتا ہے ، اگلی لائن کو پھانسی دے دی جاتی ہے جو ایل ای ڈی کو اسی پن پر کم اصطلاح کے ساتھ بند کردیتی ہے۔

اس کے بعد والی لائن میں ایک بار پھر 1/2 سیکنڈ کی تاخیر پیدا ہوتی ہے ، تاکہ ایل ای ڈی کو 1/2 سیکنڈ تک بند رہنے دیا جاسکے۔

اور عمل کوڈ کی لائنوں پر عمل درآمد تک لامحدود طور پر جاری رہتا ہے ، جب تک کہ اردوینو کو اقتدار میں رکھا جاتا ہے۔

اگلے درجے پر جانے سے پہلے ، میں آپ کو سفارش کروں گا کہ براہ کرم مذکورہ کوڈ کو پروگرام کریں اور چیک کریں کہ آیا آپ ایل ای ڈی / آف ترتیب کو صحیح طریقے سے نافذ کرنے کے قابل ہیں یا نہیں۔

چونکہ اڑدوینو میں ڈیفالٹ ایل ای ڈی پن # 13 کے ساتھ جڑا ہوا ہے ، لہذا اسے فوری طور پر مذکورہ پروگرام کا جواب دینا چاہئے اور چمکانا شروع کرنا چاہئے۔ تاہم ، اگر آپ کو معلوم ہوتا ہے کہ آپ کی بیرونی ایل ای ڈی چمکتی نہیں ہے تو آپ کے ایل ای ڈی کے ساتھ کنکشن کی غلطی ہوسکتی ہے ، آپ اپنی ایل ای ڈی کی واضحیت کو تبدیل کرنے کی کوشش کرسکتے ہیں اور امید ہے کہ یہ بھی چمکتا ہوا نظر آئے گا۔

آپ '500' کے اعداد و شمار کو کسی دوسری قیمت میں تبدیل کرکے تاخیر کے ساتھ کھیل سکتے ہیں اور ایل ای ڈی کو 'سننے' کو کمانڈوں پر ڈھونڈ سکتے ہیں اور اس کی وجہ سے مخصوص تاخیر والے اقدار کے مطابق فلیش کر سکتے ہیں۔

لیکن یاد رکھنا ، اگر آپ دیکھتے ہیں کہ ایل ای ڈی آپ کی تاخیر کے وقت کی تبدیلی سے قطع نظر ، مستقل 1 سیکنڈ ریٹ کے ساتھ چمکتی نہیں ہے ، اس سے یہ ظاہر ہوتا ہے کہ کوڈ کسی غلطی کی وجہ سے کام نہیں کررہا ہے۔ کیونکہ پہلے سے طے شدہ طور پر آرڈینو 1 سیکنڈ کی چمکتی ہوئی شرح کے ساتھ پروگرام کیا جائے گا۔ لہذا اس کے صحیح کام کی تصدیق کے ل this یہ شرح آپ کے کوڈ کے مطابق مختلف ہوجائے گی۔

1.7 تبصرے

کوڈز کی لائنیں جنہیں ہم اوپر سمجھ گئے تھے وہ خاص طور پر کمپیوٹر سافٹ ویئر کے لئے لکھے گئے تھے۔

تاہم ، اس بات کا یقین کرنے کے لئے کہ صارف لائنوں کے معنی حوالہ کرنے اور ان کو سمجھنے کے قابل ہے ، کوڈز کی مطلوبہ خطوط کے ساتھ وضاحت لکھنا اکثر کارآمد اور سمجھدار ہوسکتا ہے۔

یہ کہا جاتا ہے تبصرے جو صرف انسانی یا صارف کے حوالہ کے ل written لکھے گئے ہیں ، اور کوڈ کوڈ کیے گئے ہیں تاکہ کمپیوٹر کو اسے محفوظ طریقے سے نظرانداز کرسکیں۔

ان تبصروں کی زبان کچھ شکلوں کے ساتھ لکھی گئی ہے۔

1. تبصرہ کا بلاک اسٹائل ، جس میں تبصرہ کی تفصیل آغاز علامت / * اور اختتامی علامت * / کے تحت منسلک ہے۔
2. اس کو ایک لائن میں محدود کرنے کی ضرورت نہیں ہے بلکہ تبصرے کی وضاحت یا وضاحت پر انحصار کرتے ہوئے اگلی لینوں تک بڑھایا جاسکتا ہے ، جیسا کہ مندرجہ ذیل مثال میں دکھایا گیا ہے:

/ * یہ ایک تبصرہ ہے * /

/ * تو یہ ہے * /

/ * اور
* یہ
* جیسے
* اچھا * /

کسی تبصرہ کے لئے فوری سنگل لائن تفصیل لکھنے کے لئے ، شروع میں دو سلیش // علامت کافی ہوجاتا ہے۔ یہ کمپیوٹر کو بتاتا ہے کہ اس لائن کا اصل کوڈ سے کوئی لینا دینا نہیں ہے ، اور اسے نظرانداز کیا جانا چاہئے۔ مثال کے طور پر:

// یہ ایک ایسا تبصرہ ہے جس کو کمپیوٹر نظرانداز کریں گے۔

حوالہ کے لئے ایک مثال یہ ہے:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 خرابیوں کا سراغ لگانا

اگر آپ کو اپنے پروگرام کو مرتب کرتے وقت کسی غلطی کا مظاہرہ کرتے ہوئے ، یا کسی اور مسئلے کا پتہ چلتا ہے تو ، درج ذیل نکات آپ کو ممکن ہے کہ اپنے کوڈ کی جانچ پڑتال میں رکاوٹ سے نجات حاصل کریں۔

1. آپ کے پروگرام کی زبان کیس کی حساس ہوگی۔ مثال کے طور پر اظہار myVar لکھا نہیں جاسکتا مائی ویور
2. ہر طرح کی سفید جگہیں جو آپ کے کی بورڈ ٹائپنگ کے ذریعہ سرانجام دی جاسکتی ہیں ، بالآخر ایک ہی جگہ کی طرح پیش کی جاتی ہیں ، اور یہ صرف آپ کے ذریعہ نظر آتا ہے یا سمجھا جاتا ہے ، کمپیوٹر اس کو خاطر میں نہیں لائے گا۔ سیدھے الفاظ میں ، کسی بھی طرح کی خالی جگہوں کا کوڈ کے نتائج پر کوئی اثر نہیں پڑے گا۔
3. کوڈ کے ہر بلاک کو بائیں اور دائیں گھوبگھرالی خطوط کے ساتھ منسلک کیا جانا چاہئے ، '{' اور '}'
4. نمبر ہندسوں کو کوما کے ساتھ الگ نہیں کیا جانا چاہئے۔ مثال کے طور پر ، 1000 کو 1000 نہیں لکھا جاسکتا ہے۔
5. گھوبگھرالی خطوط وحدان کے درمیان منسلک ہر کوڈ لائن کو ایک سیمیولون کے ساتھ ختم ہونا چاہئے

آرڈوینو کے ساتھ دلچسپ یلئڈی لائٹ سیکوینس تشکیل دینا

ہمارے پچھلے باب میں ہم نے یہ سیکھا ہے کہ مستقل تاخیر کی شرح کے ساتھ مسلسل ایل ای ڈی آن / آف پلکیں۔

اب ہم سیکھیں گے کہ کس طرح پروگرام کوڈ کو اپ گریڈ کرکے ایک ہی ایل ای ڈی پر مختلف تاخیر کے نمونوں کو انجام دیا جاسکتا ہے۔

ہم بیرونی ایل ای ڈی کا استعمال نہیں کریں گے ، بلکہ پن # 13 پر ارڈینو بورڈ میں تعمیر شدہ ڈیفالٹ ایل ای ڈی کا استعمال کریں۔ آپ یہ چھوٹا سا ایس ایم ڈی ایل ای ڈی یوایسبی کنیکٹر کے بالکل پیچھے تلاش کرسکتے ہیں۔

2.2 اگر بیانات کو سمجھنا

اس سیکشن میں ہم سیکھیں گے کہ کس طرح کنٹرول ڈھانچے ہمیں انفرادی کوڈ چلانے کے قابل بناتے ہیں ، اور ضرورت کے مطابق کچھ وقت تک بار بار بھی۔

بیان اگر پہلا کنٹرول ڈھانچہ بن جاتا ہے۔ مندرجہ ذیل عمل درآمد سے پتہ چلتا ہے کہ اسے کس طرح استعمال کیا جاتا ہے:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

ہم مذکورہ کوڈ کو مرحلہ وار سمجھنے کی کوشش کریں گے اور سیکھیں گے کہ اس طرح کی دیگر پھانسیوں کے لئے اس کا استعمال کیسے ہوسکتا ہے۔

پہلی اور ساتویں لائن کے درمیان کوڈ ہمارے ابتدائی پروگرام سے بالکل یکساں ہیں۔

پہلی ترمیم دراصل آٹھویں لائن پر ہوتی ہے۔

int delayTime = 1000

آپ کو پہلی لائن کے کوڈ کی طرح پایا جاسکتا ہے ، اس حقیقت کو چھوڑ کر کہ اس کی اصطلاح ختم نہیں ہو رہی ہے const.

یہ محض اس لئے ہے کہ ، یہ ضابطہ مستقل نہیں ہے۔ اس کی بجائے اس کی وضاحت کی گئی ہے متغیر ، جو پروگرامنگ کے دوران متغیر قدر کی خاصیت رکھتا ہے۔

مذکورہ بالا مثال میں آپ دیکھ سکتے ہیں کہ اس متغیر کو 1000 کی قیمت سے منسوب کیا گیا ہے۔ یاد رکھیں ، اس طرح کے متغیرات جو گھوبگھرالی خطوط وحدانیت کے ساتھ منسلک ہوتے ہیں صرف گھوبگھرالی خط وحدانی کے جوڑے کے اندر سختی سے لکھے جاتے ہیں ، اور انھیں 'مقامی' متغیر کہا جاتا ہے۔

متبادل کے طور پر ، متغیرات جو باہر کے گھوبگھرالی خط وحدانیت کے سمجھے جاتے ہیں ، جیسے ہم ابھی گفتگو کر رہے ہیں وہ 'عالمی' کے طور پر پہچان جاتے ہیں ، اور پروگرام کوڈ کے اندر کہیں بھی اس پر عمل درآمد کیا جاسکتا ہے۔

آگے بڑھتے ہوئے ، آپ دیکھ سکتے ہیں کہ لائن 9 اور 11 کے درمیان کوڈ بھی پہلے پروگرام سے ملتے جلتے ہیں ، اس کے باوجود لائن 11 کے بعد چیزیں دلچسپ ہونے لگتی ہیں ، آئیے دیکھتے ہیں کہ کیسے!

delayTime = delayTime - 100

اس کوڈ میں ہم دیکھتے ہیں کہ تاخیر اس سے 100 کو گھٹا کر ترمیم کیا جارہا ہے۔

مطلب 100 کی ابتدائی قیمت 1000 سے کٹوتی ہے ، جو اسے 900 کی نئی قیمت فراہم کرتی ہے۔

مندرجہ ذیل تصویر کے ذریعہ ہم اردوینو زبان میں استعمال ہونے والے ریاضی کے کچھ آپریٹرز کو سمجھنے کی کوشش کریں گے۔

اب آئیے لائن 13 سے 15 کے درمیان کوڈ کا جائزہ لیں۔

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

مذکورہ بالا کوڈ کا بنیادی مقصد یہ یقینی بنانا ہے کہ ایل ای ڈی بغیر کسی مداخلت کے ٹمٹمانے جاری رہے۔

اس حقیقت کی وجہ سے کہ 100 سے اصل سے کٹوتی کی جارہی ہے تاخیر ، یہ ایل ای ڈی ٹمٹمانے کو صفر تک پہنچنے سے روکتا ہے اور ٹمٹمانے کو مسلسل چلتا رہتا ہے۔

مندرجہ ذیل تصویر میں کچھ موازنہ آپریٹرز دکھائے گئے ہیں جن کو ہم اپنے کوڈز میں استعمال کریں گے۔

ہمارے مذکورہ کوڈ میں ، ہم نے کوڈ کو جانچنا چاہ could | _ _ _ _ |

تاہم ، کیونکہ منفی شخصیت ہونا بھی اتنا ہی برا ہوسکتا ہے ، لہذا ہم اس کے لئے نہیں گئے ، اور یہ ایک تجویز کردہ عمل ہے۔

سوچئے کہ اگر ہم | _ _ + _ | 100 سے 100 کی بجائے 300 کٹوتی کرنے کی کوشش کرتے تو نتیجہ کیا ہوسکتا تھا؟

تو اب آپ کو اندازہ ہوگیا ہوگا کہ اگر if(delayTime == 0) صفر کے برابر یا اس کے برابر لکھا گیا ہے ، پھر تاخیر کا وقت اصل اعداد و شمار 1000 پر مقرر کیا جائے گا۔

delayTime

جیسا کہ اوپر دکھایا گیا کوڈ کی آخری 4 لائنیں ایل ای ڈی کو آن / آف ، آن / آف کو مسلسل موڑ دینے کے لئے ذمہ دار ہوجاتی ہیں۔

یہاں آپ واضح طور پر دیکھ سکتے ہیں کہ متعدد اعداد و شمار کو استعمال کرنے کے بجائے ، ہم نے تاخیر کا وقت تفویض کرنے کے لئے متغیر کا استعمال کیا ہے تاکہ ہم اس کو ایڈجسٹ کرسکیں جیسے ہم کوڈ کے آپریشنل دورانیے کے دوران چاہتے ہیں۔ ٹھیک ہے نا؟

2.3 ELSE کے بیانات

یہاں ہم سیکھیں گے کہ کیوں اور کیسے اگر اصطلاح میں ایک شق ہوسکتی ہے اور تاکہ یہ صورت حال کا فیصلہ کرے اگر بیان غلط ہے۔

مجھے افسوس ہے اگر یہ بہت الجھا ہوا لگتا ہے تو ، فکر نہ کریں ، ہم اسے مندرجہ ذیل مثال کے ساتھ سمجھنے کی کوشش کریں گے۔

delayTime

مندرجہ بالا میں آپ اچھی طرح سے دیکھ سکتے ہیں کہ 10 ویں لائن کوڈ میں صرف اس وقت عمل درآمد کیا جاتا ہے جب | _ _ + _ | 100 سے کم یا برابر ہے ، اگر نہیں تو پھر 13 ویں لائن میں کوڈ کو پھانسی دے دی جائے گی ، لیکن دونوں کبھی بھی نہیں ہوسکتے ہیں ، یا تو 10 ویں لائن یا 13 ویں لائن کوڈ کو لاگو کیا جائے گا ، دونوں کبھی نہیں۔

آپ نے محسوس کیا ہو گا کہ ہم نے اپنے سابقہ ​​سیکشن 2.2 میں جو کچھ کیا ہے اس کے برعکس ، یہاں ہم 100 کے مقابلے میں 0 کے ساتھ موازنہ نہیں کرتے ہیں۔ اس کی وجہ یہ ہے کہ اس مثال کے مقابلے میں ہم سیکشن 2.2 کے مقابلے میں 100 کو ، اس کے برخلاف مقابلہ کرتے ہیں۔ منہا کیا آپ بتا سکتے ہیں کہ اگر ہم 100 کی بجائے 0 کا موازنہ کرتے تو کیا ہوسکتا ہے؟

2.4 جب بیانات

TO جبکہ بیان بالکل اسی طرح کی ہے اگر بیان ، اس حقیقت کے علاوہ کہ اس کوڈ کے بلاک (جس میں گھوبگھرالی خط وحدانی کے درمیان ہوسکتی ہے) پر بار بار عمل درآمد ہوتا ہے شرائط لاگو ہوتی ہیں ، اور بغیر کسی کام کے اور بیان

مندرجہ ذیل مثال سے آپ کو اس کو بہتر طور پر سمجھنے میں مدد ملے گی

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

کیا آپ اندازہ لگا سکتے ہیں کہ مذکورہ کوڈ کو کیا کرنا ہے؟ ٹھیک ہے ، یہ ایل ای ڈی کو تیزی سے اور پھر آہستہ کرنے کے لئے ڈیزائن کیا گیا ہے۔

2.5 درست اور غلط کیا ہے؟

پروگرامنگ زبان میں ، جھوٹا صفر (0) سے مراد ہے۔ اصل میں 'سچ' استعمال نہیں ہوتا ہے ، اس کے بجائے یہ فرض کیا جاتا ہے کہ جب کچھ بھی جھوٹا نہیں ہوتا ہے ، تب جو کچھ شامل کیا جاتا ہے وہ سچ ہوتا ہے۔

یہ تھوڑا سا عجیب لگتا ہے تاہم یہ کام بہت عمدہ طریقے سے کرتا ہے۔

ہم مندرجہ ذیل مثال کے ذریعہ صورتحال کو سمجھنے کی کوشش کریں گے۔

آپ کبھی کبھی نیچے دیئے گئے کوڈ کو دیکھ سکتے ہو:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

ایسا لگتا ہے کہ ایسا لگتا ہے جیسے ایل ای ڈی عمل درآمد ہمیشہ سائیکل چلاتا رہے گا ، جب تک بجلی دستیاب ہے۔

تاہم ، اس قسم کے کوڈ کا ایک کمی اس وقت پیدا ہوسکتی ہے جب غلطی سے صارف == کی بجائے a = کا اطلاق کرتا ہے۔

مجھے یقین ہے کہ آپ پہلے ہی جانتے ہیں کہ = ایک اسائنمنٹ کی نشاندہی کرتا ہے ، یعنی اس کا استعمال متغیر کے لئے منتخب کردہ قدر کو نامزد کرنے کے لئے کیا جاتا ہے ، جب کہ ایک == ٹیسٹ کو نافذ کرنے کے لئے استعمال کیا جاتا ہے اگر قیمت ایک جیسی ہو۔

مثال کے طور پر فرض کریں کہ آپ کو یکساں رفتار سے چلنے والے پیٹرن کے ساتھ فلیش اور دوبارہ تکرار کے لئے ایل ای ڈی کی ضرورت تھی ، لیکن == کی بجائے غلط = ایک = کا استعمال کیا گیا۔

اس کے بعد کوڈ اس طرح ظاہر ہوگا:

delayTime

غلطی 0 سے const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
} تفویض کرے گی ، اور اس کا باعث بنے گی اگر بیان کرنے کے لئے کہ آیا 0 درست تھا یا نہیں۔ چونکہ 0 سے مراد غلط ہے ، لہذا وہ سوچے گا کہ یہ سچ نہیں ہے ، اور while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
} | کے نفاذ کو روک دے گی ، لیکن اس کے بجائے فنکشن int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
} لوپ () کے دوران 0 پر منعقد ہوتا ہے۔

یہ بہت ناپسندیدہ لگتا ہے !!

لہذا ، یہ یقینی بنانے کے لئے ہمیشہ اپنے پروگرام کو ڈبل چیک کریں کہ آپ نے ایسی کوئی غلط غلطی نہیں کی ہے۔

2.6 مجموعے

کبھی کبھی آپ کو ایک ساتھ کئی چیزوں کی جانچ کرنے کی ضرورت محسوس ہوسکتی ہے۔ جیسے ، آپ یہ جانچ سکتے ہیں کہ آیا کوئی متغیر دو نمبروں کے درمیان تھا۔ اگرچہ اس بیان کو متعدد بار بیان کے ذریعہ نافذ کیا جاسکتا ہے ، لیکن بہتر اور آسان پڑھنے کے ل for منطقی امتزاج کو استعمال کرنا زیادہ آسان ہوسکتا ہے۔

منطقی اصطلاحات پر امتزاج کو نافذ کرنا 3 طریقوں سے کیا جاسکتا ہے ، جیسا کہ مندرجہ ذیل ٹیبل میں دکھایا گیا ہے:

یہ جاننا دلچسپ ہوگا کہ نوٹ آپریٹر کسی متغیر کے لئے سوئچر کا کام کرسکتا ہے جسے یا تو متعین کیا جاسکتا ہے سچ ہے یا جھوٹا (یا کم یا اعلی)

مندرجہ ذیل مثال شرط کی وضاحت کرتی ہے:

delayTime

یہاں | _ _ + _ | کم ہو جائے گا ، اور اس کے بعد جیسے ہی | _ _ + _ | ، یہ ہائی ہو جائے گا۔ مندرجہ ذیل لوپ کا سبب بنے گی۔ _ _ _ _ | جب اعلی ہونا چاہئے | _ _ _ _ | کم ہے.

2.7 بیانات کے لئے

اب ہم ایک اور کنٹرول ڈھانچے کے بارے میں سمجھنے کی کوشش کریں گے جو ایک ہے کے لئے لوپ جب آپ کسی چیز کو متعدد بار نافذ کرنا چاہتے ہو تو یہ بہت آسان ہوسکتا ہے۔

آئیے اس کو مندرجہ ذیل مثال کے ساتھ سمجھیں:

delayTime = 1000

آپ کو لائن میں کچھ انوکھی چیز مل سکتی ہے کے لئے

یہ کوڈ ہے میں ++؟ . یہ ایسے پروگرامرز کے لئے مفید ہے جو بجائے سست ہیں اور آسان شارٹ کٹ کے ذریعے کوڈنگ کو نافذ کرنا چاہتے ہیں

مذکورہ بالا اصطلاح کو کمپاؤنڈ آپریٹرز کے نام سے جانا جاتا ہے ، کیونکہ وہ ایک اسائنمنٹ آپریٹر کو دوسرے اسائنمنٹ آپریٹر کے ساتھ جوڑنے کا کام کرتے ہیں۔ مندرجہ ذیل جدول میں ان میں سے سب سے مقبول کو دیکھنے میں لایا جاسکتا ہے۔

آپ کو معلوم ہوگا کہ بیان کیلئے ایک بیان میں 3 ذیلی بیانات موجود ہیں۔ اس کا ڈھانچہ جیسا کہ ذیل میں دکھایا گیا ہے:

delayTime

بیان # 1 بالکل شروع میں ہوتا ہے اور صرف ایک بار۔ لوپ کے دوران ہر بار حالت کا تجربہ کیا جاتا ہے۔ جب بھی ہوتا ہے سچ ہے گھوبگھرالی خطوط کے اندر ، اس کے بعد کا بیان # 2 نافذ ہوتا ہے۔ کی صورت میں a جھوٹا ، نظام کوڈ کے اگلے بلاک پر چھلانگ لگاتا ہے۔

مزید ایل ای ڈی کو منسلک کرنا

ٹھیک ہے ، اب ہم دیکھیں گے کہ مزید دلچسپ اثرات کے ل for ہم زیادہ تعداد میں ایل ای ڈی کو کس طرح مربوط کرسکتے ہیں۔

براہ کرم ایل ای ڈی اور آرڈوینو جیسا کہ نیچے دکھایا گیا ہے کو جوڑیں۔ ریڈ تار دراصل ضروری نہیں ہے ، لیکن چونکہ بریڈ بورڈ میں سپلائی کی دونوں ریلیں شامل کرنا ہمیشہ ہی ایک اچھا خیال ہے جب سیٹ اپ کے معنی ہیں۔

اب آئیے ایک ایسا پروگرام ٹھیک کریں جو ہمیں یہ جانچنے کے قابل بنائے کہ آیا ہمارے ہارڈ ویئر کو صحیح طریقے سے تشکیل دیا گیا ہے یا نہیں۔

یہ ہمیشہ تجویز کیا جاتا ہے کہ پروگراموں کے چھوٹے چھوٹے ٹکڑوں کوڈ کریں اور ان پر عمل درآمد کریں تاکہ یہ چیک کریں کہ متعلقہ ہارڈ ویئر صحیح طریقے سے وائرڈ ہے یا نہیں۔

اس سے ممکنہ خرابی کو جلد ازالہ کرنے میں مدد ملتی ہے۔

ذیل میں کوڈ کی مثال ایل ای ڈی کو 2 سے 5 تک ایک مخصوص نمونہ فراہم کرتی ہے جس میں انہیں ایک دوسرے کے بعد ایک چکر کے طریقے سے موڑ دیا جاتا ہے۔

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

جیسا کہ آپ دیکھ سکتے ہیں ، کوڈ میں کچھ بھی غلط نہیں ہے ، سوائے اس حقیقت کے کہ یہ لمبا نظر آتا ہے اور اس وجہ سے غلطیوں کا شکار ہے۔

یقینا مذکورہ کوڈ کو لکھنے کے بہتر طریقے موجود ہیں ، مندرجہ ذیل سیکشن اس کو ظاہر کرے گا۔

2.9 متعارف کرانے والے ارے

ارے متغیرات کا ایک گروپ ہوسکتا ہے جسے انڈیکس نمبر کے ساتھ ترتیب دیا جاسکتا ہے۔ مندرجہ ذیل مثال اس کو بہتر طور پر سمجھنے میں ہماری مدد کرے گی۔

ledState

ٹھیک ہے ، اب ہم ہر حصے کو دیکھیں اور سمجھیں کہ وہ اصل میں کیسے کام کرتے ہیں۔

ledState = !ledState

مذکورہ کوڈ نے وضاحت کی ہے کہ ہمارے پاس کتنے زیادہ سے زیادہ عناصر صف میں موجود ہیں۔ اس کوڈ سے ہمیں اس کے بعد کے حصوں میں مدد ملتی ہے تاکہ یہ یقینی بنایا جاسکے کہ سب کچھ ایک صف میں لکھا گیا ہے اور صف ختم ہونے کے بعد کچھ بھی نہیں۔

ledState

اس اگلی لائن میں ہم نے سرنی کا ڈھانچہ ترتیب دیا۔ بریکٹ کے اندر کی تعداد صف میں موجود عناصر کی تعداد کی نشاندہی کرتی ہے۔ اگرچہ ، اصل مقدار لکھی جاسکتی تھی ، لکھنے سے مستحکم کام بہتر کام کرتے ہیں۔ اقدار کو عام طور پر کوما کے ساتھ بریکٹ کے اندر دیکھا جاسکتا ہے اور اقدار کو صف میں نامزد کیا جاسکتا ہے۔

جب آپ کو 0 کے ساتھ ترتیب والی کوئی صف ملتی ہے ، تو یہ صف میں پہلے عنصر کی نشاندہی کرتی ہے ، جیسا کہ <_ + _ | میں دکھایا گیا ہے۔

اسی طرح آخری عنصر | ledState = !ledState کے طور پر دکھایا جائے گا ، چونکہ 0 سے 3 تک کی گنتی 4 ہے۔

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

مذکورہ کوڈ میں ہر صف عناصر کے ذریعے آگے بڑھنے اور انہیں OUTPUTS کی حیثیت سے ترتیب دینے کیلئے لوپ کا استعمال ظاہر ہوتا ہے۔ صف میں شامل ہر عنصر تک پہنچنے کے ل We ہم انڈیکس کے ساتھ ساتھ مربع بریکٹ لاگو کرتے ہیں۔

اگر آپ سوچ رہے ہیں کہ آیا پن # 2 استعمال کرنے کے لئے # 5 پن کو بغیر کسی قطار کے استعمال کرنا ممکن ہے تو ، جواب جواب ہاں میں ہے ، یہ ممکن ہے۔ لیکن اس مثال میں ایسا نہیں کیا گیا کیوں کہ ہم نے اس طرح نہیں کیا۔ مندرجہ ذیل حصوں میں آپ سرنی نقطہ نظر کو ختم کرسکتے ہیں اگر منتخب کردہ آؤٹ پٹ لائن میں نہیں ہیں۔

آگے بڑھتے ہوئے ، دیکھتے ہیں کہ کوڈ کا اگلا بلاک کیا کرتا ہے:

for (statement1conditionstatement2){
// statements
}

یہاں کوڈ ہر ایل ای ڈی کے ذریعہ آگے بڑھتا ہے تاکہ 100 ملی سیکنڈ کے وقفے یا تاخیر کے ساتھ ترتیب وار ان کو تبدیل کیا جاسکے۔

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

مندرجہ بالا کوڈ کا استعمال کرتے ہوئے یہ ظاہر ہوتا ہے کہ کس طرح کا اطلاق ہوتا ہے لوپ کے لئے ریورس ترتیب میں بھی لوپ کے ذریعے منتقل کرنے کے لئے استعمال کیا جا سکتا ہے۔

اس کا آغاز const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
} سے ہوتا ہے کیونکہ صفوں کی اشاریہ صفر ہے۔ ہم | _ + + _ | سے شروع نہیں کرتے ہیں کیونکہ اس کا نتیجہ سرے کو ختم کرنے میں ہوگا۔

کوڈ> = 0 کو جانچنے کے لئے استعمال کرتا ہے تاکہ انڈیکس 0 میں پہلا عنصر یاد نہ آئے یا نظر انداز نہ ہو۔

باب 3

ایک ان پٹ کیا ہے؟

تو کیا ہم نے سیکھا ہے کہ آرڈینو کے استعمال سے چیزوں کو چلانے کا طریقہ۔ اس باب میں ہم اس بات پر تبادلہ خیال کریں گے کہ بیرونی پیرامیٹرز سے انٹرفیس کرکے اصلی دنیا کو کیسے سمجھنا ہے۔

3.1 پش بٹن کا استعمال

ہم سب جانتے ہیں کہ پش بٹن کیا ہے اور یہ کیسے کام کرتا ہے۔ یہ ایک قسم کا سوئچ یا بٹن ہے جو ایک افسردہ حالت میں رہتے ہوئے ایک سرکٹ مرحلے سے دوسرے لمحے میں سگنل کو جوڑتا ہے ، اور جاری ہونے پر سگنل کو توڑ دیتا ہے۔

3.1.1 ایک بٹن اور ایک ایل ای ڈی

ہم مذکورہ بالا تفصیلات کے مطابق اردوینو کے ساتھ آرڈوینو کو پش بٹن کے ساتھ مربوط کریں گے اور سیٹ اپ کی بنیادی ورکنگ اور عمل درآمد سیکھیں گے۔

اشارہ کیا گیا پش بٹن جسے مائکرو سوئچ پش بٹن بھی کہا جاتا ہے ، میں کل 4 پن (ہر طرف 2 جوڑے) ہیں۔ جب دھکیل دیا جاتا ہے تو ، ہر ایک جوڑ کی پن اندرونی طور پر شامل ہوجاتی ہے اور اس کے ذریعہ ایک کنکشن یا ترسیل کو قابل بناتی ہے۔

اس مثال میں ہم ان پنوں یا رابطوں میں سے صرف ایک جوڑی استعمال کررہے ہیں ، دوسری جوڑی غیر متعلقہ ہے لہذا اسے نظرانداز کردیا گیا ہے۔

آئیے آگے درج ذیل کوڈ کو لاگو کر رہے ہیں اور اسے کام کرتے ہوئے دیکھیں!

const int k_numLEDs = 4

آپ کو یہاں کچھ چیزیں مل سکتی ہیں جو غیر معمولی لگتی ہیں۔ آئیے مرحلہ وار ان کا پتہ لگائیں۔

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

پہلی چیز جو ہم کرتے ہیں وہ ہے ٹھیک کرنا بٹن پن کے طور پر ان پٹ میں جانتا ہوں کہ یہ بالکل بنیادی ہے۔

اگلا ، ہم تفویض کرتے ہیں ہائی کرنے کے لئے ان پٹ پن آپ کو حیرت ہے کہ ان پٹ پر کچھ بھی لکھنا کیسے ممکن ہے؟ یقینا ، یہ دلچسپ ہوسکتا ہے۔

اصل میں ، ایک اعلی کو ایک ارڈینو ان پٹ کو تفویض کرنے سے اندرونی 20 کلو اوہم پل اپ ریزٹر آن ٹوگل ہوجاتا ہے (اس پن پر ایک LOW اسے بند کر دیتا ہے)۔

ایک اور سوال جو آپ ہو سکتے ہیں وہ یہ ہے کہ پل اپ ریزٹر کیا ہے۔ میں نے پل اپ ریزسٹرس کے بارے میں ایک جامع پوسٹ کا احاطہ کیا ہے جو آپ ہیں اسے یہاں سیکھیں .

ٹھیک ہے ، آگے بڑھ رہے ہیں ، اب آئیے لوپ کوڈ کو دیکھیں۔

code: k_LEDPins is k_LEDPins[0]

جب آپ پش بٹن دبائیں تو ، وائرڈ پن زمین سے جڑ جاتا ہے ، جو ایک دیتا ہے کم اس پن تک اور جب تکلیف نہ ہونے والی حالت میں وہی پن رکتا ہے ہائی یا 20K اندرونی پل اپ مزاحم کے ذریعے + 5V۔

یہاں ہم چاہتے ہیں کہ جب ارڈوینو ایل ای ڈی کو روشن کرے جب پش بٹن دبائیں (LOW) ، لہذا ہم دباؤ کے بٹن سے LOW کے ہر جواب کے لئے آؤٹ پٹ کے لئے ہائیٹ لکھتے ہیں ، جبکہ دب جاتا ہے۔

3.1.2 دو بٹن اور ایک ایل ای ڈی

ٹھیک ہے ، آپ کو حیرت ہوسکتی ہے کہ مذکورہ بالا دکھایا گیا عمل ایک ارڈینو کے بغیر بھی ہوسکتا ہے۔ میں سمجھتا ہوں ، تاہم ، یہ سیکھنے کے لئے یہ ایک تیز رفتار پتھر ہے کہ کس طرح آرڈونو کے ساتھ پش بٹن کا استعمال کیا جاسکتا ہے۔

اس مقام تک ، ہم نے سوئچ آن (HIGH) یا سوئچ آف (LOW) ایل ای ڈی کے ل codes کوڈ لکھنے کا مطالعہ کیا ہے۔

اب ہم دیکھتے ہیں کہ یردوینو کے ذریعہ ایل ای ڈی کی چمک کو کیسے کنٹرول کیا جاسکتا ہے۔

یہ دو طریقوں کا استعمال کرتے ہوئے کیا جاسکتا ہے:

1. موجودہ کی مقدار کو ایل ای ڈی تک محدود کرکے
2. کا استعمال کرتے ہوئے پی ڈبلیو ایم یا پلس کی چوڑائی میں ترمیم ، جس میں ایل ای ڈی کو سپلائی کچھ مطلوبہ شرح پر بہت تیزی سے / بند کی جاتی ہے ، ایک اوسط روشنی پیدا کرتی ہے جس کی شدت پی ڈبلیو ایم پر منحصر ہوگی۔

ارڈینو بورڈ میں پی ڈبلیو ایم کی مدد سے ایک ٹیلڈ (~) کے نشان والے پنوں پر دستیاب ہے ، جو پنس 3 ، 4،5،9،10 اور 11 ہیں۔ 500 ہ ہرٹز (ایک سیکنڈ میں 500 مرتبہ)۔ صارف 0 اور 255 کے درمیان کوئی قیمت مہیا کرنے کے قابل ہے ، جہاں 0 سے کوئی HIGH یا No + 5V کا حوالہ نہیں ملتا ہے ، اور 255 ہر وقت HIGH یا + 5V حاصل کرنے کے لئے ارڈینو کو بتاتا ہے۔ ان احکامات کو شروع کرنے کے ل you آپ کو مطلوبہ قیمت کے ساتھ اینالاگ رائٹ () تک رسائی حاصل کرنا ہوگی۔

آپ PWM کو x / 255 کا فرض کر سکتے ہیں جہاں x مطلوبہ قیمت ہے جسے آپ | _ _ + _ | کے ذریعے بھیجنا چاہتے ہیں۔

جیسا کہ اوپر دکھایا گیا ہے ، اردوینو اور دیگر پیرامیٹرز کو سیٹ اپ کریں۔

k_LEDPins[3]

آپ کو یہاں 3 لائنیں مل سکتی ہیں جن کی کچھ وضاحت کی ضرورت ہے۔

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

لائن: for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
} ایردوینو کے اندر ایک انوکھا فنکشن کی نمائش کرتا ہے جسے مجبوری () کہتے ہیں۔

اس اندرونی فنکشن میں درج ذیل کے موافق کوڈ ہے۔

INT رکاوٹ (INT قدر ، INT منٹ ، INT زیادہ سے زیادہ)
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

اس سے پہلے زیر بحث تمام کوڈز کے ساتھ باطل ، جس کا مطلب ہے کہ کسی بھی چیز کو واپس نہیں کرنا (باطل)۔ جبکہ مذکورہ کوڈ کے ساتھ ہی آغاز ہوتا ہے INT ، جو اس بات کی نشاندہی کرتا ہے کہ وہ عدد کو لوٹاتا ہے۔ ہم بعد کے حصوں میں اس کے بارے میں مزید گفتگو کریں گے ، اس وقت صرف یہ یاد رکھیں کہ ایک عدد میں کوئی جزوی حصہ نہیں ہوتا ہے۔

ٹھیک ہے ، تو اس کا مطلب ہے ، کوڈ: k_numLEDs - 1 | _ _ _ _ | تفویض کرتا ہے۔

اگلی لائن میں ملازمت | _ _ _ _ | مطلوبہ قدر کے ساتھ منتخب پن پر پی ڈبلیو ایم کو اپلائی کرنے کے لئے اردوینو کو حکم دیں۔

اگلی لائن 20 ملی سیکنڈ کی تاخیر پیدا کرتی ہے ، اس بات کو یقینی بنانا ہے کہ ہم کھا کھا 50 ہارڈز یا ایک سیکنڈ میں 50 بار سے زیادہ تیزی سے ایڈجسٹ نہیں کرتے ہیں۔ اس کی وجہ یہ ہے کہ انسان ایک ارڈینو سے کہیں زیادہ آہستہ ہوسکتا ہے۔ لہذا اگر تاخیر نہ کی گئی تو پروگرام ہمیں یہ محسوس کرسکتا ہے کہ پہلے بٹن کو دبانے سے ایل ای ڈی بند ہے اور دوسرا بٹن دبانے سے اسے آن کر دیا گیا ہے (تصدیق کرنے کے لئے خود سے کوشش کریں)۔

3.2 پوٹینومیٹر

آئیے آگے بڑھیں اور استعمال کرنے کا طریقہ سیکھیں ارڈینو کے ساتھ پوٹینومیٹر۔

پوٹینومیٹر یا برتن کس طرح کام کرتے ہیں یہ جاننے کے ل you ، آپ اسے پڑھ سکتے ہیں مضمون .

جیسا کہ اوپر دکھایا گیا ہے اپنے ارڈینو کے ساتھ دکھائے گئے پیرامیٹرز کو مربوط کریں۔

ایک برتن میں 3 ٹرمینلز ہوں گے۔ درمیانی ٹرماسل اردووینو میں 0 انالوگ IN کے ساتھ مربوط ہوگی۔ دیگر دو بیرونی ٹرمینلز + 5V اور 0V سپلائی ریلوں سے منسلک ہوسکتے ہیں۔

آئیے پروگرام کریں اور نتائج دیکھیں:

k_LEDPins[4]

آپ کو کچھ ایسی چیزیں ملیں گی جو پوری طرح سے نئی نظر آسکتی ہیں اور ہمارے پہلے والے کوڈ میں شامل نہیں ہیں۔

1. مستقل const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
} | A0 کے بطور تفویض کیا گیا ہے ، جس میں A مطابق پنوں میں سے کسی ایک کی وضاحت کرنے کا شارٹ کٹ ہے۔ تاہم ، A0 سے # 15 ، اور # 15 کو پن کرنے کے لئے A1 سے بھی مراد ہے ، اور یہ آپ کو تجربے کے لئے پنوں کے ختم ہونے کی صورت میں ڈیجیٹل ان پٹ / آؤٹ پٹ کے طور پر استعمال کرنے کی اجازت دیتے ہیں۔ لیکن یاد رکھنا کہ آپ ڈیجیٹل پنوں کو ینالاگ پنوں کے بطور استعمال نہیں کرسکتے ہیں۔
2. لائن: void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
} کے طور پر جانا جاتا Ardino میں ایک نیا اندر تقریب پیش کرتا ہے نقشہ (). یہ خصوصیت دی گئی حد سے دوسرے میں دوبارہ کیلیبریٹ ہوتی ہے ، جیسا کہ اس کو قرار دیا جاتا ہے نقشہ (قدر ، نیچے سے ، ہائی سے ، نیچے سے ، نیچے تک) جب سے void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
} | یہ اہم ہوسکتا ہے 0-1023 کی حدود میں ایک قیمت دیتا ہے ، لیکن ینالاگ رائٹ 0-255 سے کسی قدر کو قبول کرنے کے قابل ہے۔

آپ سوچ سکتے ہیں ، چونکہ تبدیل شدہ مزاحمت کے ذریعہ ایل ای ڈی کی چمک پر قابو پانا ممکن ہے ، لہذا محض ایک برتن اس مقصد کے لئے کافی ہوسکتا تھا ، کیوں کہ ارڈینو کا استعمال کیوں؟ ٹھیک ہے ، ایک بار پھر یہ صرف فاؤنڈیشن ہے ، یہ بتانے کے لئے کہ کس طرح ایک برڈو کو ایک ارڈینو کے ساتھ تشکیل دیا جاسکتا ہے۔

کوئی مسئلہ نہیں ، اب ہم ایسا کچھ کریں گے جو ایک ارڈینو کے بغیر نہیں کیا جاسکتا ہے۔

اس تجربے میں ہم دیکھیں گے کہ ٹمٹمانے والی رفتار یا ایل ای ڈی کی شرح کو کنٹرول کرنے کے لئے کس طرح برتن کی مختلف مزاحمت کا استعمال کیا جاسکتا ہے۔

پروگرام یہ ہے:

analogWrite()

3.2.3 تاخیر سے گریز ()

مذکورہ کوڈ اچھا نظر آتا ہے ، لیکن ایل ای ڈی برتن کی قیمت کی جانچ پڑتال کرنے سے قاصر ہے جب تک کہ یہ ہر ایک مکمل دور سے گزر نہ سکے۔ طویل تاخیر کے لئے یہ عمل لمبا ہوتا جاتا ہے ، صارف کو برتن کے ردعمل کو دیکھنے کے لئے انتظار کرنا پڑتا ہے جب وہ حرکت کرتا ہے۔ کچھ ذہین پروگرامنگ کے ذریعہ اس تاخیر سے بچا جاسکتا ہے ، تاکہ صارف کو کم سے کم تاخیر کے بغیر قیمت کی جانچ پڑتال کی جاسکے۔ کوڈ یہ ہے۔

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

تو مندرجہ بالا کوڈ میں وہ کیا مختلف ہے؟ یہ مندرجہ ذیل لائن ہے جس سے فرق پڑتا ہے۔

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

اس حصے تک ، ہم متغیر INT کے بارے میں بات چیت کر چکے ہیں۔ تاہم ، متعدد اور متعدد متغیرات ہوسکتی ہیں جن تک آپ رسائی حاصل کرسکتے ہیں۔ فہرست ذیل میں پڑھ سکتے ہیں:

فی الحال ، یہ جاننا ہی ضروری ہے کہ نسبتا large بڑی تعداد میں اسٹور کرنے کے لئے INT متغیر ، آپ یہ اصطلاح استعمال کرسکتے ہیں لمبا یا ایک لانگ انٹ

یہاں آپ کو ایک اور دلچسپ فنکشن ملاحظہ کیا جاسکتا ہے ملیس ()

اس سے ارڈینو نے شروع سے ہی اپنے کام کے دوران کام کیا ہے (یہ ہر 50 دن کے بعد 0 پر آجائے گا)۔ یہاں یہ ایک طویل عرصے سے لوٹتا ہے کیونکہ اگر وہ لوٹ گیا INT ، طویل مدت کے لئے گنتی ممکن نہیں ہوسکتی ہے۔ کیا آپ ٹھیک ٹھیک اس کا جواب دے سکتے ہیں؟ جواب 32.767 سیکنڈ ہے۔

لہذا تاخیر () کو استعمال کرنے کے بجائے ، ہم ملیس () کی جانچ پڑتال کرتے ہیں ، اور جیسے ہی خاص طور پر ملی سیکنڈ لیپس کی ایل ای ڈی کو تبدیل کرتے ہیں۔ نتیجہ یہ ہے کہ ہم اس کو آخری بار تبدیل کرتے وقت ذخیرہ کرتے ہیں آخری بار متغیر ، تاکہ جب بھی یہ چاہے ہمیں اسے دوبارہ چیک کرنے کی سہولت دے۔

3.3 آر جی بی ایل ای ڈی

اب تک ہم ایک ہی رنگ کے ایل ای ڈی کے ساتھ کھیل چکے ہیں۔ اگرچہ ایل ای ڈی کو کسی اور رنگ کے ساتھ تبدیل کرکے ایل ای ڈی رنگ تبدیل کیا جاسکتا ہے ، لیکن آر جی بی ایل ای ڈی کے استعمال کے بارے میں کیسے ہے ایل ای ڈی رنگ تبدیل کرنے کے لئے ایل ای ڈی کو تبدیل کرنے کے بغیر؟

ایک آرجیبی ایل ای ڈی بنیادی طور پر ایک یلئڈی ہے جس میں سرخ ، سبز اور نیلے رنگ کا ایل ای ڈی سرایت اور ایک ہی ایل ای ڈی میں ملا ہوا ہے۔ اس میں ایک مشترکہ سیسہ ہے جو گراؤنڈ یا 0V سپلائی ریل تک جاتا ہے جبکہ دیگر 3 لیڈز کو متنوع پی ڈبلیو ایم مثبت سگنل کے ساتھ کھلایا جاتا ہے جس کا مقصد نفاذ کے ل for ہوتا ہے رنگ اختلاط .

نیچے دیئے گئے مطابق آپ سیٹ اپ کو تار کرسکتے ہیں:

یہ تھوڑا سا پیچیدہ نظر آسکتا ہے ، لیکن دراصل یہ پی ڈبلیو ایم کا استعمال کرتے ہوئے ہمارے پہلے کے ایل ای ڈی کنٹرول ڈیزائن کی نقل ہے۔

ایک عملی پروگرام کوڈ یہ ہے:

ledBrightness = constrain(ledBrightness, 0, 255)

اس کوڈ کو اپ لوڈ کرنے کے بعد ، ذرا دیکھیں کہ برتن کی ایڈجسٹمنٹ آرجیبی پر دلچسپ روشنی کا اثر کیسے پیدا کرتی ہے ، یہ ایک حقیقی تفریح ​​ہوسکتی ہے۔

آپ کو معلوم ہوگا کہ جب سفید 3 کے بجائے تمام 3 برتنوں کو زیادہ سے زیادہ مقامات پر منتقل کیا جائے گا تو آپ سرخ رنگ کے نظر آئیں گے۔ اس کی وجہ یہ ہے کہ 3 رنگوں میں سرخ رنگ سب سے نمایاں ہے اور اس وجہ سے اس صورتحال میں غلبہ حاصل ہے۔ تاہم آپ فنکشن کے ساتھ تجربہ کرسکتے ہیں نقشہ () ، زیادہ سمجھدار توازن پیدا کرنے کے ل the ، اسے ایل ای ڈی کے سرخ حصے پر لانے سے پہلے۔

آرڈوینو کے ساتھ آڈیو

اس سیکشن میں ہم سیکھیں گے کہ اریڈوینو سیٹ اپ میں بنیادی آواز اور موسیقی کو کیسے شامل کیا جائے۔

ہم دیکھیں گے کہ کس طرح مطلوبہ تعدد کے ساتھ منسلک اسپیکر پر سگنل تبدیل کیا جائے۔

مزید واضح ہونے کے لئے ، ایک وسط A نوٹ آزمایا جائے گا ، جو ایک 440 ہرٹج فریکوئنسی نوٹ ہے۔

ایسا کرنے کے ل we ، ہم صرف ایک وسط ایک نوٹ بجائیں گے ، اور مربع لہر کے ساتھ سائن لہر سگنل کو بہتر بنائیں گے۔

نیز ہم فارمولے کا مقدمہ چلا کر لاؤڈ اسپیکر کے کتنے وقت رہ سکتے ہیں اس کا حساب کتاب کریں گے:

ٹائم ڈیلا = 1 سیکنڈ / 2 ایکس ٹون فریکوئینسی۔

ٹائم ڈیلا = 1 سیکنڈ / 2 ایکس 440

ٹائمڈیلا = 1136 مائیکرو سیکنڈ

4.1 آئیے آرڈینو بورڈ کو اپنائیں

4.2 ایک سادہ نوٹ شامل کرنا

ہم پہلے ہی تقریب کے بارے میں بات کر چکے ہیں تاخیر () جہاں یونٹ ملی سیکنڈ (سیکنڈ / 1000) میں ہے ، تاہم آپ کو ایک اور فنکشن مل جائے گا {
if(value > max){
value = max
}
if(value value = min
}
return value
} جہاں یونٹ مائیکرو سیکنڈ میں ہے ، (ملی سیکنڈ / 1000)

موجودہ سیٹ اپ کے لئے ہم اسپیکر کے ساتھ منسلک منتخب پن پر +5V آن / آف سوئچ کرنے کے لئے کوڈ پروگرام کرتے ہیں ، 440 دالیں فی سیکنڈ کی شرح سے۔

یاد ہے ، آخری گفتگو میں ہم نے مطلوبہ آڈیو نوٹ کے لئے 1136 مائکرو سیکنڈ کی قیمت کا تعین کیا۔

تو اس کے لئے یہ پروگرام ہے ، جس سے آپ اسپیکر کے ساتھ جڑے ہوئے ارڈینو کو پروگرام کرتے ہی 440 ہرٹز کا آڈیو نوٹ سن سکیں گے۔

ledBrightness = constrain(ledBrightness, 0, 255)

مذکورہ درخواست سے آڈیو نوٹ بنانا ممکن ہے ، جس کا مطلب یہ بھی ہے کہ ہم اپنی پسند کے مطابق میوزک بنا سکتے ہیں۔

اس ضابطے سے ہم سمجھتے ہیں کہ آرڈینو میں متعدد مربوط افعال شامل ہیں جو موسیقی کی تخلیق میں اضافی طور پر معاون ہیں۔

پہلا ہے سر () جو 2 عناصر کے ساتھ تیسرے اختیاری عنصر کے ساتھ کام کرتا ہے ، جس کو نامزد کیا گیا ہے سر (پن ، تعدد ، مدت)۔ یا سر (پن ، تعدد)

دونوں کو آپ کے مقرر کردہ وقت کی مدت سے متعلق عملدرآمد کے لئے نامزد کیا گیا ہے۔

وقت کی عدم موجودگی میں ، کال آنے تک میوزک چلتا رہے گا سر () دوبارہ پھانسی دی جاتی ہے ، یا جب تک آپ پھانسی نہیں دیتے ہیں ایک نہیں ().

اگر آپ میوزک بجانا واحد بنیادی چیز جس پر عمل درآمد کر رہے ہو تو اس میں تاخیر کا استعمال کرتے ہوئے اسے کرنے کی ضرورت ہوگی۔

وقت کی مدت اہم ثابت ہوسکتی ہے کیونکہ اس میں میوزک چلنے کے لئے وقت فراہم کرنے کی اجازت ملتی ہے ، لہذا آپ دوسری چیزوں کو آزادانہ طور پر کرسکتے ہیں۔ جیسے ہی مدت ختم ہوجاتی ہے ، میوزک رک جاتا ہے۔

اگلی تقریب ایک نہیں () ایک ہی پیرامیٹر کو سنبھالتا ہے اور منتخب کردہ سر کو ایک مخصوص تفویض کردہ پن پر روکتا ہے۔

ایک عجیب انتباہ: کبھی بھی جب سر () فنکشن لاگو کیا گیا ہے ، PWM فنکشن 3 اور 11 پر کام کرنا بند کردے گی۔

لہذا جب بھی پروگرام میں اسپیکر کا منسلک استعمال ہوتا ہے تو ، اس بات کو یقینی بنائیں کہ مقررین کے لئے مذکور پن کا استعمال نہ کریں ، اس کے بجائے اسپیکر کے لف دستاویز کے لئے کچھ اور پنوں کی کوشش کریں۔

ٹھیک ہے لہذا یہاں اسپیکر پر میوزک لاگو کرنے کا پروگرام ہے ، حالانکہ یہ اصل موسیقی نہیں بلکہ بیس اسکیل سی نوٹ ہے۔

ledBrightness to be within the range of 0 and 255

مذکورہ کوڈ میں آپ نے کچھ نیا محسوس کیا ہوگا اور وہ ہے # تعریف .

یہ اصطلاح کمپیوٹر کے لئے سرچ اینڈ ریپلیس کمانڈ کی طرح کام کرتی ہے جبکہ مرتب کیا جارہا ہے۔

جب بھی کسی جگہ سے پہلے اسے پہلی چیز مل جاتی ہے تو ، اسے اس کی جگہ لائن کے بقیہ حصے (جسے میکرو کہا جاتا ہے) سے بدل دیتا ہے۔

لہذا اس مثال کے اندر جب کمپیوٹر دیکھتا ہے نوٹ یہ جلد 330 مقدار کے ساتھ اس کی جگہ لے لیتا ہے۔

مزید نوٹ اور تخصیص کے ل you آپ اپنی USB اسٹک میں موجود فائل کا حوالہ دے سکتے ہیں پچیں ، جہاں زیادہ تر تعدد آپ کی ترجیح کے ل found پایا جاسکتا ہے۔

4.4 افعال کے ساتھ موسیقی

مذکورہ کوڈ اچھا لگتا ہے ، لیکن لگتا ہے کہ اس میں بہت ساری تکراریں ہیں ، ان تکرار کو مختصر کرنے کے لئے کوئی طریقہ موجود ہونا چاہئے ، ٹھیک ہے؟

اب تک ہم نے ارڈینو کے ساتھ شامل دو ضروری کاموں کے ساتھ کام کیا ہے۔ اب یہ وقت ہوسکتا ہے کہ ہم نے اپنے افعال تخلیق کیے۔

ہر فعل کی ابتدا لازمی طور پر متغیر کی قسم سے ہونی چاہئے۔ مثال کے طور پر تقریب باطل اس قسم سے مراد ہے جو کچھ نام نہیں لاتا ہے اس لئے نام باطل ہے۔ نوٹ ، ہم پہلے ہی اپنے سابقہ ​​حصوں میں متغیر کی فہرست پر تبادلہ خیال کر چکے ہیں ، آپ ان کو حوالہ دینا چاہتے ہو۔

اس کے نتیجے میں ، خاص فعل کے نام کو کھلی قوسین مل جاتا ہے '(' اس کے بعد کوما سے الگ پیرامیٹرز کی ایک فہرست۔

پیرامیٹر میں سے ہر ایک اپنی قسم کے نام کے ساتھ ، اور آخر میں قریب سے حاصل کرتا ہے ')' قوسین

یہ پیرامیٹرز متغیر کی شکل میں تقریب کے اندر لاگو ہوسکتے ہیں۔

آئیے ذیل میں ایک مثال دیکھیں جہاں ہم ایک فنکشن تیار کرتے ہیں جس کو کہتے ہیں ہمارا ٹون () ضم کرنے کے لئے ڈیزائن کیا سر () کے ساتھ تاخیر () لائنیں ، اس انداز میں کہ جب تک نوٹ ٹون بجانا ختم نہیں کرتا فنکشن واپس آنا بند ہوجاتا ہے۔

ہم ان افعال کو اپنے پچھلے کوڈ میں نافذ کرتے ہیں ، اور نیچے پروگرام حاصل کرتے ہیں ، آخری سطریں دیکھیں:

analogWrite

پروگرام کو سمجھنے میں آسانی پیدا کرنے کے لئے افعال انتہائی آسان ہوسکتے ہیں۔

مندرجہ ذیل ایک مثال ہے جہاں ہم دو سروں کا استعمال کرتے ہوئے لہجے کے انتخاب کی وضاحت کرنے کے اہل ہیں جو ہم کھیلنا چاہتے ہیں۔ نوٹ برقرار رکھنے کے لئے ایک صف ، دوسری دھڑکن برقرار رکھنے کے لئے۔

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

آپ پہلی بار لائن کا تعارف واضح طور پر دیکھ سکتے ہیں # شامل کریں بیان اس بیان کا کام اقتباسات کے بیچ پوری فائل کو منتخب کرنا اور اس کی پوزیشن میں رکھنا ہے # شامل کریں بیان معیاری قوانین کے مطابق پروگرام کے آغاز میں یہ سختی سے رکھے جاتے ہیں۔

باب 5

درجہ حرارت کی پیمائش

صرف یاد کرنے کے لئے ، مکمل طور پر بڑے پروگرام لکھنے کے بجائے یاد رکھنا ، ہمیشہ کوڈ کے چھوٹے حصوں کو لکھنا اور ان کا تجزیہ کرنا عقلمند ہے ، جو غلطیوں کو جلدی سے پتہ لگانے میں مدد دیتا ہے۔

5.1 سیریل مانیٹر

ابھی تک ، جن کوڈوں کے بارے میں ہم نے تبادلہ خیال کیا ہے وہ فوری خرابیوں کا سراغ لگانے کے قابل بنانا اتنا آسان نہیں ہوتا ہے۔ یہاں ہم نگرانی اور ممکنہ مسئلے کے حل کے ل things چیزوں کو آسان بنانے کی کوشش کریں گے۔

اردوینو کی ایک خصوصیت ہے جو اسے کمپیوٹر کے ساتھ 'ٹاک بیک' کرنے کے قابل بناتی ہے۔ آپ نے دیکھا ہے کہ پن0 اور پن 1 کو ایک دوسرے کے ساتھ RX ایک TX کے بطور نشان زد کیا گیا ہے۔ ان پنوں کو اصل میں اردوینو کے اندر ایک الگ آئی سی کے ذریعہ ٹریک کیا جاتا ہے جو پی سی پر پلگ ہونے کے دوران انہیں USB کیبل میں پڑھنے کے لئے اپ گریڈ کرتا ہے۔

مندرجہ ذیل حصے میں ایک مکمل پروگرام دکھایا گیا ہے ، براہ کرم اس کے باوجود ، ہم اس کے بعد کوڈ میں نئی ​​اندراجات کے بارے میں سیکھیں گے۔ یہ کوڈ سیکشن 2.2 کے اظہار کے برابر ہے ، سوائے اس حقیقت کے کہ اس میں کچھ اضافی اعداد و شمار شامل ہیں جو ہمیں اس کی شناخت کرنے کی اجازت دیتے ہیں جس کے لئے کوڈ کیا گیا ہے۔

kPinPot

آپ یہاں دو نئی چیزوں کی شناخت کرسکتے ہیں ، اس میں ایک نئی لائن سیٹ اپ () تقریب

ledBrightness = map(sensorValue, 0, 1023, 0, 255)

یہ لائن آسانی سے استعمال کرنے کی ضرورت کا اظہار کرتی ہے سیریل 1 اس کو نافذ کرنے کے لئے کوڈ (یہاں سیریل سے مراد ہے بٹس یکے بعد دیگرے بھیجا ، اور باؤڈ کا مطلب ہے اس شرح سے جس کو بھیجا جاتا ہے)۔ یہ معقول قیمت اور سیریل مانیٹر کے اندر ایک (جو ہم اسے بعد میں سیکھیں گے) برابر ہونا چاہئے ، ورنہ سیریل مانیٹر میں موجود ڈیٹا کوڑے دان دکھائے گا۔ 9600 معیاری ہونے کے ناطے استعمال کرنا زیادہ آسان ہوجاتا ہے۔

دوسری نئی انٹری مندرجہ ذیل ہیں

analogueRead

یہاں دوسری لائن سے پتہ چلتا ہے کہ سیریل پورٹ سے بعد میں آنے والی چیز اگلی لائن پر شروع ہوگی۔ اس طرح دوسری لائن مٹھی کی لکیر سے مختلف ہے۔

ایک اور چیز جو آپ دیکھ سکتے ہیں وہ حوالہ (') ہیں۔ یہ ایک تار کے طور پر جانا جاتا ہے ، جو یہاں صرف مستحکم کی طرح استعمال ہوگا ، کیوں کہ اس موضوع پر مزید گفتگو زیادہ وسیع اور وسعت سے باہر ہوسکتی ہے۔

ٹھیک ہے ، اب ہم مندرجہ بالا کوڈ کو ارڈینو میں اپ لوڈ کرسکتے ہیں اور دیکھتے ہیں کہ کیا ہوتا ہے۔

کیا ، افوہ لگتا ہے ایسا کچھ نہیں ہوا ہے ، ارڈینو پن # 13 ایل ای ڈی پلک جھپک کر رک گیا ، جبکہ ٹی ایکس ایل ای ڈی پلک جھپکتے ہی رہا۔

ٹھیک ہے ، اس لئے کہ سیریل مانیٹر ونڈو ابھی طے نہیں ہے۔

جیسا کہ اوپر دکھایا گیا ہے آپ کو اپنے IDE میں سیریل مانیٹر باکس پر کلک کرنے کی ضرورت ہے۔ نیچے دائیں طرف واقع باؤڈ کی جانچ پڑتال کرنا نہ بھولیں ، بطور ڈیفالٹ یہ 9600 ہونا چاہئے ، اور کوڈ سے مماثل ہوں گے۔ اگر یہ یقینی نہیں ہے کہ 9600 منتخب کریں۔

مندرجہ ذیل ویڈیو کلپ میں بتایا گیا ہے کہ یہ کیسے ہوتا ہے۔

اب آئیے ہم آگے بڑھیں اور سیکھیں کہ مذکورہ بالا سیریل مانیٹر کی خصوصیت اس پر کارروائی کرنے میں کس طرح مدد کر سکتی ہے اردوینو کا استعمال کرتے ہوئے درجہ حرارت کی پیمائش

ہم درجہ حرارت سینسر کے طور پر ، IC TMP36 استعمال کریں گے ، جس کی حد درجہ حرارت 40 سے 150 ڈگری سینٹی گریڈ تک ہے۔

سیٹ اپ نیچے دیکھا جاسکتا ہے:

درج ذیل کوڈ TMP36 سینسر سے آؤٹ پٹ کو پڑھ کر اور ID کے سیریل مانیٹر پر بھیج کر درجہ حرارت کی پیمائش کا آغاز کرے گا۔

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

آئیے اوپر سے کوڈ کو سمجھیں۔

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

یہاں آپ دیکھ سکتے ہیں کہ ہم نے متغیر کی قسم شامل کی ہے تیرنا

یہ واحد متغیر قسم ہے جس میں اعداد نمبر (اعشاریہ یا جزوی حصے کے بغیر) کے علاوہ ہر چیز کو اسٹور کرنے کی خصوصیات ہے۔

فلوٹ متغیر کی درستگی 6 سے 7 ہندسوں تک ہوسکتی ہے۔

ملحقہ کوڈ long lastTime = 0 ہمارا اپنا کام ہے جو ریاضی کے حساب سے TMP36 سینسر سے سینسڈ وولٹیج فرق کو ڈگری سیلسیس میں تبدیل کرتا ہے۔

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

کوڈز کے اگلے حصے میں ، جب سے اصطلاح | _ _ _ _ | ایک اعداد و شمار کو 1 سے 1023 کے درمیان لوٹانے کے لئے تفویض کیا گیا ہے ، ہمارے لئے یہ ممکن ہوجاتا ہے کہ ہمارے مطالعے کو 5 سے ضرب دے کر اور پھر اسے 1024 سے تقسیم کرکے سینسر سے وولٹیج کا اندازہ لگائیں۔

سینسر TMP36 0 ڈگری سینٹی گریڈ میں 0.5V پیدا کرنے کے لئے مخصوص ہے ، اور اس کے بعد ڈگری سیلسیس میں ہر ایک اضافے کے لئے 10mV پیدا کرتا ہے۔

یہاں قربت جو ہم حساب سے پیدا کرنے کے قابل ہیں:

آپ اپنا پہلا فنکشن سمجھا سکتے ہیں جو کچھ قدر واپس کرتا ہے (نوٹ کریں کہ اب تک باقی تمام افعال کسی بھی قیمت کو واپس نہیں کرپائے کیونکہ وہ اس نوعیت کے ہیں باطل ).

آپ سمجھ سکتے ہیں کہ کسی فنکشن سے قدر حاصل کرنے کے ل you ، آپ کو صرف شامل کرنے کی ضرورت ہے واپسی جس کے بعد مطلوبہ نمبر آپ واپس کرنا چاہتے ہیں۔

جب ہم کہتے ہیں واپسی اس کا مطلب یہ ہے کہ جب بھی اس کو فون کیا جاتا ہے تو اس کا کوئی جواب یا جواب واپس آتا ہے ، جسے متغیر پر لاگو کیا جاسکتا ہے۔

جب یہ سیریل مانیٹر کو بھیج دیا جاتا ہے ، تو پڑھنے کے ذریعے فارین ہائیٹ میں تبدیل ہوجاتا ہے کنورٹٹوف ()

delayMicroseconds()

یہ فنکشن سیلسیس حد کو چنتا ہے اور اسے فارن ہائیٹ میں تبدیل کرتا ہے۔

فارن ہائیٹ سیلسیس میں تبدیل کرنے کے ل we ہم فارمولا نافذ کرتے ہیں فارن ہائیٹ = 9 / 5 (سیلسیس) + 32۔

5.3 ایک ایل سی ڈی انٹرفیس کرنا

آئیے اس بات کا مطالعہ کرتے ہیں کہ انٹرفیس یا مربوط کرنے کا طریقہ ایل سی ڈی سکرین مطلوبہ آؤٹ پٹس کے لئے بصری ڈسپلے حاصل کرنے کے لئے اردوینو کے ساتھ۔

ہماری درخواست میں ہم ایک 84x48 گرافیکل LCD ، جس میں 84 پکسل یا ڈاٹ افقی طور پر ، اور 48 پکسلز عمودی ریزولوشن پر کام کرنے جارہے ہیں۔ چونکہ ایک سرشار کنٹرولر تمام LCDs کے لئے لازمی ہوجاتا ہے ، لہذا موجودہ ڈیوائس میں ایک بھی PCD8544 کنٹرولر کی شکل میں شامل ہوتا ہے۔

اس ٹیوٹوریل میں ہم مندرجہ بالا مخصوص LCD ماڈیول کو ارڈینو کے ساتھ مربوط کریں گے ، اور ڈسپلے پر متنی پیغامات تخلیق کرنے کے لئے کچھ معمولات کا اطلاق کریں گے۔

مندرجہ ذیل اعداد و شمار میں آپ ایل سی ڈی کے انٹرفیسنگ کے بارے میں تفصیلات کے ساتھ ساتھ ایک چھوٹی سی چیز بھی حاصل کرسکتے ہیں 3.3V وولٹیج ریگولیٹر . یہ ریگولیٹر ضروری ہے کیونکہ LCD کو 3.3V فراہمی کے ساتھ کام کرنے کے لئے مخصوص کیا گیا ہے۔

آپ LCD ماڈیول سے 8 پن آؤٹ بھی دیکھ سکتے ہیں ، پن آؤٹ کی وضاحتیں مندرجہ ذیل ٹیبل سے مطالعہ کی جاسکتی ہیں۔

اب ہم دیکھیں کہ ہم LCD اور متعلقہ پیرامیٹرز کو اپنے ارڈینو کے ساتھ کس طرح جوڑ سکتے ہیں۔ تفصیلات ذیل میں دکھائے گئے عکاسی میں تصور کی جاسکتی ہیں۔

5.4 ایل سی ڈی سے بات چیت کرنا

اگرچہ ارودوینو سے ایل سی ڈی کے ساتھ بات چیت کے لئے وسیع پیمانے پر کوڈ لکھنا ممکن ہے ، لیکن ہم لائبریریوں کا استعمال کرکے ایسا کرنے کا طریقہ سیکھیں گے۔

لائبریریوں میں کوڈوں کی ایک درجہ بندی شامل ہوتی ہے جس پر منتخب آردوینو پروگرام کے لئے جلدی سے درخواست دی جاسکتی ہے۔

اس سے صارف کوڈ کوٹنگ کے پیچیدہ کام میں جانے کے بغیر آسانی سے کسی فنکشن کو کال کرنے کا اہل بناتا ہے۔

5.4.1 لائبریری کیسے انسٹال کریں

اس کے ل you ، آپ کو اپنے کمپیوٹر میں ارڈینو آئ ڈی ای میں لائبریریوں کے نام سے ایک ڈائریکٹری بنانا ہوگی ، جیسا کہ وضاحت کی گئی ہے یہاں

5.4.2 LCD آپریشنز کو نافذ کرنا

ہمارے سابقہ ​​نقطہ نظر کی طرح ، ہم پہلے پورے کوڈ کو چیک کریں گے اور پھر انفرادی خطوط کی تفصیلات کو سمجھنے کی کوشش کریں گے۔

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

لائن میں کوڈ #define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
} شامل ہے

کوڈ # شامل کریں پی سی کو ہدایت کرتا ہے کہ پروگرام کو مرتب کرنے کے دوران مذکورہ فائل کو منتخب کریں اور # شامل عنصر کو فائل کے مشمولات سے تبدیل کریں۔

# عنصر عنصر زاویہ خط وحدان کا مالک ہوسکتا ہے جو لائبریری ڈائرکٹری میں تلاش کرنے کی نشاندہی کرتا ہے ، متبادل کے طور پر اس میں قیمت بھی مل سکتی ہے جس میں اشارہ ہوتا ہے کہ اسی ڈائرکٹری میں ہی پروگرام تلاش کیا گیا ہے۔

اس کے بعد والے کوڈ LCD پن آؤٹ کو ظاہر کرتے ہیں ، اور پھر ہم متغیر کی ایک نئی شکل لکھتے ہیں:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

یہاں ہم پی سی ڈی 8544 ٹائپ رکھنے والے نام ایل سی ڈی کے ساتھ ایک متغیر کا اظہار کر رہے ہیں اور پی سی کو آرڈوینو سے وابستہ اس کی پن آؤٹ کو ریگریٹ کرنے کی ہدایت کر رہے ہیں۔

اس عمل میں ہم یہ بتاتے ہوئے پی سی کے متغیر کی وضاحت کرتے ہیں کہ کیسے پن کلک ، ڈین ، ڈی سی ، اور ری سیٹ کو ارودوینو کے ساتھ انٹرفیس کیا جاتا ہے۔

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

لائن const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
} | LCD آپریشن شروع کرتا ہے۔ ایک بار اس پر عمل درآمد ہونے کے بعد ، اگلی لائن ڈسپلے کے اوپری بائیں جانب کرسر نافذ کرتی ہے۔ اور اگلی لائن میں پیغام 'ہیلو ، ورلڈ' پرنٹ کرنے کی کوشش کی گئی ہے۔

یہ اس تکنیک سے بالکل یکساں نظر آتا ہے جس میں ہم نے سیریل مانیٹر پر پیغامات بھیجے تھے۔ کوڈ کے استعمال سے صرف فرق Serial.begin(9600) اس کی بجائے سیریل.پراٹ کے۔

کوڈ کے اگلے بلاک کو دراصل بار بار کہا جاتا ہے۔

Serial.print('delayTime = ')
Serial.println(delayTime)

اس لائن کا استعمال | _ _ _ _ | ہم LCD ڈسپلے کے اوپر ، 1 قطار کے بہت بائیں طرف 0th کالم میں کرسر کو ٹھیک کرتے ہیں۔

اگلی لائن میں ایک شارٹ کٹ ملازم ہے: const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

اگر آپ کو یاد ہے تو ہم نے _ _ + _ | کے ساتھ کام کیا ہے ہمارے پہلے والے کوڈز میں ، ہم بھی کوڈ کے ذریعہ یہاں پر اطلاق کرسکتے ہیں:

float temperatureC = getTemperatureC()

تاہم اس حقیقت کی وجہ سے کہ یہاں سیکنڈ سیکنڈ میں کوئی وقفہ وقفہ نہیں ہے ، لہذا ہم اسے صرف بھیج کر پورا کرتے ہیں۔ _ + _ | getTemperatureC() پر براہ راست فنکشن کریں .

5.5 پوری چیز کا امتزاج کرنا

ٹھیک ہے ، اب LCD درجہ حرارت سرکٹ بنانے کے ل we ہم نے سبھی کوڈز کو اکٹھا کیا جو ہم نے اوپر سیکھے ہیں ، اور دیکھتے ہیں کہ یہ کیسا لگتا ہے:

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

مذکورہ پروگرام میں ہر چیز معیاری نظر آتی ہے ، سوائے اس فعل کے استعمال کے سیٹ کرسر () . اس کا استعمال ڈسپلے کے مرکز کے آس پاس جہاں تک ممکن ہو متن میں سیدھ میں لانا ہے۔

زبردست! اور مبارکباد ، آپ نے ابھی آرڈوینو استعمال کرتے ہوئے اپنے ہی چھوٹے LCD درجہ حرارت کے اشارے کا پروگرام بنایا ہے۔

عملی آرڈوینو ایپلی کیشنز

چونکہ ، اس مرحلے تک ہم نے پروگرامنگ کی مختلف تکنیکوں پر تفصیل سے احاطہ کیا ہے ، اب وقت آگیا ہے کہ ان کو کچھ مفید عملی نفاذ کے لئے استعمال کرکے ان کو استعمال کریں۔

ہم سینسرز سے آغاز کریں گے اور دیکھیں گے کہ کچھ نمونے کوڈز پر عمل درآمد کرکے سینسر آلات کو ارڈینو کے ساتھ کیسے استعمال کیا جاسکتا ہے۔

7.1 سینسر کا تعارف

اس ٹیوٹوریل میں ہم مختلف قسم کے سینسر کے بارے میں سیکھیں گے جو اردوینو کے ساتھ استعمال ہوسکتے ہیں۔ ان میں لائٹ سینسر ایل ڈی آر ، مقناطیسی ہال اثر سینسر ، ٹیلٹ سینسر ، کمپن سینسر ، پریشر سینسر وغیرہ جیسے آلات شامل ہوسکتے ہیں۔

ہم اس میں مداخلت کریں گے روشنی سینسر LDR ارڈینو کے ساتھ ، جیسا کہ میں نے مندرجہ ذیل خاکہ دکھایا ہے:

جیسا کہ ہم سب جانتے ہیں ، ایل ڈی آر روشنی پر منحصر مزاحم آلہ ہے جس کی مزاحمت اس کی سطح پر محیط واقعہ کی شدت پر منحصر ہے۔

روشنی کی شدت ایل ڈی آر کی مزاحمت پڑھنے کے متضاد متناسب ہے۔

یہاں ہم سیکھیں گے کہ کسی مفید ایپلی کیشن کو انجام دینے کے لrdu اس پراپرٹی کو اردوینو کے ساتھ کس طرح ضم کیا جاسکتا ہے۔

ذیل میں دیئے گئے پروگرام کے مطابق مکمل پروگرام کوڈ کو دیکھا جاسکتا ہے۔

analogIn()

کوڈ میں استعمال ہونے والے تمام پیرامیٹرز پر ہمارے کورس میں پہلے ہی بحث ہوچکی ہے جو ہم اب تک سیکھ چکے ہیں۔ آپ متعلقہ حصوں کا حوالہ دے کر لائنوں کو چیک کرسکتے ہیں۔

اقدار تصادفی طور پر منتخب کی گئیں ، آپ اپنی اپنی ترجیحات کے مطابق آسانی سے تبدیل ہوسکتے ہیں۔

جھکاؤ سینسر

ٹیلٹ سینسر ایک سادہ آلہ ہوتا ہے جس کا استعمال کسی بھی شے پر جہاں بھی ہوتا ہے وہاں جھکاؤ کی کارروائی کا پتہ لگانے کے لئے استعمال کیا جاسکتا ہے۔ بنیادی طور پر اس آلے کے اندر ایک دھاتی بال ہوتی ہے ، جو ان رابطوں کے ایک جوڑے پر ڈھیر لگانے پر لگی ہوتی ہے اور ان رابطوں کو لے جانے کا باعث ہوتی ہے۔ یہ رابطے جھکاؤ والے سوئچ کی برتری کی حیثیت سے ختم کیے جارہے ہیں ، ایک خارجی سرکٹ کے ساتھ ایک جھکاو عمل کی وجہ سے ترسیل کا پتہ لگانے اور مطلوبہ آؤٹ پٹ ایپلی کیشن کو چالو کرنے کے لئے استعمال کیا جاتا ہے۔

اب دیکھتے ہیں کہ کیسے جھکاؤ سینسر آلہ وائر کیا جا سکتا ہے۔ ذیل کی شبیہہ ہمیں مکمل ترتیب سے متعلق ایک نظریہ فراہم کرتی ہے۔

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

اس مثال میں ڈیفالٹ پن # 13 ایل ای ڈی جھکاؤ کے اشارے کے بطور استعمال ہوتا ہے۔

آپ یہاں پل اپ ریزسٹر کی شمولیت کو واضح طور پر دیکھ سکتے ہیں ، بالکل اسی طرح جو ہم نے سیکشن 3.1 میں کیا تھا۔ لہذا LOW کی اصطلاح اس بات کی نشاندہی کرتی ہے کہ جھکاو کا فعل متحرک نہیں ہے۔

7.4 ریڈ سوئچ ریلے (چھوٹے مقناطیس چالو ریلے)

اب آئیے دیکھیں کہ کس طرح ریلے سوئچ یا آرڈوینو کے ساتھ مقناطیسی فیلڈ سینسر لگائیں۔ ریڈ ریلے ایک قسم کا سوئچ ہوتا ہے جو مقناطیسی فیلڈ یا مقناطیس اس کے قریب لایا جاتا ہے تو چالو یا چلاتا ہے۔ بنیادی طور پر اس میں ایک چھوٹے شیشے کے دیوار کے اندر فرومیگنیٹک رابطوں کا ایک جوڑا ہوتا ہے جو مقناطیسی پل کی وجہ سے شامل ہوتا ہے یا رابطہ بناتا ہے جب بھی مقناطیسی اس کے قریب ہوتا ہے۔ جب ایسا ہوتا ہے تو رابطوں کے ٹرمینلز رابطوں کی بندش کی وجہ سے ترسیل کو ظاہر کرتے ہیں۔

یہاں بھی ہم جواب کی نشاندہی کرنے کے لئے پن # 13 ایل ای ڈی کا استعمال کرتے ہیں۔ اگر ہماری پہلے کی وضاحت کے مطابق ضرورت ہو تو آپ اس پن سے بیرونی ایل ای ڈی کو مربوط کرسکتے ہیں۔

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

کوڈ کی شرائط واقف اور خود وضاحتی ہونی چاہ.۔

7.5 کمپن سینسر پیزو ٹرانس ڈوسر کا استعمال کرتے ہوئے

اگلے نمونے کے پروگرام میں ہم دیکھیں گے کہ کیسے پیزو ٹرانسڈوسر ایردوینو کے ذریعہ ایل ای ڈی کو روشن کرنے کے لئے کمپن سینسر کے طور پر استعمال کیا جاسکتا ہے۔

ایک پیزو عنصر دراصل ایک ایسا آلہ ہوتا ہے جو کمپن یا دوپلی پیدا کرتا ہے جب اس کے ٹرمینلز میں تعدد کا اطلاق ہوتا ہے۔ تاہم اسی پیزو کو معکوس عمل میں استعمال کیا جاسکتا ہے بجلی کی دالیں پیدا کرنا اس کے جسم پر لگنے والے کمپن کے جواب میں۔ یہ کمپن دستک کی صورت میں ہوسکتی ہے یا پائزو کی سطح پر ٹکرا سکتی ہے۔

مندرجہ ذیل اعدادوشمار میں دیئے گئے ارڈینو اور ایک پیزو عنصر کو ترتیب دیں

#include

دہلیز 100 کو صرف اس بات کو یقینی بنانے کے لئے متعارف کرایا گیا ہے کہ آرڈینو صرف دستک کے ذریعے حقیقی کمپنوں کا جواب دیتا ہے ، اور نہ کہ چھوٹی کمپن جیسے تیز آوازوں ، یا سینگوں سے۔

A5 پن کا انتخاب لازمی نہیں ہے ، آپ اپنی ترجیح کے مطابق اور پروگرام کے کوڈ میں اس کو ملا کر کسی بھی ینالاگ ان پٹ کو منتخب کرسکتے ہیں۔

اردوینو کے ساتھ سروو موٹر کا استعمال کرنا

ایک سرو موٹر ایک قسم کی ڈی سی موٹر ہے جسے کسی خاص ایپلی کیشن کے مطالبہ کے مطابق عین مطابق زاویوں میں گھمایا جاسکتا ہے۔ موٹر پر متعلقہ آدانوں پر ایک محاسب کمانڈ کا اطلاق کرکے موٹر پر 180 ڈگری رینج کے اندر اندر ایک درست گردش یا رخ موڑنے والا زاویہ تیار کیا جاسکتا ہے۔

عام طور پر ایک सर्वो موٹر میں 3 تاروں یا آدان ہوتے ہیں۔ مثبت تاروں کا رنگ عام طور پر سرخ ہوتا ہے ، منفی یا زمینی تار کالی ہوتی ہے ، جسے کمانڈ تار یا سگنلنگ تار عام طور پر سفید یا پیلے رنگ کا ہوتا ہے۔

اردوینو سپورٹ لینگویج کے ذریعہ امدادی موٹر کنٹرول کی سہولت فراہم کرتی ہے جو کنٹرول موٹروں کے ل very بہت آسان اور مثالی بناتی ہے۔

مندرجہ ذیل مثال آردوینو کے ذریعہ امدادی موٹر کنٹرول کو نافذ کرنے کے لئے بنیادی سیٹ اپ پروگرام دکھائے گی۔

کوڈ ذیل میں دیا گیا ہے:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

ہم یہاں کچھ نئی اندراجات دیکھ سکتے ہیں۔ ایک جو سروو کے ساتھ منسلک تار کو بتاتا ہے کہ اسے کون سا پن تفویض کیا گیا ہے۔ دوسرا ایک کوڈ ہے جو سرو کو گردش کے زاویہ کا تعی forن کرنے کے لئے 0 اور 180 کے درمیان پن کو ایک قیمت مہیا کرتا ہے۔

نتیجہ اخذ کرنا

اردوینو مضمون غیر لitely حد تک طویل ہوسکتا ہے ، اور اس ل this اس مضمون کے دائرہ کار سے باہر ہے۔ تاہم ، میں امید کرتا ہوں کہ مندرجہ بالا ٹیوٹوریل نے آپ کو ارڈوینو کی بنیادی باتیں سیکھنے اور مختلف مثال کے کوڈ کے ذریعہ اہم پیرامیٹرز کو سمجھنے میں مدد فراہم کی ہوگی۔

امید ہے کہ جب بھی یہ دستیاب ہو وقتا فوقتا more مزید معلومات کی تازہ کاری کی جاسکے گی۔

اس دوران میں آپ اپنے پروگرامنگ کورس سے لطف اندوز ہوں ، آپ کو مبارک ہو Ardinoing !!