แผนภาพปุ่มชั้นเชิง การเชื่อมต่อปุ่มกับ Arduino การสลับโหมดโดยใช้ปุ่ม

ปุ่มเป็นอุปกรณ์กลไกที่รู้จักกันดีซึ่งสามารถปิดและเปิดได้ วงจรไฟฟ้าตามคำขอของบุคคล มีปุ่มหลายประเภทที่ทำงานตามกฎเกณฑ์ที่แตกต่างกัน ตัวอย่างเช่น ปุ่มกดที่ใช้ในบทช่วยสอนนี้จะทำให้วงจรสมบูรณ์ตราบใดที่นิ้วของคุณกดลงไป ในทางกลับกัน ปุ่มเปิดจะตัดวงจรเมื่อกด

มีปุ่มที่มีกลุ่มหน้าสัมผัสซึ่งบางปุ่มจะตัดวงจรเมื่อกดในขณะที่บางปุ่มจะปิดในเวลานี้ ปุ่มเหล่านี้รุ่นเล็กมักเรียกว่าไมโครสวิตช์

ปุ่มชั้นเชิงสามารถพบได้ในเกือบทุก อุปกรณ์อิเล็กทรอนิกส์: ในแป้นพิมพ์คอมพิวเตอร์ ในโทรศัพท์ ในรีโมทคอนโทรลของทีวี ฯลฯ

มีปุ่มล็อคที่ทำงานเหมือนปุ่มบนปากกาลูกลื่น: กดหนึ่งครั้ง - วงจรปิด ครั้งที่สอง - มันจะพัง รูปภาพด้านล่างเป็นเพียงหนึ่งในนั้น ปุ่มล็อคใช้สลับโหมดการทำงานของเครื่องได้สะดวก ตัวอย่างเช่น คุณสามารถสลับแหล่งพลังงาน: แบตเตอรี่หรือแหล่งจ่ายไฟ

หรือทางเลือกอื่น - ปุ่มขนาดใหญ่สำหรับการหยุดอุปกรณ์ฉุกเฉิน พวกเขาทาสีด้วยสีสันสดใสเพื่อดึงดูดความสนใจของผู้คน โดยพื้นฐานแล้วมันเป็นปุ่มชั้นเชิงธรรมดาสำหรับเปิดหรือปุ่มที่มีการล็อค

นี่เป็นเพียงตัวเลือกบางส่วนเท่านั้น นอกจากปุ่มต่างๆ แล้ว ในโลกของไฟฟ้ายังมีกลไกอื่นๆ อีก เช่น สวิตช์สลับและสวิตช์ ทั้งหมดนี้ได้รับการออกแบบมาเพื่อควบคุมการไหลของกระแสไฟฟ้าในวงจรด้วยกลไก

การเชื่อมต่อปุ่ม

ดังนั้นเราจะใช้งานปุ่มชั้นเชิงที่ง่ายที่สุดซึ่งเราจะพยายามเชื่อมต่อด้วย อาร์ดูโน่ อูโน่- โดยทั่วไปเมื่อทำงานกับเขียงหั่นขนมแบบไร้บัดกรีจะใช้ปุ่มที่มีหมุดบัดกรี ในภาพตอนต้นบทเรียนคุณจะเห็นว่าปุ่มดังกล่าวมีหมุดสี่อันงอเล็กน้อย มีปุ่มที่มีเอาต์พุตโดยตรง 2 ช่องซึ่งเหมาะสำหรับกิจกรรมของเราด้วย

บน ไดอะแกรมไฟฟ้าปุ่มมีลักษณะดังนี้:

หากคุณดูภายในปุ่มสี่จังหวะ คุณจะเห็นแผนภาพนี้:

ตามกฎแล้ว หมุดของปุ่มชั้นเชิงจะถูกวางไว้ที่ด้านตรงข้ามของเคสเป็นคู่ นั่นคือเราสามารถใช้หน้าสัมผัสคู่หนึ่งหรืออีกคู่ก็ได้

และนี่คือลักษณะของปุ่มสองพิน

ยากที่จะสับสนกับปุ่มนี้: ผู้ติดต่อสองคนที่เชื่อมต่อเมื่อคุณกดปุ่ม

บนเขียงหั่นขนม ปุ่มสัมผัสทั้งสองประเภทมักจะวางดังนี้:

ทีนี้มาลองประกอบวงจรที่ง่ายที่สุดบนเขียงหั่นขนมไร้บัดกรีที่จะสาธิตการทำงานของปุ่ม เราจะเปิดไฟ LED

วงจรผลลัพธ์จะทำหน้าที่ง่าย ๆ: กดปุ่ม - ไฟ LED สว่างขึ้น, ปล่อยมัน - มันจะดับ

การเชื่อมต่อกับ อาร์ดูโน่ อูโน่

ตอนนี้ฟังก์ชั่นของปุ่มแทคชัดเจนแล้ว เรามาประกอบวงจรด้วยปุ่มและไฟ LED แล้วเชื่อมต่อกับคอนโทรลเลอร์กันดีกว่า มาเริ่มงานง่ายๆ กันดีกว่า: ปล่อยให้ Arduino Uno LED กระพริบสามครั้งเมื่อคุณกดปุ่ม Arduino Uno หนึ่งครั้ง

แผนผัง

รูปร่างเค้าโครง

ในแผนภาพนี้เราจะเห็นวงจรที่คุ้นเคยอยู่แล้ว เรายังเห็นปุ่มเชื่อมต่อกับ Arduino pin หมายเลข 3 คำถามนี้อาจเกิดขึ้นได้อย่างสมเหตุสมผล: เหตุใดเราจึงเชื่อมต่อปุ่มกับกราวด์ผ่านตัวต้านทาน 10 kOhm ด้วย เพื่อจัดการกับปัญหานี้ ลองจินตนาการว่าเราเชื่อมต่อปุ่มโดยใช้วงจร "ไร้เดียงสา" โดยไม่มีตัวต้านทานเพิ่มเติม

ระหว่างพินหมายเลข 3 กับกราวด์จะมีตัวเก็บประจุขนาดเล็กที่สามารถสะสมประจุได้ ไมโครคอนโทรลเลอร์หลายตัวมีคุณสมบัตินี้

ทีนี้ลองจินตนาการว่าเรากำลังปิดปุ่ม กระแสไฟเริ่มทำงานจาก +5V ตรงไปหน้าสัมผัสเบอร์ 3 ชาร์จความจุพร้อมกัน Arduino ลงทะเบียนการกดปุ่มได้สำเร็จ แต่หลังจากที่เราเอานิ้วออกจากปุ่มนาฬิกา ซึ่งขัดกับความคาดหวังของเรา ไมโครคอนโทรลเลอร์ยังคงพิจารณาว่ามีการกดปุ่มนั้น! แน่นอนว่าเนื่องจากตัวเก็บประจุที่มีประจุจะค่อยๆ ปล่อยประจุสะสมไปที่ขาหมายเลข 3 สิ่งนี้จะดำเนินต่อไปจนกว่าความจุจะคายประจุต่ำกว่าตรรกะหนึ่งระดับ

การเชื่อมต่อโมดูลปุ่มนาฬิกา ROC เข้ากับ Arduino

โดยเฉพาะอย่างยิ่งสำหรับโครงการของคุณ พวกเราที่ RobotClass ได้สร้างโมดูลที่มีปุ่มสัมผัสสองปุ่ม โมดูลมีตัวต้านทานที่จำเป็นอยู่แล้วและมีไฟ LED สองตัวเพื่อระบุการกดปุ่ม

มาดูวิธีเชื่อมต่อโมดูลนี้กับ Arduino Uno

แผนผัง

ลักษณะเค้าโครง

อย่างที่คุณเห็นไม่ว่าเราจะใช้ปุ่มใดก็ตาม แผนภาพการเชื่อมต่อจะไม่เปลี่ยนแปลงมากนัก โปรแกรมสำหรับการทำงานร่วมกับพวกเขาจะไม่เปลี่ยนแปลงเช่นกัน

โปรแกรมการทำงานด้วยปุ่มบน Arduino

ในที่สุด เราก็ได้ทราบถึงความแตกต่างของโครงร่างของเราแล้ว และพร้อมที่จะเขียนโปรแกรมแล้ว ในบทช่วยสอนซอฟต์แวร์ เราได้เรียนรู้เกี่ยวกับฟังก์ชันการกำหนดค่าพิน พินโหมดและฟังก์ชั่นเอาต์พุตดิจิตอล ดิจิทัลเขียน- คราวนี้เราต้องการฟังก์ชันที่สำคัญอีกหนึ่งฟังก์ชันที่ให้ข้อมูลเข้ากับไมโครคอนโทรลเลอร์:

DigitalRead(หมายเลขติดต่อ);

ฟังก์ชันนี้ส่งคืนค่าบูลีนที่ Arduino อ่านจากพินที่กำหนด ซึ่งหมายความว่าหากใช้ +5V กับหน้าสัมผัส ฟังก์ชันจะกลับมา ความจริง*- หากหน้าสัมผัสเชื่อมต่อกับกราวด์เราจะได้ค่า โกหก- ในภาษา C++ จริงและเท็จเทียบเท่ากับตัวเลข 1 และ 0 ตามลำดับ

เพื่อให้ผู้ติดต่อที่เราสนใจทำงานในโหมดป้อนข้อมูลเราจะต้องตั้งค่าเป็นโหมดเฉพาะ:

PinMode(pin_number, อินพุต);

สุดท้ายเรามารวบรวมทุกอย่างเข้าด้วยกันแล้วเขียนโปรแกรม

Const int นำ = 2;
ปุ่ม const int = 3;
ค่า int = 0;

การตั้งค่าเป็นโมฆะ())(
pinMode (นำ, เอาต์พุต);
pinMode(ปุ่ม, อินพุต);
}

เป็นโมฆะวน()
val = digitalRead (ปุ่ม);
ถ้า(val == สูง)(
// วนซ้ำจาก 0 ถึง 2 ในขั้นตอนที่ 1
สำหรับ(int i=0; i<3; i++){
digitalWrite (นำ, สูง);
ล่าช้า (500);
digitalWrite (นำ, ต่ำ);
ล่าช้า (500);
}
}
}

เราโหลดโปรแกรมลงบน Arduino Uno และตรวจสอบการทำงานของโปรแกรม หากทุกอย่างถูกต้องควรมีลักษณะดังนี้:

นั่นคือทั้งหมดที่ ตอนนี้เราสามารถควบคุมอุปกรณ์ของเราโดยใช้ปุ่มต่างๆ หากเรียนจบบทเรียนแล้วเราจะสามารถทำนาฬิกาปลุกได้!

โปรแกรมปุ่มทริกเกอร์

อีกตัวอย่างที่น่าสังเกตคือปุ่มทริกเกอร์ มันทำงานดังนี้: กดปุ่มหนึ่งครั้ง - ไฟ LED จะสว่างขึ้น, กดอีกครั้ง - มันจะดับลง

หากต้องการใช้ลักษณะการทำงานของปุ่มนี้ เราจำเป็นต้องมีตัวแปรเพิ่มเติม ซึ่งมักเรียกว่า "ตัวแปรสถานะ" หรือ "แฟล็ก"

Const int นำ = 2;
ปุ่ม const int = 3;
ค่า int = 0;
สถานะไบต์ = 0; // ตัวแปรสถานะ
การตั้งค่าเป็นโมฆะ())(
pinMode (นำ, เอาต์พุต);
pinMode(ปุ่ม, อินพุต);
}
เป็นโมฆะวน()
// เขียนสถานะปุ่มให้กับตัวแปร val
val = digitalRead (ปุ่ม);
// หากสถานะของปุ่มเป็นจริง ให้ดำเนินการ
ถ้า(val == สูง)(
// เปลี่ยนสถานะเป็นตรงกันข้าม
รัฐ = !รัฐ;
ถ้า (สถานะ == สูง)(
// หากสถานะปัจจุบันเป็นจริง ให้เปิดไฟ LED
digitalWrite (นำ, สูง);
) อื่น (
// หากสถานะปัจจุบันเป็นเท็จ ให้ปิด LED
digitalWrite (นำ, ต่ำ);
}
ล่าช้า (300);
}
}

เราโหลดโปรแกรมลงบน Arduino และตรวจสอบการทำงานของวงจร กดปุ่มอย่างรวดเร็วและไฟ LED จะสว่างขึ้น กดอีกครั้งก็จะดับลง แต่ถ้าคุณกดปุ่มแล้วไม่ปล่อย ไฟ LED จะเริ่มกระพริบเป็นระยะเวลา 600ms! ทำไมจึงเป็นเช่นนี้? ลองคิดดูสิ

เควส

ตามแนวทางปฏิบัติ เรามาลองแก้ไขปัญหาง่ายๆ สองสามข้อด้วยปุ่มและไฟ LED

• วงจรประกอบด้วยปุ่มสองปุ่มและไฟ LED หนึ่งดวง ปล่อยให้ไฟ LED สว่างขึ้นเมื่อคุณกดปุ่มแรก และดับลงเมื่อคุณกดปุ่มที่สอง
• เปียโน. วงจรประกอบด้วยปุ่มเจ็ดปุ่มและลำโพงหนึ่งตัว เมื่อคุณกดปุ่มทั้งเจ็ดปุ่มแต่ละปุ่ม ลำโพงควรเล่นโน้ตที่เกี่ยวข้อง จะต้องศึกษา.
• เกม "คาวบอย" วงจรประกอบด้วยปุ่มสองปุ่ม เสียงกริ่งหนึ่งอัน และไฟ LED สองดวง หลังจากที่โปรแกรมเริ่มทำงาน เสียงกริ่งควรจะส่งเสียงสั้นๆ หลังจากนี้ ผู้เล่นแต่ละคนจะต้องกดปุ่มให้เร็วที่สุด ผู้เล่นที่ทำสิ่งนี้ก่อนจะมีไฟ LED คุณจะต้องศึกษาบทเรียนเกี่ยวกับการหยุดชะงัก

การเชื่อมต่อเซ็นเซอร์ปุ่มกับ Arduino ต้องใช้ความรู้และทักษะบางอย่าง ในบทความนี้เราจะพูดถึงว่าปุ่มชั้นเชิงคืออะไร ปุ่มเด้งคืออะไร วิธีเชื่อมต่อปุ่มกับตัวต้านทานแบบดึงขึ้นและดึงลงอย่างถูกต้อง คุณจะควบคุม LED และอุปกรณ์อื่น ๆ โดยใช้ปุ่มได้อย่างไร

ปุ่ม (หรือสวิตช์ปุ่มกด) เป็นเซ็นเซอร์ทุกประเภทที่ง่ายและเข้าถึงได้มากที่สุด เมื่อคลิกที่มัน คุณจะส่งสัญญาณไปยังคอนโทรลเลอร์ซึ่งจะนำไปสู่การกระทำบางอย่าง: ไฟ LED ติดขึ้น, มีเสียงเกิดขึ้น, มอเตอร์สตาร์ท ในชีวิตของเรา เรามักจะเจอสวิตช์ต่างๆ และคุ้นเคยกับอุปกรณ์นี้เป็นอย่างดี

ปุ่มชั้นเชิงและปุ่มสวิตช์

ตามปกติแล้ว เราจะเริ่มหัวข้อนี้ด้วยสิ่งง่ายๆ ที่น่าสนใจสำหรับผู้เริ่มต้นเท่านั้น หากคุณรู้พื้นฐานและต้องการเรียนรู้เกี่ยวกับตัวเลือกต่างๆ ในการเชื่อมต่อปุ่มเข้ากับ Arduino คุณสามารถข้ามย่อหน้านี้ได้

ปุ่มคืออะไร? โดยพื้นฐานแล้วนี่เป็นอุปกรณ์ที่ค่อนข้างง่ายที่จะปิดและเปิดเครือข่ายไฟฟ้า คุณสามารถดำเนินการปิด/เปิดนี้ในโหมดต่างๆ ได้ ในขณะที่แก้ไขหรือไม่แก้ไขตำแหน่งของคุณ ดังนั้นปุ่มทั้งหมดจึงสามารถแบ่งออกเป็นสองกลุ่มใหญ่ได้:

• สลับปุ่มด้วยการตรึง พวกเขากลับคืนสู่สภาพเดิมหลังจากได้รับการปล่อยตัว เมื่อใดขึ้นอยู่กับสถานะเริ่มต้นพวกเขาจะแบ่งออกเป็นปุ่มปิดปกติและเปิดตามปกติ
• ปุ่มชั่วขณะ (ปุ่มชั้นเชิง) พวกเขาได้รับการแก้ไขและยังคงอยู่ในตำแหน่งที่พวกเขาถูกทิ้งไว้

มีตัวเลือกมากมายสำหรับปุ่มต่างๆ นี่เป็นหนึ่งในชิ้นส่วนอิเล็กทรอนิกส์ที่พบบ่อยที่สุดอย่างแท้จริง

ปุ่ม Arduino สำหรับโครงการง่ายๆ

ในโครงการของเรา เราจะใช้งานปุ่มนาฬิกา 4 ขาที่เรียบง่ายซึ่งมาพร้อมกับชุด Arduino เกือบทุกรุ่น ปุ่มนี้เป็นสวิตช์ที่มีหน้าสัมผัสสองคู่ หน้าสัมผัสในคู่เดียวเชื่อมต่อถึงกันดังนั้นจึงไม่สามารถใช้สวิตช์มากกว่าหนึ่งตัวในวงจรได้ แต่คุณสามารถควบคุมส่วนขนานสองส่วนพร้อมกันได้ซึ่งจะมีประโยชน์

คุณสามารถสร้างทั้งสองวงจรด้วยหน้าสัมผัสแบบปกติปิดและแบบเปิดตามปกติ ทั้งนี้ขึ้นอยู่กับสถานการณ์ สิ่งที่คุณต้องทำคือทำการเชื่อมต่อในวงจรตามนั้น

เพื่อความสะดวกในการใช้งาน ปุ่มสัมผัสมักจะมาพร้อมกับฝาพลาสติกบางสี โดยจะพอดีกับปุ่มอย่างเห็นได้ชัด และทำให้โปรเจ็กต์ดูคล้ายกับแฮ็กเกอร์น้อยลง

การเชื่อมต่อปุ่ม Arduino

การเปิดและปิด LED โดยใช้ปุ่ม

เริ่มจากวิธีที่ง่ายที่สุดในการเชื่อมต่อปุ่มชั้นเชิง พิจารณาวงจรที่มี Arduino เป็นแหล่งพลังงาน, LED, ตัวต้านทานจำกัด 220 โอห์ม และปุ่มที่จะปิดและเปิดวงจร

เมื่อเชื่อมต่อปุ่มด้วยขาสองคู่ สิ่งสำคัญคือต้องเลือกหน้าสัมผัส NC ที่ถูกต้อง ดูภาพอย่างระมัดระวัง: ขาคู่หนึ่งอยู่ที่ด้านข้างของปุ่ม ตัวปุ่มเป็นรูปสี่เหลี่ยมจัตุรัส แต่ระยะห่างระหว่างผู้ติดต่อคู่นั้นมองเห็นได้ชัดเจน: คุณสามารถเลือกสองอันที่ด้านหนึ่งและอีกสองอันได้ทันที ดังนั้นจึงอยู่ระหว่าง "คู่" หนึ่งคู่ที่ด้านข้างซึ่งสวิตช์จะถูกนำมาใช้ เพื่อรวมไว้ในวงจรเราจะเชื่อมต่อกับหน้าสัมผัสหนึ่งและอีกหน้าหนึ่งซึ่งมีระยะห่างขั้นต่ำ ผู้ติดต่อคู่ที่สองจะทำซ้ำผู้ติดต่อคู่แรก

หากคุณมีสวิตช์ประเภทอื่น คุณสามารถเลือกผู้ติดต่อจากมุมตรงข้ามได้อย่างปลอดภัย (ในบางปุ่มจะมีเครื่องหมายพิเศษในรูปแบบของช่องซึ่งคุณสามารถกำหนดได้ว่าผู้ติดต่อที่จับคู่นั้นอยู่ที่ด้านใด) วิธีที่น่าเชื่อถือที่สุดในการกำหนดขาที่ถูกต้องคือให้ผู้ทดสอบโทรหาหน้าสัมผัส

วงจรที่มีปุ่ม, LED และตัวควบคุม Arduino ไม่ต้องการคำอธิบายพิเศษใดๆ ปุ่มตัดวงจร, LED ไม่ติด เมื่อกดแล้ววงจรจะปิดและไฟ LED จะเปิดขึ้น หากคุณผสมหน้าสัมผัส (เปิดปุ่มผ่านหน้าสัมผัสที่จับคู่แบบปิด) ปุ่มจะไม่ทำงานเนื่องจากวงจรจะไม่เปิด เพียงสลับผู้ติดต่อ

การเชื่อมต่อปุ่มด้วยตัวต้านทานแบบดึงขึ้น

ตอนนี้เรามาเชื่อมต่อปุ่มกับ Arduino เพื่อให้เราสามารถอ่านสถานะของมันในแบบร่างได้ เมื่อต้องการทำเช่นนี้ เราจะใช้ไดอะแกรมต่อไปนี้

ไฟ LED กระพริบหลังจากกดปุ่ม

ในตัวอย่างก่อนหน้าที่มีไฟ LED เราได้เชื่อมต่อปุ่มเข้ากับบอร์ด Arduino และเข้าใจวิธีการทำงาน LED เปิดและปิด แต่ทำในโหมดพาสซีฟโดยสมบูรณ์ - ตัวควบคุมนั้นไม่จำเป็นอย่างยิ่งที่นี่สามารถแทนที่ด้วยแบตเตอรี่ได้ ดังนั้นมาทำให้โปรเจ็กต์ใหม่ของเรา "ฉลาด" ยิ่งขึ้น: เมื่อคุณกดปุ่ม เราจะทำให้ไฟ LED กระพริบอย่างต่อเนื่อง คุณไม่สามารถทำเช่นนี้กับวงจรทั่วไปที่มีหลอดไฟและสวิตช์ได้ - เราจะใช้พลังของไมโครคอนโทรลเลอร์ของเราเพื่อแก้ปัญหานี้ แม้ว่าจะเป็นเรื่องง่าย แต่ก็ไม่ใช่งานจิ๊บจ๊อย

เราคุ้นเคยกับส่วนของวงจรที่มี LED อยู่แล้ว เราประกอบบีคอนธรรมดาพร้อม LED และตัวต้านทานจำกัด แต่ในส่วนที่สองเราจะเห็นปุ่มที่คุ้นเคยและตัวต้านทานอีกตัว แม้ว่าเราจะไม่ลงรายละเอียด แต่เราเพียงแค่ประกอบวงจรและอัปโหลดภาพร่างง่ายๆ ไปยัง Arduino องค์ประกอบทั้งหมดของวงจรมาในชุดสตาร์ทเตอร์ Arduino ที่ง่ายที่สุด

/* ร่างวงจรโดยใช้ปุ่มสัมผัสและไฟ LED จะกะพริบขณะกดปุ่ม

ปุ่มถูกดึงไปที่พื้น การกดจะสอดคล้องกับ HIGH ที่อินพุต */ const int PIN_BUTTON = 2; ค่าคงที่ PIN_LED = 13; การตั้งค่าเป็นโมฆะ () ( Serial.begin (9600); pinMode (PIN_LED, OUTPUT); ) void loop () ( // รับสถานะปุ่ม int buttonState = digitalRead (PIN_BUTTON); Serial.println (buttonState); // หาก ไม่ได้กดปุ่ม จากนั้นเราจะไม่ทำอะไรเลยถ้า (!buttonState) ( ล่าช้า(50); กลับ; ) // บล็อกของโค้ดนี้จะถูกดำเนินการหากกดปุ่ม // การกะพริบ LED digitalWrite(PIN_LED, HIGH ดีเลย์( 1,000); , ต่ำ);

กดค้างไว้ - ไฟ LED จะกะพริบ ปล่อยไป - มันจะออกไป ตรงกับที่เราต้องการ เราปรบมือด้วยความดีใจและเริ่มวิเคราะห์สิ่งที่เราได้ทำไป

1. มาดูภาพร่างกัน เราเห็นตรรกะที่ค่อนข้างง่ายอยู่ในนั้น
2. ตรวจสอบว่ามีการกดปุ่มหรือไม่
3. หากไม่ได้กดปุ่ม เราก็จะออกจากวิธีวนซ้ำโดยไม่ต้องเปิดหรือเปลี่ยนแปลงอะไรเลย
   1. หากกดปุ่ม เราจะแฟลชโดยใช้ส่วนของภาพร่างมาตรฐาน:
   2. เปิดไฟ LED โดยจ่ายแรงดันไฟฟ้าไปยังพอร์ตที่ต้องการ
   3. เราหยุดชั่วคราวเมื่อไฟ LED ติด
   4. ปิดไฟแอลอีดี

เราหยุดชั่วคราวโดยปิดไฟ LED

ตรรกะเบื้องหลังพฤติกรรมของปุ่มในแบบร่างอาจขึ้นอยู่กับวิธีเชื่อมต่อกับตัวต้านทานแบบดึงขึ้น เราจะพูดถึงเรื่องนี้ในบทความถัดไป

ในขณะที่ทำงานกับปุ่ม เราอาจพบกับปรากฏการณ์ที่ไม่พึงประสงค์ที่เรียกว่าการเด้งของปุ่ม ตามชื่อที่แสดง ปรากฏการณ์นี้เกิดจากการพูดคุยของผู้ติดต่อภายในสวิตช์ปุ่มกด แผ่นโลหะไม่ได้สัมผัสกันในทันที (แม้ว่าจะเร็วมากในสายตาของเรา) ดังนั้นแรงดันไฟกระชากและการตกจึงเกิดขึ้นในบริเวณหน้าสัมผัสในช่วงเวลาสั้นๆ หากเราไม่คาดการณ์ว่าจะมีสัญญาณ “ขยะ” เกิดขึ้น เราก็จะตอบสนองต่อสัญญาณเหล่านั้นทุกครั้งและสามารถนำโครงการของเราไปสู่บ้านได้

เพื่อป้องกันการตีกลับ จึงมีการใช้โซลูชันซอฟต์แวร์และฮาร์ดแวร์ โดยสรุป เราจะพูดถึงวิธีการหลักในการระงับการพูดพล่อย:

• เราเพิ่มการหยุดชั่วคราว 10-50 มิลลิวินาทีในร่างระหว่างการรวบรวมค่าจากพิน Arduino
• หากเราใช้การขัดจังหวะ จะไม่สามารถใช้วิธีซอฟต์แวร์ได้และเราจะสร้างการป้องกันฮาร์ดแวร์ขึ้นมา สิ่งที่ง่ายที่สุดคือตัวกรอง RC พร้อมตัวเก็บประจุและความต้านทาน
• เพื่อการดีเด้งที่แม่นยำยิ่งขึ้น จะใช้ตัวกรองฮาร์ดแวร์โดยใช้ทริกเกอร์ Schmidt ตัวเลือกนี้จะช่วยให้คุณรับสัญญาณที่มีรูปร่างเกือบจะสมบูรณ์แบบที่อินพุตของ Arduino

คุณสามารถดูข้อมูลโดยละเอียดเพิ่มเติมเกี่ยวกับวิธีจัดการกับคนพูดพล่อยได้ในบทความนี้

การสลับโหมดโดยใช้ปุ่ม

เพื่อตรวจสอบว่ามีการกดปุ่มหรือไม่ คุณเพียงแค่ต้องบันทึกข้อเท็จจริงที่ปุ่มถูกกดและจัดเก็บแอตทริบิวต์ไว้ในตัวแปรพิเศษ

เราพิจารณาข้อเท็จจริงของการกดโดยใช้ฟังก์ชัน digitalRead() ผลลัพธ์ที่ได้คือ HIGH (1, TRUE) หรือ LOW (0, FALSE) ขึ้นอยู่กับวิธีการเชื่อมต่อปุ่ม หากเราเชื่อมต่อปุ่มโดยใช้ตัวต้านทานแบบดึงขึ้นภายใน การกดปุ่มจะทำให้อินพุตไปที่ระดับ 0 (FALSE)

หากต้องการเก็บข้อมูลเกี่ยวกับการคลิกปุ่ม คุณสามารถใช้ตัวแปรบูลีน:

ปุ่มบูลีนกด = digitalRead (PIN_BUTTON) == ต่ำ;

เหตุใดเราจึงใช้โครงสร้างนี้และไม่ทำเช่นนี้:

ปุ่มบูลีนกด = digitalRead (PIN_BUTTON);

ประเด็นก็คือ digitalRead() อาจส่งคืนค่า HIGH แต่จะไม่ระบุว่ามีการกดปุ่ม หากคุณใช้วงจรที่มีตัวต้านทานแบบดึงขึ้น HIGH จะหมายความว่าไม่ได้กดปุ่มตรงกันข้าม ในตัวเลือกแรก (digitalRead(PIN_BUTTON)==LOW) เราจะเปรียบเทียบอินพุตกับค่าที่เราต้องการทันที และพิจารณาว่ามีการกดปุ่ม แม้ว่าระดับสัญญาณที่อินพุตจะต่ำก็ตาม และบันทึกสถานะของปุ่มลงในตัวแปร พยายามระบุการดำเนินการเชิงตรรกะทั้งหมดที่คุณทำอย่างชัดเจนเพื่อทำให้โค้ดของคุณโปร่งใสยิ่งขึ้น และหลีกเลี่ยงข้อผิดพลาดโง่ๆ ที่ไม่จำเป็น

จะเปลี่ยนโหมดการทำงานหลังจากกดปุ่มได้อย่างไร?

บ่อยครั้งที่สถานการณ์เกิดขึ้นเมื่อเราใช้ปุ่มต้องคำนึงถึงข้อเท็จจริงที่ไม่เพียงแต่กดเท่านั้น แต่ยังต้องปล่อยปุ่มด้วย เช่น การกดและปล่อยปุ่มจะทำให้เราสามารถเปิดไฟหรือเปลี่ยนโหมดการทำงานของวงจรได้ กล่าวอีกนัยหนึ่งเราจำเป็นต้องบันทึกในโค้ดว่ามีการคลิกปุ่มและใช้ข้อมูลนั้นในอนาคตแม้ว่าจะไม่ได้กดปุ่มอีกต่อไปก็ตาม มาดูกันว่าสามารถทำได้อย่างไร

ตรรกะของโปรแกรมนั้นง่ายมาก:

• เราจำข้อเท็จจริงของการคลิกตัวแปรบริการได้
• เรารอจนกระทั่งปรากฏการณ์ที่เกี่ยวข้องกับการส่งผ่านอันแสนยานุภาพ
• เรากำลังรอปุ่มที่จะปล่อย
• เราจำความจริงของการเปิดตัวและตั้งค่าสัญญาณว่ากดปุ่มจนสุดในตัวแปรแยกต่างหาก
• ล้างตัวแปรบริการ

จะตรวจจับการกดปุ่มหลายปุ่มได้อย่างไร?

คุณเพียงแค่ต้องจำสถานะของแต่ละปุ่มในตัวแปรที่เกี่ยวข้องหรือในอาร์เรย์ Arduino สิ่งสำคัญที่ต้องทำความเข้าใจที่นี่คือปุ่มใหม่แต่ละปุ่มนั้นเป็นพินที่ไม่ว่าง ดังนั้นหากคุณมีปุ่มจำนวนมาก คุณอาจประสบปัญหาการขาดแคลนผู้ติดต่อฟรี อีกทางเลือกหนึ่งคือการใช้ปุ่มที่เชื่อมต่อกับพินอะนาล็อกหนึ่งพินโดยใช้วงจรที่มีตัวแบ่งตัวต้านทาน เราจะพูดถึงเรื่องนี้ในบทความต่อไปนี้

ในตัวอย่างนี้ เราจะดูการเชื่อมต่อปุ่มเข้ากับคอนโทรลเลอร์ Arduino เมื่อกดปุ่มเราจะเปิดไฟ LED ในตัวให้สว่างขึ้น บอร์ด Arduino ส่วนใหญ่มี SMT LED ในตัวเชื่อมต่อกับเอาต์พุต 13 (พิน 13)

ส่วนประกอบที่จำเป็น

• คอนโทรลเลอร์อาดูโน่
• ปุ่มชั้นเชิง
• ตัวต้านทาน 10kOhm
• คณะกรรมการต้นแบบ
• สายเชื่อมต่อ

การเชื่อมต่อ

เราเชื่อมต่อเอาต์พุตกำลัง (5V) และกราวด์ (Gnd) ด้วยสายไฟสีแดงและสีดำตามลำดับเข้ากับเขียงหั่นขนม โดยทั่วไปแล้ว เขียงหั่นขนมจะใช้พินแถวนอกสุดสำหรับจ่ายไฟและกราวด์ ดังแสดงในรูป ด้วยสายสีน้ำเงินเส้นที่สามเราเชื่อมต่อพินดิจิทัล 2 ของคอนโทรลเลอร์ Arduino เข้ากับพินปุ่มนาฬิกา เราเชื่อมต่อตัวต้านทานแบบดึงขึ้น 10 kOhm ไปยังหน้าสัมผัสเดียวกันหรือกับหน้าสัมผัสที่เชื่อมต่ออย่างถาวรในรูปแบบ 4 พิน ซึ่งจะเชื่อมต่อกับกราวด์ เราเชื่อมต่อเอาต์พุตอื่นของปุ่มเข้ากับแหล่งจ่ายไฟ 5 V

เมื่อไม่ได้กดปุ่มนาฬิกา เอาต์พุต 2 จะเชื่อมต่อกับกราวด์เท่านั้นผ่านตัวต้านทานแบบดึงขึ้น และอินพุตนี้จะอ่านว่า LOW และเมื่อกดปุ่ม หน้าสัมผัสจะปรากฏขึ้นระหว่างอินพุต 2 และแหล่งจ่ายไฟ 5V และจะถูกอ่าน

หมายเหตุ: ส่วนใหญ่แล้ว ปุ่มสัมผัสจะมีหน้าสัมผัสสองอันในแต่ละด้าน ดังแสดงในรูปการเชื่อมต่อ ในขณะเดียวกันปุ่มก็มีรูปทรงเกือบเป็นสี่เหลี่ยมจัตุรัส สิ่งสำคัญคือต้องไม่สับสนเมื่อเชื่อมต่อว่ารายชื่อใดเชื่อมต่ออยู่และปิดเมื่อกด ทางที่ดีควรกดกริ่งปุ่มหากคุณไม่แน่ใจ

คุณยังสามารถเชื่อมต่อปุ่มแบบย้อนกลับ - ผ่านตัวต้านทานแบบดึงขึ้นเข้ากับแหล่งจ่ายไฟและผ่านปุ่มไปที่กราวด์ จากนั้น HIGH จะถูกอ่านจากอินพุต และ LOW เมื่อกดปุ่ม

หากปล่อยอินพุตไว้ไม่ได้เชื่อมต่อ อินพุตจะอ่านแบบสุ่มสูงหรือต่ำ นี่คือสาเหตุที่เราใช้ตัวต้านทานแบบดึงขึ้นเพื่อตั้งค่าเฉพาะเมื่อไม่ได้กดปุ่ม

โครงการ

รหัส