Pushbutton៖ របៀបប្រើធាតុសាមញ្ញនេះជាមួយ Arduino

Un ប៊ូតុងរុញគឺជាប៊ូតុងដែលអនុញ្ញាតឱ្យអ្នករំខានឬបញ្ជូនសញ្ញាអេឡិចត្រូនិក។ ជាមួយនឹងធាតុដ៏សាមញ្ញនេះរួមផ្សំជាមួយធាតុផ្សេងទៀតអ្នកអាចបង្កើតគំរោងសំរាប់កម្មវិធីជាច្រើន។ ការប្រើបា្រស់ប្រូស្តាតប្រភេទនេះគឺជារឿងធម្មតាណាស់នៅពេលនិយាយដល់គម្រោងជាមួយអាឌូណូ។ ហើយដោយការរួមបញ្ចូលគ្នានូវប៊ូតុងទាំងនេះជាច្រើនអ្នកអាចបង្កើតក្តារចុចដែលស្មុគស្មាញជាងនេះបើទោះបីជាមានក្តារចុចដែលអាចដំណើរការបានសម្រាប់ការប្រើប្រាស់ទាំងនេះក៏ដោយ។

ដោយវិធីនេះ, អ្នកមិនគួរច្រឡំប៊ូតុងរុញជាមួយកុងតាក់ទេ។ ពួកវាជារឿងខុសគ្នាទាំងស្រុង។ ភាពខុសគ្នាគឺថាកុងតាក់ឬកុងតាក់ត្រូវបានធ្វើឱ្យសកម្មឬអសកម្មជាមួយសារព័ត៌មាននីមួយៗដែលត្រូវបានបង្កើតឡើងនៅលើវា។ ចំណែកឯប៊ូតុងរុញនឹងស្ថិតក្នុងស្ថានភាពតែមួយខណៈពេលដែលសម្ពាធកំពុងដាក់លើវា។ ខ្ញុំបានអត្ថាធិប្បាយថាវាអាចផ្ញើឬរំខាននោះគឺដោយសារតែមានប៊ូតុងមូលដ្ឋានពីរប្រភេទ។

មាន ទេឬជាធម្មតាប៊ូតុងរុញនិងអិន។ ស៊ី។ រឺបិទជាធម្មតា។ នេះក៏នឹងស្តាប់ទៅអ្នកពីការបញ្ជូនតផងដែរ។ មែនហើយវាពិតជាប្រតិបត្តិការដូចគ្នា។ នៅពេលអ្នកមាន NC វានឹងអនុញ្ញាតឱ្យចរន្តឆ្លងកាត់ស្ថានីយរបស់វាហើយវាគ្រាន់តែរំខាននៅពេលអ្នកកំពុងចុចវា។ ម៉្យាងទៀតរដ្ឋសភាមិនអនុញ្ញាតឱ្យឆ្លងកាត់ចរន្តនៅពេលសម្ពាធមិនត្រូវបានដាក់លើវាហើយនឹងអនុញ្ញាតឱ្យឆ្លងកាត់នៅពេលអ្នកចុចវា។

ដោយ​ដឹង​ថា, គឺស្ទើរតែអ្វីៗទាំងអស់ដែលអ្នកត្រូវដឹងអំពីប៊ូតុងរុញ ដើម្បីចាប់ផ្តើមការតភ្ជាប់និងការសរសេរកម្មវិធីរបស់អ្នកដោយប្រើ Arduino ។ ការពិតគឺថាវាគឺជាធាតុដ៏សាមញ្ញមួយដែលមិនមានអ្វីច្រើនទេដែលត្រូវនិយាយអំពីប្រភេទនៃការរុញច្រាននេះ។

ការរួមបញ្ចូលប៊ូតុងរុញជាមួយអារីដូណូ

La ភ្ជាប់ប៊ូតុងរុញ ដើម្បីធ្វើឱ្យវាធ្វើអន្តរកម្មជាមួយ Arduino មិនអាចងាយស្រួលទេ។ ឧទាហរណ៍មួយគឺដ្យាក្រាមដែលអ្នកអាចមើលឃើញនៅលើបន្ទាត់ទាំងនេះ។ វាចាំបាច់ត្រូវចាប់ផ្តើមធ្វើពិសោធន៍។ ប៉ុន្តែជាការពិតជាមួយនឹងគ្រោងការណ៍នោះអ្នកអាចធ្វើបានតិចតួច។ វាចាំបាច់សម្រាប់អ្នកដើម្បីដាក់ការស្រមើលស្រមៃបន្តិចបន្តួចដើម្បីសម្រេចចិត្តថាតើប៊ូតុងនោះនឹងគ្រប់គ្រងអ្វី។ តាមពិតប្រសិនបើអ្នកអាន hwlibre.es ញឹកញាប់អ្នកនឹងបានឃើញអត្ថបទមួយចំនួនដែលយើងបានប្រើប៊ូតុងរុញ ...

វិធីភ្ជាប់វា

រឿងមួយដែលអ្នកគួរតែដឹងគឺបញ្ហាប្រឆាំងនឹងការលោតនិង របៀបភ្ជាប់បូតុងទាំងនេះ។ ដំបូងយើងទៅរកវិធីភ្ជាប់ពួកវាដែលអ្នកដឹងរួចហើយអាចនៅជាមួយឧបករណ៍ទាញនិងទាញចុះក្រោម៖

• ទាញ​ឡើង- ជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធធន់ទ្រាំនេះនៅពេលដែលប៊ូតុងរុញត្រូវបានចុច microcontroller ឬ Arduino អាចមើលឃើញរឺអានសូន្យនៅលើម្ជុលនោះ នោះគឺវាបកស្រាយវាជាសញ្ញាទាប។
• ទាញ​ទម្លាក់៖ ក្នុងករណីនេះវាផ្ទុយពីនេះអ្នកអាចអានឬទទួលសញ្ញា 1 ឬ HIGH តាមរយៈខ្សែភ្ជាប់។

កុំច្រឡំវាជាមួយគ។ ជ។ អ។ ឬអិន។ ដែលជាអ្វីដែលខុសពីអ្វីដែលយើងបានឃើញពីមុន។ នេះគឺឯករាជ្យនៃផ្សេងទៀត ...

ប្រឆាំងនឹងលោត

ប៊ូតុងរុញមាន ផលប៉ះពាល់ងើបឡើងវិញ នៅពេលចុច។ នោះគឺនៅពេលដែលវាត្រូវបានគេចុចឬបញ្ចេញវាមានភាពប្រែប្រួលនៃសញ្ញាដែលឆ្លងកាត់ទំនាក់ទំនងរបស់វាហើយអាចបណ្តាលឱ្យវាចេញពីរដ្ឋ HIGT ទៅ LOW ឬផ្ទុយមកវិញដោយមិនចង់អោយវាកើតឡើង។ ដែលអាចបង្កើតផលដែលមិនចង់បាននៅលើ Arduino និងធ្វើឱ្យវាធ្វើរឿងចម្លែកដូចជាធ្វើឱ្យធាតុសកម្មនៅពេលយើងពិតជាចង់បិទវាដោយប្រើប៊ូតុងរុញ។ ល។ នោះក៏ព្រោះតែអាឌូរីណូបកស្រាយសំលេងលោតផ្លេកៗហាក់ដូចជាវាត្រូវបានគេសង្កត់ច្រើនជាងម្តង ...

ផលប៉ះពាល់អវិជ្ជមាននោះ វាមានដំណោះស្រាយ។ ចំពោះបញ្ហានេះឧបករណ៍ចាប់ថាមពលតូចមួយត្រូវតែត្រូវបានអនុវត្តនៅក្នុងសៀគ្វីប្រឆាំងការលោត (វិធីសាស្ត្រផ្នែករឹង) ឬសូហ្វវែរ (កែប្រែកូដប្រភព) ថាតើការកំណត់រចនាសម្ព័ន្ធទាញឬទាញចុះក្រោមត្រូវបានប្រើឬប្រសិនបើវាជា NC ឬទេ។ ក្នុងករណីទាំងអស់ដំណោះស្រាយត្រូវតែត្រូវបានអនុវត្តដើម្បីជៀសវាងការស្ទុះងើបឡើងវិញទាំងនេះ។

ឧទាហរណ៍សៀគ្វីទាញនិងទាញចុះក្រោមជាមួយ capacitor ប្រឆាំងនឹងលោត ពួកគេនឹងមើលទៅដូចនេះ:

ខណៈពេលដែល វិធីសាស្ត្រសូហ្វវែរ វាអាចត្រូវបានគេមើលឃើញក្នុងលេខកូដកូដនេះ៖

if (digitalRead (ប៊ូតុង) == ទាប) // ពិនិត្យមើលថាតើប៊ូតុងត្រូវបានចុចដែរឬទេ
{
ចុច = 1; // តម្លៃផ្លាស់ប្តូរអថេរ
}
ប្រសិនបើ (digitalRead (ប៊ូតុង) == ខ្ពស់ && ចុច == 1)
{
// អនុវត្តសកម្មភាពដែលចង់បាន
ចុច = 0; // អថេរត្រឡប់ទៅតម្លៃដើមរបស់វា
}

ឧទាហរណ៍គម្រោងសាមញ្ញ

នៅពេលដែលយើងបានរៀនប្រធានបទនៃវិធីដើម្បីតភ្ជាប់ប៊ូតុងរុញនិងសៀគ្វីប្រឆាំងនឹងការស្ទុះងើបឡើងវិញយើងនឹងឃើញឧទាហរណ៍ជាក់ស្តែងមួយដើម្បី គ្រប់គ្រងអំពូល LED ជាមួយប៊ូតុងរុញ។ គ្រោងការណ៍គឺសាមញ្ញស្មើគ្នាដូចដែលអ្នកបានឃើញ។

នៅពេលភ្ជាប់ត្រឹមត្រូវហើយរឿងបន្ទាប់គឺសរសេរ លេខកូដនៅ Arduino IDE ដើម្បីបង្កើតបន្ទះរបស់អ្នកហើយចាប់ផ្តើមពិសោធជាមួយប៊ូតុង។ ឧទាហរណ៏កូដសាមញ្ញមួយដើម្បីគ្រប់គ្រងសៀគ្វីរបស់យើងនឹងមានដូចខាងក្រោមៈ

// ឧទាហរណ៍នៃការបង្ហាញប្រភេទរូបភាពដើម្បីបញ្ជាប៊ូតុង
ម្ជុល int = 2;
រដ្ឋ int;
pulsating int = 0;
ការចាត់ទុកជាមោឃៈ ()

{
pinMode (2, INPUT); // ដើម្បីអានជីពចរដោយបញ្ចូលម្ជុលនោះ

pinMode (13, OUTPUT); // សម្រាប់អំពូល LED

Serial.begin (៩៦០០);
}
ចន្លោះប្រហោង ()

{
ប្រសិនបើ (digitalRead (២) == ខ្ពស់)

{

ម្ជុល = 2;

antiBounce (); // ហៅទៅមុខងារប្រឆាំងនឹងលោត

}
}
// មុខងារប្រឆាំងនឹងលោតផ្នែកទន់
ចាត់ទុកជាមោឃៈប្រឆាំងការលោត ()

{
ខណៈពេល (digitalRead (pin) == ទាប);
state = digitalRead (១៣);
digitalWrite (១៣, រដ្ឋ);
ខណៈពេល (digitalRead (pin) == HIGH);

}