இந்த டுடோரியலில் எடுத்துக்காட்டு குறியீடுகள் மற்றும் மாதிரி நிரல்கள் மூலம் அடிப்படை Arduino நிரலாக்கத்தை எவ்வாறு செய்வது என்று கற்றுக்கொள்கிறோம். இந்த டுடோரியல் எளிதான, புரிந்துகொள்ளக்கூடிய மொழி மூலம் அடிப்படைகளை புரிந்து கொள்ள விரும்பும் அனைத்து புதியவர்களுக்கும் மிகவும் மதிப்புமிக்க பாடமாகும்.
அறிமுகம்
படி விக்கிபீடியா மைக்ரோகண்ட்ரோலர் என்பது ஒரு ஐசி சில்லுக்குள் கட்டப்பட்ட ஒரு மினி கணினிக்கு சமம், அதன் சொந்த மைய செயலி, நிரல்படுத்தக்கூடிய உள்ளீடுகள், நினைவகம் மற்றும் வெளியீட்டு சாதனங்கள் உள்ளன.
ஒரு மைக்ரோகண்ட்ரோலர் ஒரு பயனருக்கு மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் இது ஒரு உள்ளமைக்கப்பட்ட செயலி, நினைவகம் மற்றும் உள்ளீடு / வெளியீட்டு துறைமுகங்களை (GPIO அல்லது பொது நோக்கம் உள்ளீடு / வெளியீட்டு ஊசிகளாகவும் அழைக்கப்படுகிறது) வழங்குகிறது, அவை எந்தவொரு விரும்பிய விவரக்குறிப்புகளின்படி பயனரால் கட்டுப்படுத்தப்படலாம்.
இந்த டுடோரியலில், நிரல்களைக் கற்றுக்கொள்வதற்கும் சோதனை செய்வதற்கும் ஒரு ஆர்டுயினோ யூனோ போர்டுடன் இணைந்து செயல்படுவோம். வன்பொருள் சட்டசபை சோதனை மற்றும் ஒருங்கிணைப்பதற்கு நாங்கள் ஒரு பிரெட்போர்டைப் பயன்படுத்துவோம்.
இப்போது விரைவாக நகர்ந்து ஒரு ஆர்டுயினோ நிரலாக்கத்துடன் எவ்வாறு தொடங்குவது என்பதைக் கற்றுக்கொள்வோம்.
1.2 மென்பொருளை நிறுவுதல் (விண்டோஸ்)
இதற்காக உங்களுக்கு இணைய அணுகல் தேவைப்படும், இது உங்கள் கணினியில் நீங்கள் இருக்க வேண்டும். தயவுசெய்து பின்வரும் இணைப்பிற்குச் சென்று IDE மென்பொருளைப் பதிவிறக்கவும்:
நிர்வாகி அல்லாத நிறுவலுக்கான விண்டோஸ் ஜிப் கோப்பு
பதிவிறக்கிய பிறகு பதிவிறக்க கோப்புறையில் Arduino அமைவு ஐகானைக் காண்பீர்கள், இது இப்படி இருக்கும்:
இதைப் பெற்றவுடன், நீங்கள் அதை இருமுறை கிளிக் செய்து உங்கள் கணினியில் Arduino ஒருங்கிணைந்த மேம்பாட்டு சூழலை (IDE) நிறுவலாம். முழுமையான செயல்முறையை பின்வரும் வீடியோவில் காணலாம்:
https://youtu.be/x7AMn1paCeU1.4 எங்கள் முதல் சுற்றுடன் தொடங்குகிறது
உண்மையான நிரலாக்க நுட்பங்களை நாங்கள் கற்கத் தொடங்குவதற்கு முன், எந்தவொரு புதியவருக்கும் எல்.ஈ.டி போன்ற அடிப்படைக் கூறுகளைத் தொடங்குவது பயனுள்ளதாக இருக்கும், மேலும் அதை ஒரு ஆர்டுயினோவுடன் எவ்வாறு இணைப்பது என்பதைப் புரிந்து கொள்ளுங்கள்.
எல்.ஈ.டி என்பது ஒரு ஒளி உமிழும் டையோடு ஆகும், இது ஒரு துருவமுனைப்பைக் கொண்டுள்ளது மற்றும் சரியான விநியோக துருவங்களுடன் இணைக்கப்படாவிட்டால் அது ஒளிராது.
எல்.ஈ.டிகளுடனான மற்றொரு அம்சம் என்னவென்றால், இந்த சாதனங்கள் குறைந்த மின்னோட்டத்துடன் இயங்குகின்றன மற்றும் சரியான முறையில் கணக்கிடப்பட்ட மின்தடை அதன் ஊசிகளில் ஒன்றில் தொடரில் சேர்க்கப்படாவிட்டால் உடனடியாக சேதமடையக்கூடும்.
கட்டைவிரல் விதியாக, 330 ஓம் 1/4 வாட் வழங்கல் உள்ளீட்டின் ஒவ்வொரு 5 வி உயர்வுக்கும் தற்போதைய பாதுகாப்பான நிலைக்கு மட்டுப்படுத்த மிகவும் ஏற்றது. எனவே 5V க்கு இது 330 ஓம்களாக இருக்கலாம், 10 வி க்கு 680 ஓம்களாக இருக்கலாம்.
சட்டசபைக்கு பிரெட்போர்டைப் பயன்படுத்துதல்
A ஐ எவ்வாறு பயன்படுத்துவது என்பது உங்களுக்குத் தெரியும் என்பதை உறுதிப்படுத்தவும் பிரட்போர்டு இந்த அத்தியாயத்தில் விளக்கப்பட்ட டுடோரியலை முயற்சிப்பதற்கு முன்பு, இங்குள்ள அனைத்து சோதனைகளுக்கும் நாங்கள் ஒரு பிரெட் போர்டைப் பயன்படுத்துவோம்.
அடிப்படை எல்இடி இணைப்பு அமைப்பை கீழே காணலாம்:
மேலே 3 அடிப்படை கூறுகளை நீங்கள் காணலாம்:
- ஒரு 5 மிமீ, 20 எம்ஏ எல்இடி
- ஒரு 330 ஓம் 1/4 வாட் மின்தடை
- ஒரு Arduino Board
வரைபடத்தின்படி கணினியை வரிசைப்படுத்துங்கள்.
அடுத்து, கணினி யூ.எஸ்.பி முதல் அர்டுயினோ வரை 5 வி செருகவும். நீங்கள் இதைச் செய்தவுடன் எல்.ஈ.டி விளக்குகள் ஏற்றப்படுவதைக் காண்பீர்கள்.
அது மிகவும் அடிப்படை என்று எனக்குத் தெரியும், ஆனால் புதிதாகத் தொடங்குவது எப்போதும் நல்லது. மீதமுள்ள உறுதி விஷயங்கள் நாம் முன்னேறும்போது மேலும் மேலும் சுவாரஸ்யமடையத் தொடங்கும்.
1.5 அர்டுயினோவுடன் எல்.ஈ.டி.
ஒரு ஆர்டுயினோ நிரலுடன் எல்.ஈ.டியை எவ்வாறு கட்டுப்படுத்துவது என்பதை இப்போது கற்றுக்கொள்வோம்.
ஒரு நிரலை எழுத ஒவ்வொரு நிரலிலும் குறைந்தது 2 செயல்பாடுகளை கொண்டிருக்க வேண்டும்.
ஒரு செயல்பாடு ஒரு நிரலாக்க அறிக்கைகளின் வரிசையாக புரிந்து கொள்ளப்படலாம், அவை ஒரு பெயருடன் ஒதுக்கப்படலாம், கீழே கொடுக்கப்பட்டுள்ளபடி:
- அமைப்பு () இது நிரலின் தொடக்கத்தில் அழைக்கப்படுகிறது அல்லது செயல்படுத்தப்படுகிறது.
- லூப் () இது Arduino இன் முழு செயல்பாட்டுக் காலத்திலும் மீண்டும் மீண்டும் அழைக்கப்படுகிறது அல்லது செயல்படுத்தப்படுகிறது.
ஆகையால், இது நடைமுறைச் செயல்பாட்டைக் கொண்டிருக்கவில்லை என்றாலும், தொழில்நுட்ப ரீதியாக ஒரு குறுகிய முறையான Arduino நிரலை இவ்வாறு எழுதலாம்:
எளிய திட்டம்
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 என்ற சொல்லுக்கு Arduino இன் சம்பந்தப்பட்ட முள் மீது + 5V பெறுவது என்று பொருள். LOW என்ற முழுமையான சொல் நியமிக்கப்பட்ட முள் மீது பூஜ்ஜியம் அல்லது 0 வி என்பதைக் குறிக்கிறது.
அடுத்து, நாங்கள் delay() மில்லி விநாடிகள் (ஒரு வினாடிக்கு 1/1000 வது) மூலம் தாமதத்தை உருவாக்குவதே இதன் செயல்பாடு. எண்ணிக்கை 500 உள்ளிடப்பட்டதால், செயல்படுத்தப்பட்ட தாமதம் 1/2 விநாடிக்கு இருக்கும்.
இந்த 1/2 வினாடி முடிந்தவுடன், அடுத்த வரி செயல்படுத்தப்படுகிறது, இது எல்.ஈ.டி ஐ அதே முள் மீது குறைந்த காலத்துடன் இயக்குகிறது.
எல்.ஈ.டி 1/2 விநாடிகள் முடக்கத்தில் இருக்க அனுமதிக்க, அடுத்தடுத்த வரி மீண்டும் 1/2 வினாடி தாமதத்தை உருவாக்குகிறது.
குறியீட்டின் வரிகளை செயல்படுத்துவதன் மூலம் இந்த செயல்முறை எண்ணற்ற அளவில் தொடர்கிறது, அர்டுயினோ இயங்கும் வரை.
அடுத்த நிலைக்குச் செல்வதற்கு முன், மேலே உள்ள குறியீட்டை நிரல் செய்து, எல்.ஈ.டி ஆன் / ஆஃப் வரிசையை சரியாக செயல்படுத்த முடியுமா இல்லையா என்பதை சரிபார்க்க பரிந்துரைக்கிறேன்.
Arduino இல் இயல்புநிலை எல்இடி பின் # 13 உடன் இணைக்கப்பட்டுள்ளதால், அது உடனடியாக மேலே உள்ள நிரலுக்கு பதிலளித்து ஒளிர ஆரம்பிக்க வேண்டும். இருப்பினும், உங்கள் வெளிப்புற எல்.ஈ.டி ஒளிரவில்லை என நீங்கள் கண்டால், உங்கள் எல்.ஈ.டி உடன் இணைப்பு தவறு இருக்கக்கூடும், உங்கள் எல்.ஈ.டி யின் துருவமுனைப்பை மாற்றியமைக்க முயற்சி செய்யலாம், மேலும் அது ஒளிரும்.
'500' உருவத்தை வேறு மதிப்புக்கு மாற்றுவதன் மூலம் நீங்கள் தாமத நேரத்துடன் விளையாடலாம் மற்றும் கட்டளைகளுக்கு எல்.ஈ.டி 'கேட்பதை' கண்டுபிடித்து குறிப்பிட்ட தாமத மதிப்புகளின் படி அதை ஒளிரச் செய்யலாம்.
உங்கள் தாமத நேர மாற்றத்தைப் பொருட்படுத்தாமல், நிலையான 1 வினாடி வீதத்துடன் எல்.ஈ.டி ஒளிராமல் இருப்பதை நீங்கள் கண்டால், சில தவறு காரணமாக குறியீடு செயல்படவில்லை என்பதைக் குறிக்கலாம். ஏனெனில் முன்னிருப்பாக Arduino 1 வினாடி ஒளிரும் வீதத்துடன் திட்டமிடப்படும். எனவே இந்த விகிதம் உங்கள் குறியீட்டின் சரியான செயல்பாட்டை உறுதிப்படுத்த மாறுபடும்.
1.7 கருத்துரைகள்
நாம் மேலே புரிந்துகொண்ட குறியீடுகளின் கோடுகள் குறிப்பாக கணினி மென்பொருளுக்காக எழுதப்பட்டவை.
இருப்பினும், பயனர் வரிகளின் பொருளைக் குறிப்பிடுவதையும் அவற்றைப் புரிந்துகொள்வதையும் உறுதி செய்வதற்காக, குறியீடுகளின் விரும்பிய வரிகளுக்கு அருகில் விளக்கத்தை எழுதுவது பெரும்பாலும் பயனுள்ளதாகவும் விவேகமாகவும் இருக்கலாம்.
இவை அழைக்கப்படுகின்றன கருத்துகள் அவை மனித அல்லது பயனர் குறிப்புக்காக மட்டுமே எழுதப்பட்டவை, மேலும் கணினிகள் அதைப் பாதுகாப்பாக புறக்கணிக்க உதவும் வகையில் குறியிடப்படுகின்றன.
இந்த கருத்துகளின் மொழி ஓரிரு வடிவங்களுடன் எழுதப்பட்டுள்ளது:
- கருத்தின் தொகுதி பாணி, இதில் கருத்து விளக்கம் தொடக்க சின்னம் / * இன் கீழ் இணைக்கப்பட்டுள்ளது மற்றும் முடிவுக்கு வரும் சின்னம் * /
- இது ஒரு வரியில் கட்டுப்படுத்த வேண்டியதில்லை, மாறாக பின்வரும் எடுத்துக்காட்டில் காட்டப்பட்டுள்ளபடி, கருத்தின் நீளம் அல்லது விளக்கத்தைப் பொறுத்து அடுத்தடுத்த வரிகளுக்கு நீட்டிக்க முடியும்:
/ * இது ஒரு கருத்து * /
/ * அப்படியே இது * /
/ * மற்றும்
* இது
* என
* நன்றாக * /
கருத்துக்கு விரைவான ஒற்றை வரி விளக்கத்தை எழுதுவதற்கு, தொடக்கத்தில் இரண்டு ஸ்லாஷ் // சின்னம் போதுமானதாகிறது. இந்த வரிக்கு உண்மையான குறியீட்டுடன் எந்த தொடர்பும் இல்லை, இது புறக்கணிக்கப்பட வேண்டும் என்று இது கணினியிடம் கூறுகிறது. உதாரணத்திற்கு:
// இது கணினிகள் புறக்கணிக்கும் ஒரு கருத்து.
குறிப்புக்கு இங்கே ஒரு எடுத்துக்காட்டு:
/*
* 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 சரிசெய்தல்
தொகுக்கும்போது உங்கள் நிரல் ஒரு 'பிழை' அல்லது வேறு ஏதேனும் சிக்கலைக் காண்பித்தால், உங்கள் குறியீட்டை மறுபரிசீலனை செய்ய பின்வரும் உதவிக்குறிப்புகள் உங்களுக்கு உதவும்.
- உங்கள் நிரல் மொழி வழக்கு உணர்திறன் கொண்டதாக இருக்கும். உதாரணமாக வெளிப்பாடு myVar என எழுத முடியாது மைவார்.
- உங்கள் விசைப்பலகை தட்டச்சு மூலம் செயல்படுத்தப்படக்கூடிய அனைத்து வகையான வெள்ளை இடங்களும் இறுதியில் ஒற்றை இடமாக வழங்கப்படுகின்றன, மேலும் இது உங்களால் மட்டுமே தெரியும் அல்லது புரிந்து கொள்ளப்படுகிறது, கணினி இதை கணக்கில் எடுத்துக்கொள்ளாது. எளிமையாகச் சொல்வதானால், எந்தவொரு இலவச இடங்களும் குறியீடு முடிவுகளில் எந்த விளைவையும் ஏற்படுத்தாது.
- குறியீட்டின் ஒவ்வொரு தொகுதியும் இடது மற்றும் வலது சுருள் அடைப்புக்குறிகளுடன் இணைக்கப்பட வேண்டும், '{' மற்றும் '}'
- எண் இலக்கங்களை காற்புள்ளிகளுடன் பிரிக்கக்கூடாது. உதாரணமாக, 1000 ஐ 1,000 என எழுதக்கூடாது.
- சுருள் அடைப்புக்குறிக்கு இடையில் இணைக்கப்பட்டுள்ள ஒவ்வொரு குறியீடு வரியும் அரைக்காற்புள்ளியுடன் முடிக்கப்பட வேண்டும்
அர்டுயினோவுடன் சுவாரஸ்யமான எல்.ஈ.டி ஒளி வரிசையை உருவாக்குதல்
எங்கள் முந்தைய அத்தியாயத்தில் ஒரு நிலையான தாமத விகிதத்துடன் தொடர்ந்து எல்.ஈ.டி ஆன் / ஆஃப் செய்வது எப்படி என்பதைக் கற்றுக்கொண்டோம்.
நிரல் குறியீட்டை மேம்படுத்துவதன் மூலம் ஒரே எல்.ஈ.யில் வெவ்வேறு தாமத வடிவங்களை எவ்வாறு செயல்படுத்தலாம் என்பதை இப்போது அறிந்து கொள்வோம்.
நாங்கள் வெளிப்புற எல்.ஈ.டியைப் பயன்படுத்த மாட்டோம், மாறாக முள் # 13 இல் அர்டுயினோ போர்டில் கட்டப்பட்ட இயல்புநிலை எல்.ஈ.டி. யூ.எஸ்.பி இணைப்பிற்குப் பின்னால் இந்த சிறிய எஸ்.எம்.டி எல்.ஈ.டி.
2.2 IF அறிக்கைகளைப் புரிந்துகொள்வது
இந்த பிரிவில், கட்டுப்பாட்டு கட்டமைப்புகள் தனிப்பட்ட குறியீடுகளை எவ்வாறு இயக்க உதவுகின்றன என்பதைக் கற்றுக்கொள்வோம், மேலும் சில சமயங்களில் தேவைக்கேற்ப மீண்டும் மீண்டும் கூட.
அறிக்கை என்றால் 1 வது கட்டுப்பாட்டு கட்டமைப்பாக மாறுகிறது. இது எவ்வாறு பயன்படுத்தப்படுகிறது என்பதை பின்வரும் செயல்படுத்தல் காட்டுகிறது:
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)
}
மேலே உள்ள குறியீட்டை படி வாரியாக புரிந்துகொள்ள முயற்சிப்போம், மேலும் இது போன்ற பிற மரணதண்டனைகளுக்கு இது எவ்வாறு பயன்படும் என்பதை அறியலாம்.
1 மற்றும் 7 வது வரிக்கு இடையிலான குறியீடுகள் எங்கள் ஆரம்ப நிரலுடன் ஒத்தவை.
முதல் மாற்றம் உண்மையில் 8 வது வரியில் நடக்கிறது.
int delayTime = 1000
இது 1 வது வரியில் உள்ள குறியீட்டைப் போலவே இருப்பதைக் காணலாம், இது காலத்தைக் காணவில்லை என்ற உண்மையைத் தவிர const.
இது வெறுமனே காரணம், இந்த குறியீடு நிலையானது அல்ல. அதற்கு பதிலாக இது ஒரு என வரையறுக்கப்படுகிறது மாறி , இது நிரலாக்கத்தின் போது மாறி மதிப்பின் சொத்துக்களைக் கொண்டுள்ளது.
மேலே உள்ள எடுத்துக்காட்டில், இந்த மாறி 1000 மதிப்பைக் கொண்டிருப்பதைக் காணலாம். நினைவில் கொள்ளுங்கள், சுருள் அடைப்புக்குறிக்குள் இணைக்கப்பட்டுள்ள இத்தகைய மாறிகள் கண்டிப்பாக ஜோடி சுருள் அடைப்புக்குறிக்குள் மட்டுமே எழுதப்பட வேண்டும், மேலும் அவை 'உள்ளூர்' மாறிகள் என குறிப்பிடப்படுகின்றன.
மாற்றாக, சுருள் அடைப்புக்குறிக்கு வெளியே இருக்க வேண்டிய மாறிகள், இப்போது நாம் விவாதித்து வருவதைப் போல 'உலகளாவிய' என அங்கீகரிக்கப்படுகின்றன, மேலும் அவை நிரல் குறியீட்டில் எங்கும் செயல்படுத்தப்படலாம்.
முன்னோக்கி நகரும்போது, வரி 9 மற்றும் 11 க்கு இடையிலான குறியீடுகளும் முதல் நிரலுக்கு ஒத்திருப்பதை நீங்கள் காணலாம், ஆயினும் விஷயங்கள் 11 வது வரியின் பின்னர் சுவாரஸ்யமடையத் தொடங்குகின்றன. எப்படி என்று பார்ப்போம்!
delayTime = delayTime - 100
இந்த குறியீட்டில் இயல்புநிலை மதிப்பு delayTime அதிலிருந்து 100 ஐக் கழிப்பதன் மூலம் மாற்றியமைக்கப்படுகிறது.
100 என்பது அதன் ஆரம்ப மதிப்பான 1000 இலிருந்து கழிக்கப்படுகிறது, இது 900 இன் புதிய மதிப்பை வழங்குகிறது.
பின்வரும் படத்தின் மூலம் அர்டுயினோ மொழியில் பயன்படுத்தப்படும் கணித ஆபரேட்டர்களில் சிலவற்றைப் புரிந்துகொள்ள முயற்சிப்போம்.
இப்போது 13 மற்றும் 15 வரிக்கு இடையிலான குறியீடுகளை மதிப்பிடுவோம்.
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
எல்.ஈ.டி எந்த தடங்கலும் இல்லாமல் தொடர்ந்து ஒளிரும் என்பதை உறுதி செய்வதே மேற்கண்ட குறியீட்டின் முக்கிய நோக்கம்.
அசலில் இருந்து 100 கழிக்கப்படுவதால் delayTime , இது எல்.ஈ.டி ஒளிரும் பூஜ்ஜியத்தை அடைவதைத் தடுக்கிறது மற்றும் ஒளிரும் தொடர்ச்சியாக செல்ல அனுமதிக்கிறது.
எங்கள் குறியீடுகளில் நாம் பயன்படுத்த விரும்பும் சில ஒப்பீட்டு ஆபரேட்டர்களை பின்வரும் படம் காட்டுகிறது:
எங்கள் மேலே உள்ள குறியீட்டில், குறியீட்டை if(delayTime == 0) என்று சோதித்திருக்கலாம்.
இருப்பினும், எதிர்மறை நபராக இருப்பது மோசமாக இருக்கக்கூடும் என்பதால், நாங்கள் அதற்கு செல்லவில்லை, இது பரிந்துரைக்கப்பட்ட நடைமுறை.
delayTime இலிருந்து 100 க்கு பதிலாக 300 ஐக் கழிக்க முயற்சித்திருந்தால் அதன் விளைவு என்னவாக இருக்கும் என்று சிந்தியுங்கள்?
எனவே delayTime என்றால் இப்போது நீங்கள் உணர்ந்திருக்கலாம் குறைவாகவோ அல்லது பூஜ்ஜியத்திற்கு சமமாகவோ எழுதப்பட்டுள்ளது, பின்னர் தாமத நேரம் அசல் எண்ணிக்கை 1000 க்கு அமைக்கப்படும்.
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
மேலே காட்டப்பட்டுள்ள குறியீட்டின் கடைசி 4 வரிகள் எல்.ஈ.டி ஆன் / ஆஃப், ஆன் / ஆஃப் ஆகியவற்றை தொடர்ச்சியாக மாற்றுவதற்கு காரணமாகின்றன.
இங்கே நீங்கள் பல உருவங்களைப் பயன்படுத்துவதற்குப் பதிலாக, தாமத நேரத்தை ஒதுக்குவதற்கு ஒரு மாறியைப் பயன்படுத்தினோம், இதனால் குறியீட்டின் செயல்பாட்டுக் காலத்தில் நாம் விரும்பியபடி அதை சரிசெய்ய முடியும். அது அருமை, இல்லையா?
2.3 ELSE அறிக்கைகள்
ஏன், எப்படி என்று இங்கே கற்றுக்கொள்வோம் என்றால் காலத்திற்கு ஒரு பிரிவு இருக்கலாம் வேறு அதனால் அது நிலைமையை தீர்மானிக்கும் என்றால் அறிக்கை தவறானது.
இது மிகவும் குழப்பமானதாக இருந்தால் நான் வருந்துகிறேன், கவலைப்பட வேண்டாம், பின்வரும் எடுத்துக்காட்டுடன் அதைப் புரிந்துகொள்ள முயற்சிப்போம்:
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)
}
10 வது வரி குறியீட்டில் delayTime போது மட்டுமே செயல்படுத்தப்படும் என்பதை மேலே உள்ளவற்றில் நீங்கள் காணலாம் 100 க்கு குறைவாகவோ அல்லது சமமாகவோ உள்ளது, இல்லையென்றால் 13 வது வரியில் உள்ள குறியீடு செயல்படுத்தப்படுகிறது, ஆனால் இரண்டுமே ஒன்றாக நடக்காது, 10 வது வரி அல்லது 13 வது வரி குறியீடு செயல்படுத்தப்படும், இரண்டுமே இல்லை.
எங்கள் முந்தைய பிரிவு 2.2 இல் நாங்கள் செய்ததைப் போலல்லாமல், இங்கே 100 உடன் ஒப்பிடுகையில் 0 உடன் ஒப்பிடவில்லை என்பதை நீங்கள் கவனித்திருக்கலாம். இதற்குக் காரணம், இந்த உதாரணத்தில் நாம் 100 ஐக் கழிப்பதற்கு முன்பு ஒப்பிடும்போது, பிரிவு 2.2 க்கு மாறாக, நாங்கள் ஒப்பிட்ட பிறகு கழித்தல். 100 க்கு பதிலாக 0 ஐ ஒப்பிட்டுப் பார்த்தால் என்ன நடந்திருக்கும் என்று சொல்ல முடியுமா?
2.4 WHILE அறிக்கைகள்
TO போது அறிக்கை மிகவும் ஒத்திருக்கிறது என்றால் அறிக்கை, இது ஒரு குறியீட்டின் தொகுதிக்கு (சுருள் அடைப்புக்குறிக்கு இடையில் இருக்கலாம்) மீண்டும் மீண்டும் மரணதண்டனை ஏற்படுத்துகிறது என்ற உண்மையைத் தவிர, நீண்ட காலமாக நிபந்தனைகள் பொருந்தும், மேலும் இது இல்லாமல் செயல்படுகிறது வேறு அறிக்கை.
இதை நன்கு புரிந்துகொள்ள பின்வரும் எடுத்துக்காட்டு உங்களுக்கு உதவும்
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)
}
}
மேலே உள்ள குறியீடு என்ன செய்ய திட்டமிடப்பட்டுள்ளது என்பதை உங்களால் யூகிக்க முடியுமா? சரி, இது எல்.ஈ.டி வேகமாகவும் பின்னர் மெதுவாகவும் சிமிட்டும் வகையில் வடிவமைக்கப்பட்டுள்ளது.
2.5 உண்மை எது பொய்?
நிரலாக்க மொழியில், பொய் பூஜ்ஜியத்தைக் குறிக்கிறது (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 க்கு delayTime, மற்றும் வழிவகுக்கும் என்றால் 0 உண்மையா இல்லையா என்பதை சரிபார்க்க அறிக்கை. 0 என்பது பொய்யைக் குறிப்பதால், அது உண்மை இல்லை என்று நினைக்கும், மேலும் delayTime = 1000 ஐ செயல்படுத்துவதை நிறுத்திவிடும், ஆனால் அதற்கு பதிலாக delayTime வளையத்தின் போது 0 இல் நடைபெறும் ().
இது மிகவும் விரும்பத்தகாததாக தோன்றுகிறது !!
எனவே, இதுபோன்ற வேடிக்கையான தவறுகளை நீங்கள் செய்யவில்லை என்பதை உறுதிப்படுத்த உங்கள் திட்டத்தை எப்போதும் இருமுறை சரிபார்க்கவும்.
2.6 சேர்க்கைகள்
சில விஷயங்களை ஒன்றாகச் சோதிக்க வேண்டிய அவசியத்தை சில நேரங்களில் நீங்கள் உணரலாம். இது போல, ஒரு மாறி இரண்டு எண்களுக்கு இடையில் இருந்ததா என்பதை நீங்கள் ஆராய விரும்பலாம். If அறிக்கையை பல முறை பயன்படுத்தி இதை செயல்படுத்த முடியும் என்றாலும், சிறந்த மற்றும் எளிதான வாசிப்புக்கு தருக்க சேர்க்கைகளைப் பயன்படுத்துவது மிகவும் வசதியாக இருக்கும்.
பின்வரும் அட்டவணையில் காட்டப்பட்டுள்ளபடி, தருக்க சொற்களில் சேர்க்கைகளை 3 முறைகள் மூலம் செய்ய முடியும்:
NOT ஆபரேட்டர் ஒரு மாறிக்கு ஒரு ஸ்விட்சராக வேலை செய்ய முடியும் என்பதை அறிவது சுவாரஸ்யமாக இருக்கும் உண்மை அல்லது பொய் (அல்லது குறைந்த அல்லது உயர்).
பின்வரும் எடுத்துக்காட்டு நிபந்தனையை விளக்குகிறது:
int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}
இங்கே ledState குறைவாக இருக்கும், பின்னர் ledState = !ledState விரைவில், அது உயரமாக மாறும். பின்வரும் வளையம் ledState ledState = !ledState போது அதிகமாக இருக்க வேண்டும் குறைவாக இருக்கிறது.
2.7 அறிக்கைகளுக்கு
இப்போது மற்றொரு கட்டுப்பாட்டு கட்டமைப்பைப் பற்றி புரிந்து கொள்ள முயற்சிப்போம் க்கு வளைய. நீங்கள் பல முறை ஏதாவது ஒன்றை செயல்படுத்த விரும்பினால் இது மிகவும் எளிது.
பின்வரும் எடுத்துக்காட்டுடன் இதைப் புரிந்துகொள்வோம்:
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
}
நீங்கள் வரிசையில் தனித்துவமான ஒன்றைக் காணலாம் க்கு.
இது குறியீடு i ++? . சோம்பேறியாக இருக்கும் மற்றும் வசதியான குறுக்குவழிகள் மூலம் குறியீட்டை செயல்படுத்த விரும்பும் புரோகிராமர்களுக்கு இது பயனுள்ளதாக இருக்கும்
மேற்கூறிய சொல் காம்பவுண்ட் ஆபரேட்டர்கள் என்று அழைக்கப்படுகிறது, ஏனெனில் அவர்கள் ஒரு அசைன்மென்ட் ஆபரேட்டரை மற்றொரு அசைன்மென்ட் ஆபரேட்டருடன் இணைக்கும் வேலையைச் செய்கிறார்கள். இவற்றில் மிகவும் பிரபலமானவை பின்வரும் அட்டவணையில் காட்சிப்படுத்தப்படலாம்:
ஒரு அறிக்கையில் 3 துணை அறிக்கைகள் இருப்பதை நீங்கள் காண்பீர்கள். கீழே காட்டப்பட்டுள்ளபடி இது கட்டமைக்கப்பட்டுள்ளது:
for (statement1conditionstatement2){
// statements
}
# 1 அறிக்கை ஆரம்பத்தில் மற்றும் ஒரே ஒரு முறை நிகழ்கிறது. ஒவ்வொரு முறையும் வளையத்தின் போது நிலை சோதிக்கப்படுகிறது. இருக்கும் போதெல்லாம் உண்மை சுருள் அடைப்புக்குறிக்குள், அடுத்தடுத்த அறிக்கை # 2 செயல்படுத்தப்படுகிறது. ஒரு விஷயத்தில் பொய், கணினி குறியீட்டின் அடுத்த தொகுதிக்கு தாவுகிறது.
மேலும் எல்.ஈ.டிகளை இணைக்கிறது
சரி, இப்போது சுவாரஸ்யமான விளைவுகளைப் பெறுவதற்கு அதிக எண்ணிக்கையிலான எல்.ஈ.டிகளை எவ்வாறு இணைப்பது என்று பார்ப்போம்.
கீழே காட்டப்பட்டுள்ளபடி எல்.ஈ.டி மற்றும் அர்டுயினோவை இணைக்கவும். சிவப்பு கம்பி உண்மையில் தேவையில்லை, ஆனால் ப்ரெட்போர்டில் சப்ளை ரெயில்கள் இரண்டையும் சேர்த்துக் கொள்வது எப்போதும் நல்ல யோசனையாக இருப்பதால், அமைப்பது அர்த்தமுள்ளதாக இருக்கும்.
இப்போது எங்கள் வன்பொருள் சரியாக உள்ளமைக்கப்பட்டுள்ளதா இல்லையா என்பதை சரிபார்க்க உதவும் ஒரு நிரலை சரிசெய்வோம்.
அந்தந்த வன்பொருள்கள் சரியாக கம்பி செய்யப்படுகிறதா இல்லையா என்பதை சரிபார்க்க சிறிய பிட் நிரல்களை குறியீடாக செயல்படுத்த எப்போதும் அறிவுறுத்தப்படுகிறது.
இது சாத்தியமான பிழையை விரைவாக சரிசெய்ய உதவுகிறது.
கீழேயுள்ள குறியீடு எடுத்துக்காட்டு எல்.ஈ.டி 2 முதல் 5 வரை ஒரு குறிப்பிட்ட வடிவத்தை ஒன்றன்பின் ஒன்றாக சுழற்சி முறையில் திருப்புவதன் மூலம் வழங்குகிறது.
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)
}
நீங்கள் கவனிக்கிறபடி, குறியீட்டில் எந்தத் தவறும் இல்லை, அது நீண்டதாகத் தோன்றுகிறது, எனவே தவறுகளுக்கு ஆளாகிறது.
மேலே உள்ள குறியீட்டை எழுத சிறந்த வழிகள் உள்ளன, பின்வரும் பகுதி அதை வெளிப்படுத்தும்.
2.9 வரிசைகளை அறிமுகப்படுத்துதல்
வரிசைகள் மாறிகள் குழுவாக இருக்கலாம், அவை குறியீட்டு எண்களுடன் குறியிடப்படலாம். அதை நன்கு புரிந்துகொள்ள பின்வரும் எடுத்துக்காட்டு நமக்கு உதவும்.
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
}
}
void loop()
{
for(int i = 0 i
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}
சரி, இப்போது ஒவ்வொரு பகுதியையும் கடந்து அவை உண்மையில் எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்வோம்.
const int k_numLEDs = 4
வரிசையில் எத்தனை அதிகபட்ச கூறுகள் இருக்க வேண்டும் என்பதை மேலே உள்ள குறியீடு வரையறுக்கிறது. எல்லாமே ஒரு வரிசைக்குள் எழுதப்பட்டிருப்பதை உறுதிப்படுத்த இந்த குறியீடு அடுத்தடுத்த பிரிவுகளில் நமக்கு உதவுகிறது மற்றும் வரிசை முடிந்ததும் எதுவும் இல்லை.
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
இந்த அடுத்த வரியில் வரிசை கட்டமைப்பை அமைத்துள்ளோம். அடைப்புக்குறிக்குள் உள்ள எண்கள் வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கையைக் குறிக்கின்றன. இருப்பினும், உண்மையான அளவு எழுதப்பட்டிருக்கலாம், மாறிலிகளாக எழுதுவது சிறப்பாக செயல்படுகிறது. மதிப்புகள் பொதுவாக அடைப்புக்குறிக்குள் காற்புள்ளிகளுடன் காணப்படலாம் மற்றும் மதிப்புகளை வரிசைக்கு நியமிக்கலாம்.
எண் 0 உடன் குறியிடப்பட்ட ஒரு வரிசையை நீங்கள் கண்டறிந்தால், இது code: k_LEDPins is k_LEDPins[0] இல் காட்டப்பட்டுள்ளபடி, வரிசையின் முதல் உறுப்பைக் குறிக்கிறது.
இதேபோல் கடைசி உறுப்பு k_LEDPins[3] என காட்டப்படும், ஏனெனில் 0 முதல் 3 வரையிலான எண்ணிக்கை 4 ஆகும்.
void setup()
{
for(int i = 0 i
}
}
மேலே உள்ள குறியீடு ஒவ்வொரு வரிசை கூறுகளின் வழியாகவும் அவற்றை OUTPUTS ஆக அமைப்பதற்கும் லூப்பின் பயன்பாட்டைக் காட்டுகிறது. வரிசையில் உள்ள ஒவ்வொரு உறுப்புகளையும் அடைய குறியீட்டுடன் சதுர அடைப்புக்குறிகளையும் செயல்படுத்துகிறோம்.
வரிசைகள் இல்லாமல் # 5 ஐ முள் # 2 ஐப் பயன்படுத்த முடியுமா என்று நீங்கள் யோசிக்கிறீர்கள் என்றால், பதில் ஆம், அது சாத்தியமாகும். ஆனால் இந்த எடுத்துக்காட்டில் அது செய்யப்படவில்லை, ஏனெனில் நாங்கள் அதை அவ்வாறு செய்யவில்லை. தேர்ந்தெடுக்கப்பட்ட வெளியீட்டு ஊசிகளும் வரிசையில் இல்லாவிட்டால் பின்வரும் பிரிவுகளில் நீங்கள் வரிசை அணுகுமுறையை அகற்றலாம்.
முன்னோக்கி நகரும்போது, குறியீட்டின் அடுத்த தொகுதி என்ன செய்கிறது என்று பார்ப்போம்:
for(int i = 0 i
delay(100)
}
இங்கே குறியீடு ஒவ்வொரு எல்.ஈ.டி வழியாக தொடர்ச்சியாக 100 மில்லி விநாடி இடைவெளி அல்லது தாமதத்துடன் அவற்றை இயக்குகிறது.
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
மேலே உள்ள குறியீட்டைப் பயன்படுத்துவது எவ்வாறு பயன்பாட்டைக் காட்டுகிறது வளையத்திற்கு தலைகீழ் வரிசையில் கூட வளையத்தின் வழியாக செல்ல பயன்படுத்தலாம்.
இது k_numLEDs - 1 இலிருந்து தொடங்குகிறது, ஏனெனில் வரிசைகள் பூஜ்ஜியமாக குறியிடப்படுகின்றன. நாங்கள் k_LEDPins[4] இலிருந்து தொடங்கவில்லை ஏனெனில் அது வரிசையின் முடிவைக் கடக்கும்.
குறியீடு சரிபார்க்க => 0 ஐப் பயன்படுத்துகிறது, இதனால் குறியீட்டு 0 இல் உள்ள முதல் உறுப்பு தவறவிடப்படாது அல்லது புறக்கணிக்கப்படாது.
அத்தியாயம் 3
ஒரு உள்ளீடு என்ன
Arduino ஐப் பயன்படுத்தி விஷயங்களை எவ்வாறு இயக்குவது என்பதை நாங்கள் கற்றுக்கொண்டோம். இந்த அத்தியாயத்தில் வெளிப்புற அளவுருக்களிலிருந்து உள்ளீடுகளை இணைப்பதன் மூலம் உண்மையான உலகத்தை எவ்வாறு உணரலாம் என்பதைப் பற்றி விவாதிப்போம்.
3.1 புஷ்பட்டன்களைப் பயன்படுத்துதல்
புஷ்-பொத்தான் என்றால் என்ன, அது எவ்வாறு இயங்குகிறது என்பதை நாம் அனைவரும் அறிவோம். இது ஒரு வகையான சுவிட்ச் அல்லது பொத்தானாகும், இது ஒரு சர்க்யூட்டை ஒரு சர்க்யூட் கட்டத்தில் இருந்து இன்னொருவருக்கு மனச்சோர்வடைந்த நிலையில் இருக்கும்போது சிறிது நேரத்தில் இணைக்கிறது, மேலும் வெளியிடும் போது சிக்னலை உடைக்கிறது.
3.1.1 ஒரு பொத்தான் மற்றும் ஒரு எல்.ஈ.டி.
மேலே காட்டப்பட்டுள்ள விவரங்களின்படி அர்டுயினோவுடன் புஷ்-பொத்தானைக் கொண்டு அர்டுயினோவை இணைப்போம், மேலும் அமைப்பின் அடிப்படை வேலை மற்றும் செயல்பாட்டைக் கற்றுக்கொள்வோம்.
மைக்ரோ சுவிட்ச் புஷ் பொத்தான் என்றும் அழைக்கப்படும் சுட்டிக்காட்டப்பட்ட புஷ் பொத்தான் மொத்தம் 4 ஊசிகளைக் கொண்டுள்ளது (ஒவ்வொரு பக்கத்திலும் 2 ஜோடிகள்). தள்ளப்படும்போது, ஒவ்வொரு ஜோடி ஊசிகளும் உள்நாட்டில் இணைக்கப்படுகின்றன, மேலும் அவை முழுவதும் ஒரு இணைப்பு அல்லது கடத்துதலை இயக்கும்.
இந்த எடுத்துக்காட்டில் நாம் இந்த ஊசிகளையோ தொடர்புகளையோ ஒரு ஜோடியைப் பயன்படுத்துகிறோம், மற்ற ஜோடி பொருத்தமற்றது, எனவே புறக்கணிக்கப்படுகிறது.
பின்வரும் குறியீட்டைப் பயன்படுத்துகிறோம், அது செயல்படுவதைப் பாருங்கள்!
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)
}
}
அசாதாரணமாகத் தோன்றும் சில விஷயங்களை நீங்கள் இங்கே காணலாம். படி வாரியாக அவற்றைக் கண்டுபிடிப்போம்.
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
நாம் செய்வது முதல் விஷயம் buttonPin என உள்ளீடு. அது மிகவும் அடிப்படை, எனக்கு தெரியும்.
அடுத்து, நாங்கள் ஒதுக்குகிறோம் உயர் க்கு உள்ளீடு முள். நீங்கள் ஆச்சரியப்படுகிறீர்கள், உள்ளீட்டில் எதையும் எழுதுவது எப்படி சாத்தியமாகும்? நிச்சயமாக, இது சுவாரஸ்யமாக இருக்கலாம்.
உண்மையில், ஒரு ஆர்டுயினோ உள்ளீட்டிற்கு ஒரு உயர்வை ஒதுக்குவது உள் 20 கி ஓம் புல்-அப் மின்தடையத்தை இயக்குகிறது (இந்த முள் குறைவானது அதை முடக்குகிறது).
நீங்கள் இழுக்கக்கூடிய மின்தடை என்றால் என்ன என்பது மற்றொரு கேள்வி. நீங்கள் இழுக்கும் மின்தடையங்களில் ஒரு விரிவான இடுகையை நான் உள்ளடக்கியுள்ளேன் அதை இங்கே கற்றுக்கொள்ளுங்கள் .
சரி, நகரும், இப்போது முக்கிய லூப் குறியீட்டைப் பார்ப்போம்:
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
நீங்கள் புஷ் பொத்தானை அழுத்தும்போது, கம்பி முள் தரையில் இணைக்கப்படும், இது ஒரு குறைந்த அந்த முள். அழுத்தப்படாத நிலையில் அதே முள் வைக்கப்படுகிறது உயர் அல்லது 20K உள் புல்-அப் மின்தடையின் வழியாக + 5 வி.
புஷ் பொத்தானை அழுத்தும் போது (குறைந்த) அர்டுயினோ எல்.ஈ.டி ஒளிர வேண்டும் என்று இங்கே விரும்புகிறோம், எனவே புஷ் பொத்தானிலிருந்து ஒரு குறைந்த ஒவ்வொரு பதிலுக்கும் வெளியீட்டிற்கு உயர் எழுதுகிறோம், அது அழுத்தும் போது.
3.1.2 இரண்டு பொத்தான்கள் மற்றும் ஒரு எல்.ஈ.டி.
சரி, மேலே காட்டப்பட்ட செயலை ஒரு ஆர்டுயினோ இல்லாமல் செய்திருக்கலாம் என்று நீங்கள் ஆச்சரியப்படுவீர்கள். நான் புரிந்துகொள்கிறேன், இருப்பினும் இது அர்ச்சுனோவுடன் புஷ் பொத்தானை எவ்வாறு பயன்படுத்தலாம் என்பதை அறிய ஒரு செங்குத்தான கல்.
இந்த கட்டம் வரை, சுவிட்ச் ஆன் (ஹை) அல்லது எல்.ஈ.டி ஆஃப் (ஆஃப்) (குறைந்த) மாறுவதற்கான குறியீடுகளை எழுதுவதைப் படித்தோம்.
எல்.ஈ.டி யின் பிரகாசத்தை ஒரு ஆர்டுயினோவுடன் எவ்வாறு கட்டுப்படுத்த முடியும் என்பதை இப்போது பார்ப்போம்.
இது இரண்டு முறைகளைப் பயன்படுத்தி செய்யப்படலாம்:
- எல்.ஈ.டிக்கு மின்னோட்டத்தின் அளவைக் கட்டுப்படுத்துவதன் மூலம்
- பயன்படுத்தி பி.டபிள்யூ.எம் அல்லது துடிப்பு அகல பண்பேற்றம், இதில் எல்.ஈ.டிக்கு வழங்கல் சில விரும்பிய விகிதத்தில் மிக விரைவாக ஆன் / ஆஃப் செய்யப்படுகிறது, இது சராசரி வெளிச்சத்தை உருவாக்குகிறது, இதன் தீவிரம் PWM ஐப் பொறுத்தது.
ஒரு ஆர்டுயினோ போர்டில் பி.டபிள்யூ.எம் ஆதரவு ஒரு டில்ட் (~) எனக் குறிக்கப்பட்ட ஊசிகளில் கிடைக்கிறது, அவை ஊசிகளான 3, 4,5,9,10 மற்றும் 11) 500 ஹெர்ட்ஸ் (வினாடிக்கு 500 முறை). பயனர் 0 மற்றும் 255 க்கு இடையில் எந்த மதிப்பையும் வழங்க முடியும், அங்கு 0 என்பது HIGH அல்லது + 5V இல்லை என்பதைக் குறிக்கிறது, மேலும் 255 Arduino க்கு ஒரு HIGH அல்லது + 5V ஐ எப்போதும் பெறச் சொல்கிறது. இந்த கட்டளைகளைத் தொடங்க நீங்கள் விரும்பிய மதிப்புடன் அனலாக்ரைட் () ஐ அணுக வேண்டும்.
நீங்கள் PWM ஐ x / 255 என்று கருதலாம், அங்கு x என்பது analogWrite() வழியாக அனுப்ப விரும்பும் மதிப்பு.
மேலே காட்டப்பட்டுள்ளபடி Arduino மற்றும் பிற அளவுருக்களை அமைக்கவும்.
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)
}
சில விளக்கங்கள் தேவைப்படும் 3 வரிகளை இங்கே காணலாம்.
ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)
வரி: ledBrightness = constrain(ledBrightness, 0, 255) Arduino க்குள் ஒரு தனித்துவமான செயல்பாட்டை விளக்குகிறது.
இந்த உள் செயல்பாடு பின்வருவனவற்றை ஒத்த குறியீட்டைக் கொண்டுள்ளது:
முழு கட்டுப்பாடு (முழு மதிப்பு, முழு நிமிடம், முழு அதிகபட்சம்) {
if(value > max){
value = max
}
if(value
}
return value
}
இதற்கு முன்னர் விவாதிக்கப்பட்ட அனைத்து குறியீடுகளும் தொடங்கப்பட்டன வெற்றிடத்தை , இதன் பொருள் எதையும் திருப்பித் தரக்கூடாது (வெற்றிடத்தை). அதேசமயம் மேலே உள்ள குறியீடு தொடங்குகிறது எண்ணாக , இது ஒரு முழு எண்ணைத் தருகிறது என்பதைக் குறிக்கிறது. பிந்தைய பிரிவுகளில் இதைப் பற்றி மேலும் விவாதிப்போம், ஒரு முழு எண்ணுக்கு எந்த பகுதியும் இல்லை என்பதை இந்த நேரத்தில் நினைவில் கொள்க.
சரி, எனவே இது குறிக்கிறது: ledBrightness = constrain(ledBrightness, 0, 255) ledBrightness to be within the range of 0 and 255 ஐ ஒதுக்குகிறது.
அடுத்த வரியில் analogWrite தேர்ந்தெடுக்கப்பட்ட முள் மீது PWM ஐ விரும்பிய மதிப்புடன் பயன்படுத்த Arduino ஐ கட்டளையிட.
அடுத்த வரி 20 மில்லி விநாடிகளின் தாமதத்தை உருவாக்குகிறது, இது 50 ஹெர்ட்ஸை விட வேகமாக அல்லது ஒரு வினாடிக்கு 50 மடங்கு சாப்பிடாமல் இருப்பதை உறுதி செய்வதாகும். ஏனென்றால், மனிதர்கள் ஒரு அர்டுயினோவை விட மெதுவாக இருக்க முடியும். எனவே தாமதம் செய்யப்படாவிட்டால், முதல் பொத்தானை அழுத்துவதன் மூலம் எல்.ஈ.டி முடக்கப்பட்டு இரண்டாவது பொத்தானை அழுத்தினால் அதை இயக்கலாம் (உறுதிப்படுத்த அதை நீங்களே முயற்சிக்கவும்).
3.2 பொட்டென்டோமீட்டர்கள்
முன்னேறி, எவ்வாறு பயன்படுத்துவது என்பதைக் கற்றுக்கொள்வோம் Arduino உடன் potentiometers.
பொட்டென்டோமீட்டர் அல்லது ஒரு பானை எவ்வாறு இயங்குகிறது என்பதை அறிய, இதைப் படிக்கலாம் கட்டுரை .
மேலே காட்டப்பட்டுள்ளபடி காட்டப்பட்ட அளவுருக்களை உங்கள் Arduino உடன் இணைக்கவும்.
ஒரு பானையில் 3 முனையங்கள் இருக்கும். நடுத்தர டெர்மினஸ்ல் Arduino இல் ANALOG IN 0 உடன் இணைக்கும். மற்ற இரண்டு வெளி முனையங்கள் + 5 வி மற்றும் 0 வி விநியோக தண்டவாளங்களுடன் இணைக்கப்படலாம்.
நிரல் செய்து முடிவுகளைப் பார்ப்போம்:
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)
}
எங்கள் முந்தைய குறியீடுகளில் எதுவும் சேர்க்கப்படாத முற்றிலும் புதியதாகத் தோன்றும் சில விஷயங்களை நீங்கள் காண்பீர்கள்.
- நிலையான
kPinPotA0 என ஒதுக்கப்பட்டுள்ளது, இதில் A என்பது அனலாக் ஊசிகளில் ஒன்றை விவரிக்க குறுக்குவழி ஆகும். இருப்பினும் A0 பின் # 14, A1 ஐ முள் # 15 மற்றும் முன்னும் பின்னும் குறிக்கிறது, மேலும் இவை ஒரு சோதனைக்கு நீங்கள் ஊசிகளை விட்டு வெளியேறினால் டிஜிட்டல் உள்ளீடுகள் / வெளியீடுகளாக பயன்படுத்த அனுமதிக்கின்றன. ஆனால் நீங்கள் டிஜிட்டல் ஊசிகளை அனலாக் ஊசிகளாக பயன்படுத்த முடியாது என்பதை நினைவில் கொள்க. - வரி:
ledBrightness = map(sensorValue, 0, 1023, 0, 255)Arduino இல் ஒரு புதிய உள்ளே செயல்பாட்டை வழங்குகிறது வரைபடம் (). இந்த அம்சம் ஒரு குறிப்பிட்ட வரம்பிலிருந்து மற்றொரு அளவிற்கு மறு அளவீடு செய்கிறது, என அழைக்கப்படுகிறது வரைபடம் (மதிப்பு, fromLow, fromHigh, toLow, toHigh).analogueReadமுதல் இது முக்கியமானதாக மாறக்கூடும் 0-1023 வரம்பிற்குள் ஒரு மதிப்பை அளிக்கிறது, ஆனால் அனலாக்ரைட் 0-255 முதல் மதிப்பை ஏற்க முடியும்.
எல்.ஈ.டி யின் பிரகாசத்தை மாறும் எதிர்ப்பின் மூலம் கட்டுப்படுத்த முடியும் என்பதால், ஒரு பானை இந்த நோக்கத்திற்காக போதுமானதாக இருந்திருக்கலாம், ஏன் அர்டுயினோவின் பயன்பாடு என்று நீங்கள் நினைக்கலாம். சரி, மீண்டும் ஒரு அடித்தளம் தான், ஒரு பானை ஒரு அர்டுயினோவுடன் எவ்வாறு கட்டமைக்க முடியும் என்பதைக் காண்பிக்க.
சிக்கல்கள் இல்லை, இப்போது ஒரு ஆர்டுயினோ இல்லாமல் செய்ய முடியாத ஒன்றை நாங்கள் செய்வோம்.
எல்.ஈ.டி யின் ஒளிரும் வேகம் அல்லது வீதத்தைக் கட்டுப்படுத்த ஒரு பானையின் மாறுபட்ட எதிர்ப்பை எவ்வாறு பயன்படுத்தலாம் என்பதை இந்த சோதனையில் பார்ப்போம்.
இங்கே திட்டம்:
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)
}
3.2.3 தாமதத்தைத் தவிர்ப்பது ()
மேலே உள்ள குறியீடு நன்றாக இருக்கிறது, ஆனால் எல்.ஈ.டி ஒவ்வொரு முழு சுழற்சியிலும் செல்லும் வரை பானை மதிப்பை சரிபார்க்க முடியவில்லை. நீண்ட தாமதங்களுக்கு இந்த செயல்முறை நீண்டதாகிறது, பயனர் அதை நகர்த்தும்போது பானை பதிலைக் காண காத்திருக்க வேண்டும். இந்த தாமதத்தை சில புத்திசாலித்தனமான நிரலாக்கங்களுடன் தவிர்க்கலாம், இதனால் பயனர்கள் குறைந்தபட்ச தாமதங்கள் இல்லாமல் மதிப்பைச் சரிபார்க்க அனுமதிக்கிறது. இங்கே குறியீடு.
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)
}
}
எனவே மேலே உள்ள குறியீட்டில் வேறுபட்டது என்ன? பின்வரும் வரியே வித்தியாசத்தை ஏற்படுத்துகிறது.
long lastTime = 0
இந்த பகுதி வரை, நாம் முழு எண்ணாக பற்றி விவாதித்தோம். இருப்பினும், நீங்கள் அணுகக்கூடிய பல வகையான மாறிகள் இருக்கலாம். பட்டியலை கீழே படிக்கலாம்:
தற்போது, ஒப்பீட்டளவில் பெரிய எண்ணிக்கையை சேமிப்பதற்காக என்பதை அறிவது மட்டுமே முக்கியமானதாக இருக்கலாம் எண்ணாக மாறி, நீங்கள் இந்த வார்த்தையைப் பயன்படுத்தலாம் நீண்டது அல்லது ஒரு நீண்ட எண்ணாக.
இங்கே நீங்கள் மற்றொரு சுவாரஸ்யமான செயல்பாட்டைக் காணலாம் மில்லிஸ் ().
இது ஆரம்பத்தில் இருந்தே ஆர்டுயினோ அதன் செயல்பாட்டின் போது பணியாற்றிய நேரத்தை மில்லி விநாடிகளில் உருவாக்குகிறது (இது ஒவ்வொரு 50 நாட்களுக்குப் பிறகு 0 ஆக மீட்டமைக்கப்படும்). இங்கே அது நீண்ட நேரம் திரும்பும், ஏனெனில் அது திரும்பினால் எண்ணாக , நீண்ட காலத்திற்கு எண்ணுவது சாத்தியமில்லை. எவ்வளவு நேரம் சரியாக பதிலளிக்க முடியுமா? பதில் 32.767 வினாடிகள்.
எனவே தாமதம் () ஐப் பயன்படுத்துவதற்குப் பதிலாக, மில்லிஸ் () ஐச் சரிபார்க்கிறோம், குறிப்பிட்ட எண்ணிக்கையிலான மில்லி விநாடிகள் முடிந்தவுடன் எல்.ஈ.டி. இதன் விளைவாக நாங்கள் மாற்றிய நேரத்தை கடைசியாக சேமித்து வைக்கிறோம் கடைசி நேரம் மாறி, இதனால் எப்போது வேண்டுமானாலும் அதை மீண்டும் சரிபார்க்க அனுமதிக்கிறது.
3.3 ஆர்ஜிபி எல்.ஈ.
இதுவரை எல்.ஈ.டி என்ற ஒற்றை வண்ணத்துடன் விளையாடியுள்ளோம். எல்.ஈ.டியை மற்றொரு நிறத்துடன் மாற்றுவதன் மூலம் எல்.ஈ.டி நிறத்தை மாற்ற முடியும் என்றாலும், ஆர்.ஜி.பி எல்.ஈ. எல்.ஈ.டி வண்ணங்களை மாற்ற எல்.ஈ.டிகளை மாற்றாமல்?
ஒரு RGB எல்.ஈ.டி அடிப்படையில் ஒரு சிவப்பு, பச்சை மற்றும் நீல எல்.ஈ.டி கொண்ட ஒரு எல்.ஈ.டி உட்பொதிக்கப்பட்டு ஒற்றை எல்.ஈ. இது ஒரு பொதுவான ஈயத்தைக் கொண்டுள்ளது, இது தரையில் அல்லது 0 வி சப்ளை ரெயிலுக்குச் செல்கிறது, மற்ற 3 தடங்கள் பன்முகப்படுத்தப்பட்ட பி.டபிள்யூ.எம் நேர்மறை சமிக்ஞைகளுடன் வழங்கப்படுகின்றன வண்ண கலவை .
கீழே காட்டப்பட்டுள்ளபடி அமைப்பை நீங்கள் கம்பி செய்யலாம்:
இது கொஞ்சம் சிக்கலானதாகத் தோன்றலாம், ஆனால் உண்மையில் இது PWM ஐப் பயன்படுத்தி எங்கள் முந்தைய எல்.ஈ.டி கட்டுப்பாட்டு வடிவமைப்பின் பிரதி.
நடைமுறை நிரல் குறியீடு இங்கே:
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)
}
இந்த குறியீட்டைப் பதிவேற்றிய பிறகு, பானை சரிசெய்தல் RGB இல் சுவாரஸ்யமான ஒளி விளைவை எவ்வாறு உருவாக்குகிறது என்பதைப் பாருங்கள், இது ஒரு உண்மையான வேடிக்கையாக இருக்கும்.
அனைத்து 3 பானைகளும் அதிகபட்ச நிலைகளை நகர்த்தும்போது, ஒரு வெள்ளை நிறத்திற்கு பதிலாக நீங்கள் சிவப்பு நிறத்தைக் காண்பீர்கள். ஏனென்றால் 3 வண்ணங்களில் சிவப்பு நிறம் மிக முக்கியமானது, எனவே இந்த சூழ்நிலையில் ஆதிக்கம் செலுத்துகிறது. இருப்பினும் நீங்கள் செயல்பாட்டை பரிசோதிக்கலாம் வரைபடம் () , எல்.ஈ.டி யின் சிவப்பு பகுதிக்கு அதை இயக்குவதற்கு முன்பு, மிகவும் விவேகமான சமநிலையை உருவாக்கும் பொருட்டு.
Arduino உடன் ஆடியோ
இந்த பிரிவில் ஒரு ஆர்டுயினோ அமைப்பில் அடிப்படை ஒலி மற்றும் இசையை எவ்வாறு சேர்ப்பது என்பதைக் கற்றுக்கொள்வோம்.
விரும்பிய அதிர்வெண் கொண்ட இணைக்கப்பட்ட ஸ்பீக்கருக்கு சிக்னலை எவ்வாறு மாற்றுவது என்று பார்ப்போம்.
இன்னும் துல்லியமாக இருக்க, ஒரு நடுத்தர குறிப்பு முயற்சிக்கப்படும், இது 440 ஹெர்ட்ஸ் அதிர்வெண் குறிப்பு.
இதைச் செய்ய நாம் ஒரு நடுத்தர குறிப்பை விளையாடுவோம், மேலும் சதுர அலை மூலம் சைன் அலை சமிக்ஞையை மேம்படுத்துவோம்.
மேலும், சூத்திரத்தில் வழக்குத் தொடுப்பதன் மூலம் ஒலிபெருக்கி இயங்கக்கூடிய நேரத்தைக் கணக்கிடுவோம்:
timeDelay = 1 வினாடி / 2 x தொனி அதிர்வெண்.
timeDelay = 1 வினாடி / 2 x 440
timeDelay = 1136 மைக்ரோ விநாடிகள்
4.1 Arduino Board ஐ இணைப்போம்
4.2 ஒரு எளிய குறிப்பைச் சேர்த்தல்
செயல்பாடு பற்றி ஏற்கனவே விவாதித்தோம் தாமதம் () அலகு மில்லி விநாடிகளில் (இரண்டாவது / 1000) இருக்கும், இருப்பினும் நீங்கள் மற்றொரு செயல்பாட்டைக் காண்பீர்கள் delayMicroseconds() அலகு மைக்ரோ விநாடிகளில், (மில்லி விநாடி / 1000).
தற்போதைய அமைப்பிற்காக, ஸ்பீக்கருடன் இணைக்கப்பட்ட தேர்ந்தெடுக்கப்பட்ட முள் மீது + 5 வி ஆன் / ஆஃப் செய்ய ஒரு குறியீட்டை நிரல் செய்கிறோம், வினாடிக்கு 440 பருப்பு வீதம்.
நினைவில் கொள்ளுங்கள், கடந்த கலந்துரையாடலில் 1136 மைக்ரோ செகண்ட் மதிப்பை நோக்கம் கொண்ட ஆடியோ குறிப்புக்கு தீர்மானித்தோம்.
எனவே இதற்கான நிரல் இங்கே உள்ளது, இது ஒரு ஸ்பீக்கருடன் இணைக்கப்பட்ட அர்டுயினோவை நிரல் செய்தவுடன் 440 ஹெர்ட்ஸ் ஆடியோ குறிப்பைக் கேட்க அனுமதிக்கும்.
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)
}
மேலே உள்ள பயன்பாட்டின் மூலம் ஆடியோ குறிப்பை உருவாக்க முடியும், அதாவது எங்கள் விருப்பப்படி ஒரு இசையை உருவாக்க முடியும்.
குறியீட்டிலிருந்து அர்டுயினோ இரண்டு ஒருங்கிணைந்த செயல்பாடுகளை உள்ளடக்கியது என்பதை நாங்கள் புரிந்துகொள்கிறோம், இது இசையை உருவாக்க கூடுதலாக பங்களிக்கிறது.
முதல் ஒன்று தொனி () இது 3 வது விருப்ப உறுப்புடன் 2 கூறுகளுடன் செயல்படுகிறது தொனி (முள், அதிர்வெண், காலம்). அல்லது தொனி (முள், அதிர்வெண்)
நீங்கள் நியமித்த கால அவகாசத்தை செயல்படுத்த இருவரும் நியமிக்கப்பட்டுள்ளனர்.
ஒரு கால அவகாசம் இல்லாத நிலையில், அழைப்பு வரும் வரை இசை தொடர்ந்து இயங்கும் தொனி () மீண்டும் செயல்படுத்தப்படுகிறது, அல்லது நீங்கள் இயக்கும் வரை ஒன்று இல்லை ().
மியூசிக் பிளேயிங் மட்டுமே நீங்கள் செயல்படுத்தும் அடிப்படை விஷயமாக இருந்தால் தாமத செயல்பாட்டைப் பயன்படுத்தி இதைச் செய்ய வேண்டும்.
இசை காலம் எவ்வளவு நேரம் இசைக்கப்படுகிறது என்பதற்கான நேரத்தை வழங்க அனுமதிப்பதால் கால அளவு முக்கியமானதாக இருக்கலாம், எனவே மற்ற விஷயங்களைச் செய்ய நீங்கள் இலவசமாக முடியும். காலம் முடிந்தவுடன், இசை நிறுத்தப்படும்.
அடுத்த செயல்பாடு ஒன்று இல்லை () ஒற்றை அளவுருவை கையாளுகிறது மற்றும் ஒரு குறிப்பிட்ட ஒதுக்கப்பட்ட முள் மீது தேர்ந்தெடுக்கப்பட்ட தொனியை நிறுத்துகிறது.
ஒரு விசித்திரமான எச்சரிக்கை: எப்போது வேண்டுமானாலும் தொனி () செயல்பாடு செயல்படுத்தப்படுகிறது, முள் 3 மற்றும் 11 இல் PWM செயல்பாடு செயல்படுவதை நிறுத்தும்.
எனவே நிரலில் ஒரு ஸ்பீக்கர் இணைப்பு பயன்படுத்தப்படும்போதெல்லாம், ஸ்பீக்கர்களுக்காக குறிப்பிடப்பட்ட முள் பயன்படுத்த வேண்டாம் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள், அதற்கு பதிலாக ஸ்பீக்கர் இணைப்பிற்கு வேறு சில ஊசிகளை முயற்சிக்கவும்.
சரி, ஒரு ஸ்பீக்கரில் இசையை செயல்படுத்துவதற்கான நிரல் இங்கே உள்ளது, இருப்பினும் இது ஒரு உண்மையான இசை அல்ல, மாறாக ஒரு அடிப்படை அளவிலான சி குறிப்பு.
#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)
}
மேலே உள்ள குறியீட்டில் நீங்கள் புதிதாக ஒன்றைக் கவனித்திருக்கலாம், அதுதான் #வரையறு .
தொகுத்தல் செய்யப்படும்போது இந்த சொல் கணினிக்கான தேடல் மற்றும் மாற்று கட்டளையைப் போல செயல்படுகிறது.
ஒரு இடத்திற்கு முன் முதல் விஷயத்தைக் கண்டுபிடிக்கும் போதெல்லாம், அதை வரியின் மீதமுள்ள பகுதியுடன் மாற்றுகிறது (மேக்ரோக்கள் என அழைக்கப்படுகிறது).
எனவே கணினி பார்க்கும்போது இந்த எடுத்துக்காட்டுக்குள் NOTE_E4 அது விரைவாக அதை 330 அளவுடன் மாற்றுகிறது.
கூடுதல் குறிப்புகள் மற்றும் தனிப்பயனாக்கலுக்கு உங்கள் யூ.எஸ்.பி ஸ்டிக்கில் உள்ள கோப்பைக் குறிப்பிடலாம் pitches.h , உங்கள் விருப்பத்திற்கு பெரும்பாலான அதிர்வெண்களைக் காணலாம்.
4.4 செயல்பாடுகளுடன் இசை
மேலே உள்ள குறியீடு நன்றாக இருக்கிறது, ஆனால் பல மறுபடியும் மறுபடியும் தெரிகிறது, இந்த மறுபடியும் மறுபடியும் குறைக்க சில முறை இருக்க வேண்டும், இல்லையா?
இதுவரை நாங்கள் Arduino உடன் சேர்க்கப்பட்ட இரண்டு அத்தியாவசிய செயல்பாடுகளுடன் பணியாற்றியுள்ளோம். இப்போது நாம் எங்கள் சொந்த செயல்பாடுகளை உருவாக்கிய நேரமாக இருக்கலாம்.
ஒவ்வொரு செயல்பாடும் அதனுடன் தொடர்புடைய மாறி வகையுடன் தொடங்க வேண்டும். உதாரணமாக செயல்பாடு வெற்றிடத்தை எதையும் குறிக்காத வகையை குறிக்கிறது, எனவே பெயர் வெற்றிடமாகும். குறிப்பு, எங்கள் முந்தைய பிரிவுகளில் மாறி பட்டியலை நாங்கள் ஏற்கனவே விவாதித்தோம், நீங்கள் அவற்றைக் குறிப்பிட விரும்பலாம்.
இதன் விளைவாக, குறிப்பிட்ட செயல்பாட்டு பெயர் திறந்த அடைப்புக்குறிப்பைப் பெறுகிறது '(' கமாவால் பிரிக்கப்பட்ட அளவுருக்களின் பட்டியலைத் தொடர்ந்து.
ஒவ்வொரு அளவுருவும் அதன் வகையை ஒரு பெயருடன் சேர்த்து, இறுதியாக ஒரு நெருக்கமானதைப் பெறுகிறது ')' அடைப்பு.
இந்த அளவுருக்கள் செயல்பாட்டிற்குள் மாறிகள் வடிவத்தில் பயன்படுத்தப்படலாம்.
என்று அழைக்கப்படும் ஒரு செயல்பாட்டை உருவாக்கும் ஒரு உதாரணத்தை கீழே காணலாம் எங்கள் டோன் () ஒன்றிணைக்க வடிவமைக்கப்பட்டுள்ளது தொனி () உடன் தாமதம் () கோடுகள், குறிப்பு தொனியில் விளையாடுவதை முடிக்கும் வரை செயல்பாடு திரும்புவதை நிறுத்துகிறது.
இந்த செயல்பாடுகளை எங்கள் முந்தைய குறியீட்டில் செயல்படுத்துகிறோம், மேலும் கீழேயுள்ள நிரலைப் பெறுகிறோம், கடைசி வரிகளைப் பார்க்கவும்:
#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)
}
ஒரு நிரலைப் புரிந்துகொள்வதை எளிதாக்குவதற்கு செயல்பாடுகள் மிகவும் எளிது.
பின்வருவது இரண்டு வரிசைகளைப் பயன்படுத்தி நாம் விளையாட விரும்பும் தொனியின் தேர்வைக் குறிப்பிடக்கூடிய ஒரு எடுத்துக்காட்டு. குறிப்புகளைத் தக்கவைத்துக்கொள்வதற்கான ஒரு வரிசை, மற்றொன்று துடிப்புகளைத் தக்கவைத்தல்.
#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
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)
}
அறிமுகத்தை முதல் வரியில் நீங்கள் தெளிவாகக் காணலாம் #சேர்க்கிறது அறிக்கை. இந்த அறிக்கையின் வேலை மேற்கோள்களுக்கு இடையில் முழு கோப்பையும் எடுத்து அதை நிலையில் வைப்பது #சேர்க்கிறது அறிக்கை. நிலையான விதிகளின்படி இவை திட்டத்தின் தொடக்கத்தில் கண்டிப்பாக வைக்கப்படுகின்றன.
அத்தியாயம் 5
வெப்பநிலையை அளவிடுதல்
நினைவுகூர, பெரிய நிரல்களை முழுவதுமாக எழுதுவதற்கு பதிலாக நினைவில் கொள்ளுங்கள், குறியீடுகளின் சிறிய பகுதிகளை எழுதுவதும் பகுப்பாய்வு செய்வதும் எப்போதும் புத்திசாலித்தனம், இது தவறுகளை விரைவாகக் கண்டறிய உதவுகிறது.
5.1 சீரியல் மானிட்டர்
இப்போது வரை, நாங்கள் விவாதித்த குறியீடுகள் விரைவான சரிசெய்தலை இயக்குவது அவ்வளவு சுலபமாகத் தெரியவில்லை. சாத்தியமான சிக்கலைக் கண்காணிப்பதற்கும் எளிதில் தீர்ப்பதற்கும் விஷயங்களை எளிதாக்க இங்கே முயற்சிப்போம்.
Arduino ஒரு அம்சத்தைக் கொண்டுள்ளது, இது கணினியுடன் 'மீண்டும் பேச' உதவுகிறது. பின் 0 மற்றும் பின் 1 ஆகியவை ஒருவருக்கொருவர் ஆர்எக்ஸ் ஒரு டிஎக்ஸ் என குறிக்கப்பட்டுள்ளதை நீங்கள் கவனிக்கலாம். இந்த ஊசிகளை உண்மையில் அர்டுயினோவிற்குள் ஒரு தனி ஐ.சி மூலம் கண்காணிக்கப்படுகிறது, இது கணினியில் செருகப்படும்போது யூ.எஸ்.பி கேபிள் முழுவதும் படிக்க மேம்படுத்தும்.
கீழேயுள்ள பகுதி ஒரு முழுமையான நிரலைக் காட்டுகிறது, தயவுசெய்து செல்லுங்கள், அதன் பின்னர் குறியீட்டில் உள்ள புதிய உள்ளீடுகளைப் பற்றி அறிந்து கொள்வோம். இந்த குறியீடு வெளிப்படுத்தப்பட்ட பிரிவு 2.2 ஐப் போன்றது, இது குறியிடப்பட்டதை அடையாளம் காண எங்களை அனுமதிப்பதற்கான சில கூடுதல் தரவை உள்ளடக்கியது.
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)
}
நீங்கள் இங்கே இரண்டு புதிய விஷயங்களை அடையாளம் காணலாம், ஒரு புதிய வரி அமைப்பு () செயல்பாடு.
Serial.begin(9600)
இந்த வரி வெறுமனே பயன்படுத்த வேண்டிய அவசியத்தை வெளிப்படுத்துகிறது சீரியல் 1 9600 பாட் மூலம் அதை செயல்படுத்த குறியீடு. (இங்கே சீரியல் குறிக்கிறது பிட்கள் ஒன்றன் பின் ஒன்றாக அனுப்பப்பட்டது, மற்றும் பாட் என்றால் அது அனுப்பப்படும் வீதம் என்று பொருள்). இந்த பாட் மதிப்பு மற்றும் சீரியல் மானிட்டரில் உள்ள ஒன்று (இதை நாங்கள் பின்னர் கற்றுக்கொள்வோம்) சமமாக இருக்க வேண்டும், இல்லையெனில் சீரியல் மானிட்டரில் உள்ள தரவு குப்பைகளைக் காண்பிக்கும். 9600 தரநிலையாக இருப்பது பயன்படுத்த மிகவும் வசதியானது.
இரண்டாவது புதிய நுழைவு பின்வருமாறு
Serial.print('delayTime = ')
Serial.println(delayTime)
சீரியல் போர்ட்டிலிருந்து வெளிவரும் அடுத்த விஷயம் அடுத்த வரியில் தொடங்கும் என்று இங்கே இரண்டாவது வரி அறிவுறுத்துகிறது. இரண்டாவது வரி ஃபிஸ்ட் கோட்டிலிருந்து வேறுபட்டது.
நீங்கள் பார்க்கக்கூடிய இன்னொரு விஷயம் மேற்கோள்கள் ('). இது ஒரு சரம் என்று அழைக்கப்படுகிறது, இது இங்கே மாறிலிகளைப் போலவே பயன்படுத்தப்படும், ஏனெனில் இந்த தலைப்பில் மேலும் விவாதம் மிகவும் விரிவானதாகவும், எல்லைக்கு அப்பாற்பட்டதாகவும் இருக்கும்.
சரி, இப்போது மேலே உள்ள குறியீட்டை Arduino இல் பதிவேற்றலாம் மற்றும் என்ன நடக்கிறது என்று பார்க்கலாம்.
என்ன, அச்சச்சோ எதுவும் நடக்கவில்லை என்று தோன்றுகிறது, அர்டுயினோ முள் # 13 எல்.ஈ.டி ஒளிரும் மற்றும் நிறுத்தப்பட்டது, அதே நேரத்தில் டி.எக்ஸ் எல்.ஈ.டி ஒளிரும்.
சரி, சீரியல் மானிட்டர் சாளரம் இன்னும் சரி செய்யப்படவில்லை என்பதால் தான்.
மேலே காட்டப்பட்டுள்ளபடி உங்கள் IDE இல் உள்ள சீரியல் மானிட்டர் பெட்டியில் கிளிக் செய்ய வேண்டும். கீழ் வலதுபுறத்தில் அமைந்துள்ள பாட் வீதத்தை சரிபார்க்க மறக்காதீர்கள், முன்னிருப்பாக இது 9600 ஆக இருக்க வேண்டும், மேலும் இது குறியீட்டுடன் பொருந்தும். இல்லையென்றால் 9600 ஐத் தேர்ந்தெடுப்பது உறுதி.
இது எவ்வாறு செய்யப்படுகிறது என்பதை பின்வரும் வீடியோ கிளிப் விளக்குகிறது.
https://youtu.be/ENg8CUyXm10இப்போது மேலே செல்லலாம் மற்றும் செயலாக்க மேலே உள்ள சீரியல் மானிட்டர் அம்சம் எவ்வாறு உதவக்கூடும் என்பதை அறியலாம் Arduino ஐப் பயன்படுத்தி வெப்பநிலையின் அளவீட்டு
-40 முதல் 150 டிகிரி செல்சியஸ் வரம்பைக் கொண்ட ஐசி டி.எம்.பி 36 ஐ வெப்பநிலை சென்சாராகப் பயன்படுத்துவோம்.
அமைப்பை கீழே காணலாம்:
பின்வரும் குறியீடு TMP36 சென்சாரிலிருந்து வெளியீட்டைப் படிப்பதன் மூலமும், ஐடியின் சீரியல் மானிட்டருக்கு அனுப்புவதன் மூலமும் வெப்பநிலையை அளவிடத் தொடங்கும்.
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()
மாறி வகையை நாங்கள் சேர்த்துள்ளதை இங்கே காணலாம் மிதவை.
முழு எண் எண்களைத் தவிர எல்லாவற்றையும் (தசம அல்லது பகுதியளவு இல்லாத எண்கள்) சேமித்து வைக்கும் ஒரே மாறி வகை இதுவாகும்.
மிதவை மாறியில் இருந்து துல்லியம் 6 முதல் 7 இலக்கங்கள் வரை இருக்கலாம்.
அருகிலுள்ள குறியீடு getTemperatureC() எங்கள் சொந்த செயல்பாடு, இது TMP36 சென்சாரிலிருந்து உணரப்பட்ட மின்னழுத்த வேறுபாட்டை கணித ரீதியாக கணக்கிட்டு டிகிரி செல்சியஸாக மாற்றுகிறது.
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
}
analogIn() என்ற காலத்திலிருந்து குறியீடுகளின் அடுத்த பகுதியில் 1 முதல் 1023 வரை ஒரு உருவத்தைத் திருப்புவதற்கு ஒதுக்கப்பட்டுள்ளது, சென்சாரிலிருந்து வரும் மின்னழுத்தத்தை எங்கள் வாசிப்பை 5 ஆல் பெருக்கி 1024 ஆல் வகுப்பதன் மூலம் மதிப்பீடு செய்ய முடியும்.
சென்சார் TMP36 0 டிகிரி செல்சியஸில் 0.5V ஐ உருவாக்க குறிப்பிடப்பட்டுள்ளது, பின்னர் டிகிரி செல்சியஸின் ஒவ்வொரு உயர்வுக்கும் 10mV ஐ உருவாக்குகிறது.
கணக்கீடுகளின் மூலம் நாம் உருவாக்கக்கூடிய தோராய மதிப்பீடு இங்கே:
சில மதிப்பைத் தரும் உங்கள் முதல் செயல்பாடாக நீங்கள் கருதலாம் (மீதமுள்ள அனைத்து செயல்பாடுகளும் அவை எந்த வகையிலும் இருந்ததால் எந்த மதிப்பையும் தரவில்லை என்பதை நினைவில் கொள்க வெற்றிடத்தை ).
ஒரு செயல்பாட்டிலிருந்து ஒரு மதிப்பைப் பெற, நீங்கள் சேர்க்க வேண்டும் என்பதை நீங்கள் புரிந்து கொள்ளலாம் திரும்ப நீங்கள் திரும்ப விரும்பும் விரும்பிய எண்ணைத் தொடர்ந்து.
நாங்கள் சொல்லும்போது திரும்ப இதன் பொருள், செயல்பாடு அழைக்கப்படும் போதெல்லாம் ஒரு பதிலை அல்லது பதிலை அளிக்கிறது, இது ஒரு மாறிக்கு பயன்படுத்தப்படலாம்.
இது சீரியல் மானிட்டருக்கு அனுப்பப்படும் போது, வாசிப்பு ஃபாரன்ஹீட்டிற்கு மாற்றப்படும் convertToF ().
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
இந்த செயல்பாடு செல்சியஸ் வரம்பை எடுத்து ஃபாரன்ஹீட்டாக மாற்றுகிறது.
பாரன்ஹீட்டை செல்சியஸாக மாற்றுவதற்கு நாங்கள் சூத்திரத்தை செயல்படுத்துகிறோம் பாரன்ஹீட் = 9 / 5 (செல்சியஸ்) + 32.
5.3 ஒரு எல்சிடியை இடைமுகப்படுத்துதல்
இப்போது ஒரு இடைமுகம் அல்லது எவ்வாறு இணைப்பது என்பதைப் படிப்போம் எல்சிடி காட்சி தேவையான வெளியீடுகளுக்கான காட்சி காட்சியைப் பெறுவதற்கு Arduino உடன்.
எங்கள் பயன்பாட்டில் 84x48 வரைகலை எல்சிடியைப் பயன்படுத்தப் போகிறோம், 84 பிக்சல் அல்லது புள்ளிகள் கிடைமட்டமாகவும், 48 பிக்சல்கள் செங்குத்து தீர்மானம் கொண்டதாகவும் இருக்கும். அனைத்து எல்.சி.டி களுக்கும் ஒரு பிரத்யேக கட்டுப்படுத்தி கட்டாயமாக இருப்பதால், தற்போதைய சாதனம் பி.சி.டி 8544 கட்டுப்படுத்தி வடிவத்திலும் ஒன்றை இணைக்கிறது.
இந்த டுடோரியலில், மேலே குறிப்பிட்ட எல்சிடி தொகுதியை அர்டுயினோவுடன் இணைப்போம், மேலும் காட்சியில் உரை செய்திகளை உருவாக்க சில நடைமுறைகளைப் பயன்படுத்துவோம்.
பின்வரும் படத்தில் எல்.சி.டியின் இடைமுகம் தொடர்பான விவரங்களையும், சிறியவற்றையும் காணலாம் 3.3 வி மின்னழுத்த சீராக்கி . எல்.சி.டி 3.3 வி விநியோகத்துடன் வேலை செய்ய குறிப்பிடப்பட்டுள்ளதால் இந்த சீராக்கி அவசியம்.
எல்சிடி தொகுதியிலிருந்து 8 பின்அவுட்களையும் நீங்கள் காணலாம், பின்அவுட் விவரக்குறிப்புகளை பின்வரும் அட்டவணையில் இருந்து படிக்கலாம்:
இப்போது எல்.சி.டி மற்றும் தொடர்புடைய அளவுருக்களை எங்கள் ஆர்டுயினோவுடன் எவ்வாறு இணைப்பது என்று பார்ப்போம். விவரங்களை கீழே காட்டப்பட்டுள்ள விளக்கத்தில் காணலாம்:
5.4 எல்சிடியுடன் தொடர்புகொள்வது
அர்டுயினோவிலிருந்து எல்.சி.டி.யுடன் தொடர்புகொள்வதற்கு விரிவான குறியீடுகளை எழுத முடியும் என்றாலும், நூலகங்களைப் பயன்படுத்தி இதை எப்படி செய்வது என்று கற்றுக்கொள்வோம்.
தேர்ந்தெடுக்கப்பட்ட Arduino நிரலுக்கு விரைவாகப் பயன்படுத்தக்கூடிய குறியீடுகளின் வகைப்படுத்தலை நூலகங்கள் கொண்டுள்ளது.
இது சிக்கலான குறியீட்டு வேலையைச் செய்யாமல் ஒரு செயல்பாட்டை சிரமமின்றி அழைக்க பயனருக்கு உதவுகிறது.
5.4.1 நூலகத்தை எவ்வாறு நிறுவுவது
இதற்காக நீங்கள் விளக்கமளித்தபடி, உங்கள் கணினி Arduino IDE இல் நூலகங்கள் எனப்படும் கோப்பகத்தை உருவாக்க வேண்டும் இங்கே
5.4.2 எல்சிடி செயல்பாடுகளை செயல்படுத்துதல்
எங்கள் முந்தைய அணுகுமுறையைப் போலவே, முதலில் முழு குறியீட்டையும் சரிபார்த்து, பின்னர் தனிப்பட்ட வரிகளின் விவரங்களைப் புரிந்துகொள்ள முயற்சிப்போம்.
#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())
}
வரியில் #include குறியீடு அடங்கும்
#Clude என்ற குறியீடு பி.சி.க்கு குறிப்பிடப்பட்ட கோப்பை எடுக்க அறிவுறுத்துகிறது மற்றும் நிரலை தொகுக்கும் போது # உள்ளடக்கு உறுப்பை கோப்பு உள்ளடக்கங்களுடன் மாற்றவும்.
# உள்ளடக்கு உறுப்பு நூலக அடைவில் தேடுவதைக் குறிக்கும் கோண அடைப்புகளைக் கொண்டிருக்கலாம், மாற்றாக இது நிரல் அமைந்துள்ள அதே கோப்பகத்தில் தேடுவதைக் குறிக்கும் மேற்கோள்களையும் கொண்டிருக்கலாம்.
குறியீட்டின் அடுத்தடுத்த கோடுகள் எல்சிடி பின்அவுட்களை வெளிப்படுத்துகின்றன, பின்னர் நாம் ஒரு புதிய வடிவ மாறியை எழுதுகிறோம்:
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
இங்கே நாம் எல்சிடி என்ற பெயருடன் பிசிடி 8544 வகையைக் கொண்ட ஒரு மாறியை வெளிப்படுத்துகிறோம், மேலும் ஆர்டுயினோவுடன் தொடர்புடைய அதன் பின்அவுட்களை மறுசீரமைக்க பிசிக்கு அறிவுறுத்துகிறோம்.
இந்த செயல்பாட்டில், முள் clk, din, dc, மற்றும் மீட்டமைத்தல் ஆகியவை Arduino உடன் எவ்வாறு இணைக்கப்படுகின்றன என்பதை அறிவுறுத்துவதன் மூலம் PC க்கு மாறியை விவரிக்கிறோம்.
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
வரி lcd.init() எல்சிடி செயல்பாட்டைத் துவக்குகிறது. இது செயல்படுத்தப்பட்டதும், அடுத்த வரி காட்சியின் மேல் இடதுபுறத்தில் கர்சரை செயல்படுத்துகிறது. அடுத்த அடுத்த வரி 'ஹலோ, வேர்ல்ட்' செய்தியை அச்சிட முயற்சிக்கிறது.
சீரியல் மானிட்டரில் செய்திகளை அனுப்பிய நுட்பத்துடன் இது மிகவும் ஒத்ததாக இருக்கிறது. lcd.print குறியீட்டின் பயன்பாடு மட்டுமே வித்தியாசம் serial.print க்கு பதிலாக.
குறியீட்டின் அடுத்த தொகுதி உண்மையில் மீண்டும் மீண்டும் அழைக்கப்படுகிறது.
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}
இந்த வரியைப் பயன்படுத்துதல் lcd.setCursor(0,1) எல்.சி.டி டிஸ்ப்ளே வழியாக, 1 வது வரிசையின் இடதுபுறத்தில் 0 வது நெடுவரிசைக்கு கர்சரை சரிசெய்கிறோம்.
அடுத்த வரி குறுக்குவழியைப் பயன்படுத்துகிறது: lcd.print(millis())
நீங்கள் நினைவு கூர்ந்தால் நாங்கள் millis() உடன் பணிபுரிந்தோம் எங்கள் முந்தைய குறியீடுகளில், குறியீடுகளின் மூலமும் இங்கேயே இதைப் பயன்படுத்தியிருக்கலாம்:
long numMillis = millis()
lcd.print(numMillis)
இருப்பினும், இங்கு மில்லி விநாடிகளில் எந்த நேரமும் ஈடுபடவில்லை என்பதால், millis() நேரடியாக lcd.print() .
5.5 முழு விஷயத்தையும் இணைத்தல்
சரி, இப்போது எல்சிடி வெப்பநிலை சுற்றுகளை உருவாக்குவதற்கு நாம் மேலே கற்றுக்கொண்ட அனைத்து குறியீடுகளையும் இணைப்போம், அது எப்படி இருக்கிறது என்று பார்ப்போம்:
#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
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
}
செயல்பாட்டின் பயன்பாட்டைத் தவிர, மேலே உள்ள நிரலில் அனைத்தும் நிலையானதாகத் தெரிகிறது setCursor () . காட்சியின் மையத்தைச் சுற்றி உரையை முடிந்தவரை சீரமைக்க இது பயன்படுத்தப்படுகிறது.
நன்று! வாழ்த்துக்கள், நீங்கள் உங்கள் சொந்த சிறிய எல்சிடி வெப்பநிலை குறிகாட்டியை Arduino ஐப் பயன்படுத்தி நிரல் செய்துள்ளீர்கள்.
நடைமுறை Arduino பயன்பாடுகள்
இந்த கட்டத்தில், பல்வேறு நிரலாக்க நுட்பங்களை நாங்கள் விரிவாக விவரித்துள்ளதால், ஒரு சில பயனுள்ள நடைமுறை செயலாக்கங்களுக்கு அவற்றைப் பயன்படுத்துவதன் மூலம் அவற்றைத் தெரிந்துகொள்ள வேண்டிய நேரம் இது.
சென்சார்களுடன் தொடங்குவோம், சில மாதிரி குறியீடுகளை இயக்குவதன் மூலம் சென்சார் சாதனங்களை அர்டுயினோவுடன் எவ்வாறு பயன்படுத்தலாம் என்பதைப் பார்ப்போம்.
7.1 சென்சார்கள் அறிமுகம்
இந்த டுடோரியலில் Arduino உடன் பயன்படுத்தக்கூடிய பல்வேறு வகையான சென்சார்கள் குறித்து அறிந்து கொள்வோம். லைட் சென்சார் எல்.டி.ஆர், காந்த ஹால் எஃபெக்ட் சென்சார், டில்ட் சென்சார்கள், வைப்ரேஷன் சென்சார், பிரஷர் சென்சார் போன்ற சாதனங்கள் இதில் இருக்கலாம்.
இன் இடைமுகத்துடன் தொடங்குவோம் ஒளி சென்சார் எல்.டி.ஆர் Arduino உடன், நான் பின்வரும் வரைபடத்தைக் காட்டியுள்ளேன்:
நாம் அனைவரும் அறிந்தபடி, எல்.டி.ஆர் என்பது ஒரு ஒளி சார்ந்த மின்தடைய சாதனம், அதன் எதிர்ப்பு அதன் மேற்பரப்பில் சுற்றுப்புற சம்பவத்தின் தீவிரத்தை சார்ந்துள்ளது.
ஒளியின் தீவிரம் எல்.டி.ஆரின் எதிர்ப்பு வாசிப்புக்கு நேர்மாறான விகிதாசாரமாகும்.
பயனுள்ள பயன்பாட்டை இயக்குவதற்கு இந்த சொத்தை Arduino உடன் எவ்வாறு ஒருங்கிணைக்க முடியும் என்பதை இங்கே கற்றுக்கொள்வோம்:
முழுமையான நிரல் குறியீட்டை கீழே கொடுக்கப்பட்டுள்ளபடி காட்சிப்படுத்தலாம்:
const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}
குறியீட்டில் பயன்படுத்தப்படும் அனைத்து அளவுருக்கள் ஏற்கனவே நாங்கள் கற்றுக்கொண்ட எங்கள் பாடத்திட்டத்தில் ஏற்கனவே விவாதிக்கப்பட்டுள்ளன. தொடர்புடைய பிரிவுகளைக் குறிப்பிடுவதன் மூலம் நீங்கள் வரிகளைச் சரிபார்க்கலாம்.
மதிப்புகள் தோராயமாக தேர்ந்தெடுக்கப்பட்டன, உங்கள் சொந்த விருப்பங்களின்படி நீங்கள் எளிதாக மாற்றலாம்.
டில்ட் சென்சார்
டில்ட் சென்சார் என்பது ஒரு எளிய சாதனமாகும், இது நிறுவப்பட்ட எந்தவொரு பொருளின் மீதும் ஒரு சாய்வு செயலைக் கண்டறிய பயன்படுகிறது. சாதனம் அடிப்படையில் ஒரு உலோக பந்தைக் கொண்டுள்ளது, இது ஒரு ஜோடி தொடர்புகளின் மீது சாய்வதில் அந்த தொடர்புகள் முழுவதும் ஒரு கடத்தலை ஏற்படுத்துகிறது. இந்த தொடர்புகள் சாய் சுவிட்சின் தடங்களாக நிறுத்தப்படுகின்றன, ஒரு சாய்வு நடவடிக்கை காரணமாக கடத்துதலைக் கண்டறிவதற்கும் விரும்பிய வெளியீட்டு பயன்பாட்டை செயல்படுத்துவதற்கும் வெளிப்புற சுற்றுடன் பயன்படுத்தப்படுகிறது.
இப்போது எப்படி என்று பார்ப்போம் டில்ட் சென்சார் சாதனம் கம்பி செய்யப்படலாம். முழுமையான உள்ளமைவு குறித்த ஒரு கருத்தை கீழே உள்ள படம் நமக்கு வழங்குகிறது:
const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}
இந்த எடுத்துக்காட்டில் இயல்புநிலை முள் # 13 எல்இடி சாய்வு குறிகாட்டியாக பயன்படுத்தப்படுகிறது.
பிரிவு 3.1 இல் நாங்கள் செய்ததைப் போலவே, இழுத்தல்-மின்தடையையும் இங்கே சேர்ப்பதை நீங்கள் தெளிவாகக் காணலாம். எனவே LOW என்ற சொல் சாய் செயல்பாடு தூண்டப்படவில்லை என்பதைக் குறிக்கிறது.
7.4 ரீட் ஸ்விட்ச் ரிலே (மினியேச்சர் காந்தம் செயல்படுத்தப்பட்ட ரிலே)
இப்போது ஆர்டுயினோவுடன் ரிலே சுவிட்ச் அல்லது காந்தப்புல சென்சாரை எவ்வாறு இணைப்பது என்று பார்ப்போம். ஒரு ரீட் ரிலே என்பது ஒரு வகையான சுவிட்ச் ஆகும், இது ஒரு காந்தப்புலம் அல்லது ஒரு காந்தத்தை அதன் அருகே கொண்டு வரும்போது செயல்படுத்துகிறது அல்லது நடத்துகிறது. அடிப்படையில் இது ஒரு மினியேச்சர் கண்ணாடி உறைக்குள் ஒரு ஜோடி ஃபெரோ காந்த தொடர்புகளைக் கொண்டுள்ளது, இது ஒரு காந்தம் அதன் அருகில் இருக்கும்போது காந்த இழுப்பு காரணமாக இணைகிறது அல்லது தொடர்பு கொள்கிறது. இது நிகழும்போது தொடர்புகளின் முனையங்கள் தொடர்புகளை மூடுவதால் கடத்துதலைக் காட்டுகின்றன.
இங்கேயும் பதிலைக் குறிக்க # 13 எல்.ஈ. எங்கள் முந்தைய விளக்கங்களின்படி தேவைப்பட்டால் இந்த முள் இருந்து வெளிப்புற எல்.ஈ.டி இணைக்கலாம்.
const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
குறியீடு சொற்கள் பழக்கமானதாகவும் சுய விளக்கமாகவும் இருக்க வேண்டும்.
7.5 பைசோ டிரான்ஸ்யூசரைப் பயன்படுத்தி அதிர்வு சென்சார்
அடுத்த மாதிரி நிரலில் எப்படி என்று பார்ப்போம் பைசோ டிரான்ஸ்யூசர் Arduino மூலம் எல்.ஈ.டி ஒளிர ஒரு அதிர்வு சென்சாராக பயன்படுத்தப்படலாம்.
பைசோ உறுப்பு உண்மையில் அதன் முனையங்களில் ஒரு அதிர்வெண் பயன்படுத்தப்படும்போது அதிர்வு அல்லது ஊசலாட்டத்தை உருவாக்கும் சாதனம் ஆகும். இருப்பினும் அதே பைசோவை தலைகீழ் செயல்பாட்டில் பயன்படுத்தலாம் மின் பருப்புகளை உருவாக்குகிறது அதன் உடலில் பயன்படுத்தப்படும் அதிர்வுக்கு பதில். இந்த அதிர்வு பைசோவின் மேற்பரப்பில் தட்டு அல்லது அடிக்கும் வடிவத்தில் இருக்கலாம்.
பின்வரும் படத்தில் கொடுக்கப்பட்டுள்ளபடி Arduino மற்றும் ஒரு பைசோ உறுப்பை அமைக்கவும்
const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}
த்ரெஷோல்ட் 100 அறிமுகப்படுத்தப்பட்டது, அர்டுயினோ உண்மையான அதிர்வுகளுக்கு நாக்ஸ் மூலம் மட்டுமே பதிலளிப்பதை உறுதிசெய்கிறது, மற்றும் உரத்த ஒலிகள் அல்லது கொம்புகள் போன்ற பிற சிறிய அதிர்வுகளுக்கு அல்ல.
A5 முள் தேர்வு கட்டாயமில்லை, உங்கள் விருப்பப்படி மற்றும் நிரல் குறியீட்டில் பொருத்துவதன் மூலம் வேறு எந்த அனலாக் உள்ளீடுகளையும் நீங்கள் தேர்ந்தெடுக்கலாம்.
Arduino உடன் சர்வோ மோட்டாரைப் பயன்படுத்துதல்
ஒரு சர்வோ மோட்டார் என்பது ஒரு வகை டிசி மோட்டார் ஆகும், இது ஒரு குறிப்பிட்ட பயன்பாட்டின் தேவைக்கேற்ப துல்லியமான கோணங்களில் சுழற்றப்படலாம். மோட்டரில் 180 டிகிரி வரம்பிற்குள் துல்லியமான சுழற்சி அல்லது திருப்பு கோணத்தை உருவாக்க மோட்டரின் தொடர்புடைய உள்ளீடுகளுக்கு கணக்கிடப்பட்ட கட்டளையைப் பயன்படுத்துவதன் மூலம் இதைச் செய்யலாம்.
பொதுவாக ஒரு சர்வோ மோட்டரில் 3 கம்பிகள் அல்லது உள்ளீடுகள் உள்ளன. நேர்மறை கம்பிகள் பொதுவாக சிவப்பு நிறத்தில் இருக்கும், எதிர்மறை அல்லது தரை கம்பி கருப்பு, இது கட்டளை கம்பி அல்லது சமிக்ஞை கம்பி பொதுவாக வெள்ளை அல்லது மஞ்சள் நிறத்தில் இருக்கும்.
ஆதரவு மொழியில் கட்டமைக்கப்பட்டதன் மூலம் சர்வோ மோட்டார் கட்டுப்பாட்டை அர்டுயினோ எளிதாக்குகிறது, இது சர்வோ மோட்டர்களுக்கு மிகவும் வசதியானதாகவும் சிறந்ததாகவும் இருக்கும்.
Arduino மூலம் சர்வோ மோட்டார் கட்டுப்பாட்டை செயல்படுத்துவதற்கான அடிப்படை அமைவு திட்டத்தை பின்வரும் எடுத்துக்காட்டு நமக்குக் காண்பிக்கும்:
குறியீடு கீழே கொடுக்கப்பட்டுள்ளது:
#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}
ஓரிரு புதிய உள்ளீடுகளை இங்கே காணலாம். சேவையின் இணைக்கப்பட்ட கம்பியை அது எந்த முள் ஒதுக்கியுள்ளது என்று சொல்லும் ஒன்று. மற்றொன்று சேவையகத்தின் சுழற்சியின் கோணத்தை தீர்மானிக்க முள் 0 மற்றும் 180 க்கு இடையில் ஒரு மதிப்பை வழங்கும் குறியீடாகும்.
முடிவுரை
Arduino பொருள் எல்லையற்றதாக இருக்கலாம், எனவே இந்த கட்டுரையின் எல்லைக்கு அப்பாற்பட்டது. எவ்வாறாயினும், மேலேயுள்ள பயிற்சி நிச்சயமாக அர்டுயினோவின் அடிப்படைகளை அறிய உங்களுக்கு உதவியிருக்க வேண்டும் என்று நம்புகிறேன், மேலும் பல்வேறு எடுத்துக்காட்டு பயன்பாட்டுக் குறியீடுகளின் மூலம் முக்கியமான அளவுருக்களைப் புரிந்து கொள்ளுங்கள்.
கிடைக்கும்போதெல்லாம் அவ்வப்போது கூடுதல் தகவல்கள் இங்கு புதுப்பிக்கப்படலாம் என்று நம்புகிறோம்.
இதற்கிடையில் உங்கள் நிரலாக்க பாடத்திட்டத்தை அனுபவிக்கவும், உங்களுக்கு வாழ்த்துக்கள் !!
முந்தைய: MQ-3 சென்சார் தொகுதியைப் பயன்படுத்தி ஆல்கஹால் டிடெக்டர் மீட்டர் சர்க்யூட் அடுத்து: செல்போன் கட்டுப்படுத்தப்பட்ட நாய் ஊட்டி சுற்று
