การเชื่อมต่อปุ่มกับ Arduino การเชื่อมต่อปุ่ม วิธีเชื่อมต่อปุ่มนาฬิกากับ Arduino

การเชื่อมต่อเซ็นเซอร์ปุ่มกับ 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. เปิดไฟ LED โดยจ่ายแรงดันไฟฟ้าไปยังพอร์ตที่ต้องการ
   2. เราหยุดชั่วคราวเมื่อไฟ LED ติด
   3. ปิดไฟแอลอีดี
   4. เราหยุดชั่วคราวโดยปิดไฟ LED

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

ปุ่ม Arduino แสนยานุภาพ

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

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

• เราเพิ่มการหยุดชั่วคราว 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 วันนี้เราจะมาพูดถึงสัญญาณ Arduino GPIO และ PWM เราจะใช้ปุ่มและควบคุมความสว่างของ LED โดยใช้สัญญาณ PWM นอกจากนี้เรายังจะใช้ฟังก์ชันในสภาพแวดล้อมการเขียนโปรแกรม Arduino

ขั้นแรก เรามาลองควบคุม LED โดยใช้ปุ่มกันก่อน

เราจะต้อง:

1. ตัวต้านทานนิกายประมาณ 100-400 โอห์มเพื่อจำกัดกระแสที่ไหลผ่าน LED เพื่อไม่ให้ไฟดับ
2. ตัวต้านทานนิกายประมาณ 10 ห้องเพื่อดึงระดับลอจิกที่อินพุต Arduino หากคุณไม่ได้ติดตั้ง ปุ่มของเราก็จะทำงานได้ไม่เสถียรอย่างมาก เพราะ... จะมีสัญญาณรบกวนที่อินพุต Arduino แทนที่จะเป็นสัญญาณที่มีประโยชน์
3. ไดโอดเปล่งแสง AL307หรือคนที่คุณชอบ จริงๆแล้วเราจะจุดไฟมัน
4. ปุ่มชั้นเชิง IT-1102หรืออื่น ๆ จะใช้ควบคุมไฟ LED

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

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

หากคุณเชื่อมต่อ LED ไม่ถูกต้อง ไฟจะไม่สว่างเพราะไม่มีกระแสไฟฟ้าไหลผ่าน (เพียงแต่จะปิด) ง่ายต่อการระบุขั้วของ LED ขาสั้นของ LED เป็นลบ (เช่นศูนย์หรือ GND) และขายาวเป็น +.

ปุ่มเชื่อมต่อในลักษณะที่ในขณะที่กดสวิตช์ +5 โวลต์เป็นอินพุตหมายเลข 10 ของ Arduino ซึ่งสอดคล้องกับหน่วยลอจิคัลของอินพุตดิจิทัล Arduino ในขณะที่ไม่ได้กดปุ่ม ตัวต้านทาน 10 kohm ของเราจะดึงอินพุต Arduino ไปที่ GND (เช่น เป็นศูนย์) และอินพุต Arduino จะเป็นศูนย์ตรรกะอย่างสม่ำเสมอ หากคุณไม่ได้ใช้ตัวต้านทานแบบดึงขึ้นนี้อาจเป็นไปได้ว่าสัญญาณเตือนที่ผิดพลาดจะเกิดขึ้นเนื่องจากจะไม่มีตัวต้านทานแบบดึงขึ้นที่อินพุต Arduino และด้วยเหตุนี้แรงดันไฟฟ้าจะไม่เป็น เป็นศูนย์ มันจะเปลี่ยนอย่างโกลาหล ซึ่งทำให้เกิดตรรกะเท็จที่ปรากฏที่อินพุต Arduino

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

/*

เรากระพริบไฟ LED
เราจะเปิดไฟ LED ไว้ตราบใดที่กดปุ่ม

*/

{


}

{
if (digitalRead(switchPin) == HIGH) // หากกดปุ่ม ตัวแปร switchPin ของเราจะถูกตั้งค่าเป็น HIGH (ลอจิคัล 1) และโค้ดต่อไปนี้จะถูกดำเนินการ เส้น
{
digitalWrite (ledPin, สูง); // เปิดไฟ LED โดยการตั้งค่าลอจิก 1 (ระดับสูง) ที่เอาต์พุต 13
}
else // หากไม่ได้กดปุ่ม โค้ดด้านล่างนี้จะถูกดำเนินการ
{
digitalWrite (ledPin, ต่ำ); // ปิดไฟ LED
}
}

แล้วได้อะไรล่ะ! -

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

รหัสของเราสำหรับวัตถุประสงค์เหล่านี้จะมีลักษณะดังนี้:

/*
บทที่ 2 GPIO ปุ่ม และ PWM บน Arduino

เราจะเปิดไฟ LED หลังจากกดปุ่มและปิดหลังจากกดครั้งที่สอง
รหัสสาธิตนี้ถูกดาวน์โหลดจาก www.site
*/

int switchPin = 10; // เพื่อความสะดวก ให้ตั้งชื่อ "switchPin" สำหรับพิน 10
int ledPin = 13; // เพื่อความสะดวก ให้ตั้งชื่อ "ledPin" สำหรับพิน 13


การตั้งค่าเป็นโมฆะ () // บล็อก "การตั้งค่า" จะทำงานเพียงครั้งเดียวเมื่อ Arduino เริ่มทำงานซึ่งจำเป็นสำหรับการเริ่มต้น
{
pinMode(สวิตช์พิน, อินพุต); // กำหนดค่า Arduino pin 10 เป็นอินพุต เพราะ เราจะอ่านสถานะของปุ่ม
pinMode(ledPin, เอาท์พุต); // กำหนดค่า Arduino pin 13 เป็นเอาต์พุต จากนั้นเราจะเปิด LED
}

void loop() // บล็อก “loop” นั้นเป็น loop เช่น รหัสที่ทำงานซ้ำแล้วซ้ำเล่าอย่างไม่มีที่สิ้นสุด
{
ถ้า (digitalRead(switchPin) == HIGH && LastButton == LOW) // หากกดปุ่มและสถานะปุ่มสุดท้ายคือ "ไม่ได้กด" ให้รันโค้ดต่อไปนี้
{

ปุ่มสุดท้าย = สูง; // เปลี่ยนค่าของ LastButton เป็นค่าตรรกะ
}
อื่น
{
LastButton = digitalRead (สวิตช์พิน); // ตั้งค่าตัวแปร LastButton ให้เป็นค่าเดียวกันกับตัวแปร switchPin
}

}

แล้วมันทำงานยังไงล่ะ! อืม... แปลก.. บางครั้งทุกอย่างก็เป็นไปตามที่คาดไว้สำหรับเรา และบางครั้งก็ไม่... ทำไมสิ่งนี้ถึงเกิดขึ้นได้? ทั้งหมดนี้เกี่ยวข้องกับเอฟเฟกต์ "การตีกลับแบบสัมผัส":

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

/*
บทที่ 2 GPIO ปุ่ม และ PWM บน Arduino
เปิด/ปิดไฟแอลอีดี
เราจะเปิดไฟ LED หลังจากกดปุ่มและปิดหลังจากกดครั้งที่สองและกำจัดการตีกลับของปุ่ม
รหัสสาธิตนี้ถูกดาวน์โหลดจาก www.site

int switchPin = 10; // เพื่อความสะดวก ให้ตั้งชื่อ "switchPin" สำหรับพิน 10
int ledPin = 13; // เพื่อความสะดวก ให้ตั้งชื่อ "ledPin" สำหรับพิน 13
บูลีน LastButton = ต่ำ; // ในตัวแปรนี้ เราจะจัดเก็บสถานะของปุ่มในระหว่างการประมวลผลลูปก่อนหน้าของเรา และตั้งค่าให้เป็นศูนย์ด้วย
บูลีน ledOn = false; // ในตัวแปรนี้ เราจะจัดเก็บสถานะของ LED เพื่อให้เราสามารถสลับได้

การตั้งค่าเป็นโมฆะ () // บล็อก "การตั้งค่า" จะทำงานเพียงครั้งเดียวเมื่อ Arduino เริ่มทำงานซึ่งจำเป็นสำหรับการเริ่มต้น
{
pinMode(สวิตช์พิน, อินพุต); // กำหนดค่า Arduino pin 10 เป็นอินพุต เพราะ เราจะอ่านสถานะของปุ่ม
pinMode(ledPin, เอาท์พุต); // กำหนดค่า Arduino pin 13 เป็นเอาต์พุต จากนั้นเราจะเปิด LED
}

{


{


}

}

void loop() // บล็อก “loop” นั้นเป็น loop เช่น รหัสที่ทำงานซ้ำแล้วซ้ำเล่าอย่างไม่มีที่สิ้นสุด

{


{
ledOn = !ledOn; // เปลี่ยนค่า ledOn ให้เป็นค่าตรงกันข้าม
}

digitalWrite (ledPin, ledOn); // จริงๆ แล้วบรรทัดนี้จะเปิดปิด LED
}

ฉันคิดว่าตอนนี้ทุกอย่างทำงานได้ตามที่ตั้งใจไว้สำหรับทุกคน;)

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

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

และยังทำการเปลี่ยนแปลงรหัสโปรแกรมอีกด้วย กล่าวคือ คุณต้องเปลี่ยนหมายเลขติดต่อและ เพิ่มการใช้ PWM:

/*
บทที่ 2 GPIO ปุ่ม และ PWM บน Arduino
เปลี่ยนความสว่างของ LED
เราจะเปลี่ยนความสว่างของ LED หลังจากกดปุ่มแต่ละปุ่ม
รหัสสาธิตนี้ถูกดาวน์โหลดจาก www.site
*/

int switchPin = 10; // เพื่อความสะดวก ให้ตั้งชื่อ "switchPin" สำหรับพิน 10
int ledPin = 11; // เพื่อความสะดวก ให้ตั้งชื่อ "ledPin" สำหรับพิน 11
บูลีน LastButton = ต่ำ; // ในตัวแปรนี้ เราจะจัดเก็บสถานะของปุ่มในระหว่างการประมวลผลลูปก่อนหน้าของเรา และตั้งค่าให้เป็นศูนย์ด้วย
int ledLevel = 0; // ในตัวแปรนี้ เราจะเก็บความสว่างของ LED ความสว่างสามารถมีค่าได้ตั้งแต่ 0 ถึง 255 ในขณะที่เริ่มต้นเราจะตั้งค่าเป็น 0 เพื่อให้ LED ไม่เรืองแสง
บูลีน currentButton = ต่ำ; // ตัวแปรสำหรับฟังก์ชัน debounce ของเรา

การตั้งค่าเป็นโมฆะ () // บล็อก "การตั้งค่า" จะทำงานเพียงครั้งเดียวเมื่อ Arduino เริ่มทำงานซึ่งจำเป็นสำหรับการเริ่มต้น
{
pinMode(สวิตช์พิน, อินพุต); // กำหนดค่า Arduino pin 10 เป็นอินพุต เพราะ เราจะอ่านสถานะของปุ่ม
pinMode(ledPin, เอาท์พุต); // กำหนดค่า Arduino pin 13 เป็นเอาต์พุต จากนั้นเราจะเปิด LED
}

boolean debounce(boolean สุดท้าย) //ฟังก์ชันสำหรับ debouncing ปุ่มผู้ติดต่อ จะคืนสถานะก่อนหน้า
{
บูลีนปัจจุบัน = digitalRead (switchPin); // เขียนสถานะปัจจุบันของปุ่มให้เป็นปัจจุบัน
if (last != current) // ตรวจสอบว่าสถานะของปุ่มมีการเปลี่ยนแปลงหรือไม่
{
ล่าช้า(5); // ถ้าใช่ ให้หน่วงเวลา 5 มิลลิวินาทีเพื่อให้ปุ่มหยุด “รัว”
ปัจจุบัน = digitalRead (switchPin); // อ่านค่าของปุ่มหลังจากหยุดชั่วคราว ตอนนี้การพูดคุยควรจะผ่านไปแล้ว
}
กลับปัจจุบัน; // คืนค่าคงที่ของปุ่ม
}

void loop() // บล็อก “loop” นั้นเป็น loop เช่น รหัสที่ทำงานซ้ำแล้วซ้ำเล่าอย่างไม่มีที่สิ้นสุด
{
currentButton = debounce (ปุ่มสุดท้าย); // ส่งผ่านไปยัง currentButton ซึ่งเป็นผลลัพธ์ของฟังก์ชัน debounce โดยมีสถานะของปุ่มที่ส่งผ่านไป
if (lastButton == LOW && currentButton == HIGH) // ตรวจสอบว่ามีการกดปุ่มหรือไม่
{
ledLevel = ledLevel + 51; // เปลี่ยนค่าความสว่างเป็น 51
}
LastButton = ปุ่มปัจจุบัน; // ตั้งค่าตัวแปร LastButton ให้เป็นค่าเดียวกันกับตัวแปร currentButton

ถ้า (ledLevel > 255) ledLevel = 0; // จำกัดจำนวนสูงสุด มูลค่า 255
อะนาล็อกเขียน (ledPin, ledLevel); // จริงๆ แล้วบรรทัดนี้จะให้ไฟ LED สว่างตามความสว่างที่ต้องการ
}

ฉันหวังว่าทุกอย่างจะได้ผลสำหรับคุณ นี่คือจุดสิ้นสุดของบทเรียน

สามารถถามคำถามและขอคำแนะนำได้ในความคิดเห็น

/*
* ชุดทดลอง ArduinoKit
* รหัสโปรแกรมการทดลองหมายเลข 5: ร่าง 05
*
* ปุ่ม
*
* เขียนขึ้นสำหรับเว็บไซต์ http://site
*
*
* ความช่วยเหลือจากชุมชน Arduino
* เยี่ยมชม http://www.arduino.cc
*
* ความเห็นเกี่ยวกับโปรแกรมที่เขียนโดย
* 22 มกราคม 2557
* พิเศษสำหรับ http://site
*/

ปุ่ม

การใช้ปุ่มบนอินพุตดิจิตอล

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

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

แต่เดี๋ยวก่อนจะเกิดอะไรขึ้นเมื่อไม่ได้กดปุ่ม? ในสถานะนี้พอร์ตจะถูกตัดการเชื่อมต่อจากทุกสิ่งนั่นคือมันค้างอยู่ในอากาศและเราเรียกสถานะที่เข้าใจยากนี้ว่า "ไม่ได้กำหนด" หรือลอยตัว นั่นคือเราไม่สามารถพูดได้อย่างแน่นอนว่า Arduino จะตอบสนองต่อสถานะดังกล่าวอย่างไร ขึ้นอยู่กับสภาพแวดล้อมต่างๆ เธออาจมองว่าสิ่งนี้เป็นสูง (“สูง” +5 โวลต์) หรือต่ำ (“ต่ำ” - ศูนย์ตรรกะ)

เพื่อหลีกเลี่ยงความคลาดเคลื่อนใด ๆ และไมโครคอนโทรลเลอร์รู้แน่ชัดว่ามีอะไรอยู่ที่อินพุตในปัจจุบัน เราจะเชื่อมต่อพอร์ต Arduino เพิ่มเติมผ่านตัวต้านทานแบบจำกัด (ตัวใดตัวหนึ่งที่มีพิกัด 1KOhm - 10KOhm จะทำ) กับบัส +5 โวลต์ “การดึงขึ้น” นี้จะรับประกันว่าจะมีสัญญาณ HIGH +5V คงที่ และเมื่อคุณกดปุ่ม วงจรจะปิดกับกราวด์ - “0” ซึ่งหมายถึงสำหรับ Arduino สัญญาณอินพุตจะเปลี่ยนจากสูงเป็นต่ำ , เช่น. จากสูง +5V ถึงต่ำ “0”

(เพิ่มเติม: เมื่อคุณคุ้นเคยกับตัวต้านทานและรู้ว่าเมื่อใดที่จำเป็น คุณสามารถเปิดใช้งานตัวต้านทานแบบดึงขึ้นภายในที่พบในโปรเซสเซอร์ ATmega ได้ สำหรับข้อมูลเพิ่มเติม โปรดดูที่ http://arduino.cc/en/Tutorial/ พินดิจิทัล)

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

ปุ่มมีผู้ติดต่อสองราย หากกดปุ่ม ผู้ติดต่อจะถูกปิด หากไม่กด ผู้ติดต่อจะเปิดขึ้น

ในปุ่มเราจะใช้ทั้งผู้ติดต่อสองและสี่ราย แต่ควรสังเกตว่าในปุ่มที่เราจะใช้ตอนนี้ผู้ติดต่อสองคนจะขนานกัน

วิธีที่ง่ายที่สุดในการเชื่อมต่อปุ่มคือการต่อสายไฟเข้ากับขั้วต่อ - เฉียง (แนวทแยง)

เชื่อมต่อพินของปุ่ม 1 เข้ากับกราวด์ (GND)
เชื่อมต่อหมุดปุ่มอีกอันเข้ากับพอร์ตดิจิตอล 2

เชื่อมต่อพินของปุ่ม 2 เข้ากับกราวด์ (GND)
เชื่อมต่อหมุดปุ่มอีกอันเข้ากับพอร์ตดิจิตอล 3

ที่ขาของปุ่มที่ไปยังพอร์ตดิจิตอล 2,3 ให้เชื่อมต่อตัวต้านทานแบบ "ดึงขึ้น" 10K (สีน้ำตาล/สีดำ/สีแดง) และเชื่อมต่อเทอร์มินัลที่สองของตัวต้านทานเหล่านี้เข้ากับ "-" ทั่วไป (GND) ตัวต้านทานเหล่านี้ช่วยให้แน่ใจว่าอินพุตจะเป็น +5V (ไม่ได้กดปุ่ม) หรือเป็น "0" เมื่อกด และไม่มีอย่างอื่นอีก (และอย่าลืมว่า อินพุตแบบดิจิทัลนั้นต่างจากอินพุตแบบอะนาล็อกตรงที่มีเพียงสองสถานะเท่านั้น: สูง และ ต่ำ)

ไดโอดเปล่งแสง:

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

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

เชื่อมต่อขั้วบวกของ LED เข้ากับพอร์ตดิจิตอล Arduino #13
เชื่อมต่อขั้วลบของ LED เข้ากับตัวต้านทาน 330 โอห์ม
เชื่อมต่อเทอร์มินัลอีกอันของตัวต้านทานเข้ากับ GND "-"

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

ปุ่ม const int1Pin = 2; // ปุ่มหมายเลข 1 - พอร์ต 2
ปุ่ม const int2Pin = 3; // ปุ่มหมายเลข 2 - พอร์ต 3
const int ledPin = 13; // พอร์ต 13 สำหรับ LED

การตั้งค่าเป็นโมฆะ ()
{
// ตั้งค่าพอร์ตของปุ่มเป็นขาเข้า:
pinMode(ปุ่ม1พิน, อินพุต);
pinMode(ปุ่ม2พิน, อินพุต);

// ตั้งค่าพอร์ต LED เป็นขาออก:
pinMode(ledPin, เอาท์พุต);
}

เป็นโมฆะวน()
{
int ปุ่ม 1 สถานะ ปุ่ม 2 สถานะ; // ตัวแปรสำหรับบันทึกสถานะของปุ่ม

// เนื่องจากปุ่มมีเพียงสองสถานะ (กดและไม่ได้กด) เราจะทำ
// ทำงานร่วมกับพวกเขาโดยใช้พอร์ตอินพุตดิจิทัล เพื่อที่จะได้อ่าน
// ข้อมูลเราจะใช้ฟังก์ชัน digitalRead() คุณสมบัตินี้ช่วยให้
// รับพารามิเตอร์หนึ่งตัวจากพอร์ตดิจิทัลและส่งคืน HIGH (+5V)
// หรือต่ำ (“0”)

// ที่นี่เราอ่านสถานะปัจจุบันของปุ่มและใส่ค่าของมัน
// เป็นสองตัวแปร:

button1State = digitalRead (ปุ่ม 1 พิน);
button2State = ดิจิทัลอ่าน (button2Pin);

// จำไว้ว่าหากกดปุ่ม พอร์ตจะเชื่อมต่อกับกราวด์ ("-")
// หากไม่ได้กดปุ่ม พอร์ตจะเชื่อมต่อกับ +5 โวลต์ผ่านตัวต้านทานแบบดึงขึ้น

// ดังนั้นสถานะพอร์ตจะต่ำเมื่อกดปุ่ม
// และ HIGH (สูง) เมื่อไม่ได้กด

// ตอนนี้เราจะใช้สถานะของพอร์ตเพื่อควบคุม LED

// สิ่งที่เราอยากทำเงื่อนไข:
// "หากกดปุ่มใดปุ่มหนึ่ง ไฟ LED จะสว่างขึ้น"
// “แต่ถ้ากดทั้งสองปุ่ม ไฟ LED จะไม่สว่าง”
// มาแปลสิ่งนี้เป็นโค้ดกันดีกว่า

// Arduino มีตัวดำเนินการเชิงตรรกะพิเศษและตัวดำเนินการเปรียบเทียบ
// ซึ่งมักใช้ในการตรวจสอบเงื่อนไข โดยเฉพาะ:

// "==" (ความเท่าเทียมกัน) - เป็นจริงถ้าทั้งสองฝ่ายเหมือนกัน
// ตัวอย่าง:
// ถ้า (x == y) (
//สภาพร่างกาย
//}

// "&&" (ตรรกะ AND) - เป็นจริงเฉพาะเมื่อตรงตามเงื่อนไขทั้งสองเท่านั้น
// ตัวอย่าง:
// จริงถ้าทั้งสองนิพจน์เป็น True
// ถ้า (x > 0 && x< 5) {
//สภาพร่างกาย
//}

- (ตรรกะไม่)
// จริงถ้าตัวดำเนินการเป็นเท็จ
// ตัวอย่าง:
// ถ้า (!x) (
//สภาพร่างกาย
//}

- (ตรรกะ OR) - เป็นจริงหากมีเงื่อนไขอย่างน้อยหนึ่งข้อเป็นจริง
// ตัวอย่าง:
// ถ้า (x > 0 || y > 0) (
//สภาพร่างกาย
// }

// ในกรณีนี้ เราจะใช้โครงสร้าง "if" เพื่อแปลทุกอย่าง
// ข้างต้นเข้าสู่ห่วงโซ่ลอจิคัลของโปรแกรม
// (อย่าลืมว่า LOW หมายถึงกดปุ่มแล้ว)

// "หากกดปุ่มใดปุ่มหนึ่ง ไฟ LED จะสว่างขึ้น"
// มันจะเปิดออก:
// ถ้า ((button1State == LOW) || (button2State == LOW)) // เปิดไฟ LED

// "ถ้ากดทั้งสองปุ่ม ไฟ LED จะไม่สว่าง"
// มันจะเปิดออก:
// ถ้า ((button1State == LOW) && (button2State == LOW)) // อย่าเปิดไฟ LED

// ตอนนี้เรามาใช้ฟังก์ชันข้างต้นและรวมเข้าด้วยกันเป็นคำสั่งเดียว:

if (((button1State == LOW) || (button2State == LOW)) // เปรียบเทียบว่ามีการกดปุ่มใดปุ่มหนึ่ง
- //และถ้าไม่.
((button1State == LOW) && (button2State == LOW))) // เปรียบเทียบว่ากดทั้งสองปุ่มหรือไม่
// แล้ว…
{
digitalWrite (ledPin, สูง); // เปิดไฟ LED
}
อย่างอื่น // อย่างอื่น
{
digitalWrite (ledPin, ต่ำ); // ปิดไฟ LED
}

// ตามที่คุณอาจสังเกตเห็นแล้วว่า สามารถรวมโอเปอเรเตอร์เข้าด้วยกันได้
// สำหรับการแก้ปัญหาที่ซับซ้อน

// อย่าลืม: คุณไม่สามารถใช้ตัวดำเนินการ "=" เมื่อเปรียบเทียบค่าแทนได้
// "==" เนื่องจากตัวดำเนินการ "=" กำหนดค่าให้กับตัวแปร!
}

ในบทความถัดไป เราจะเผยแพร่โค้ดสำหรับบทเรียนที่ 5 เป็นไฟล์เก็บถาวร

และ อาร์ดูโน่ก็ไม่มีข้อยกเว้น หลังจากที่ไฟ LED กระพริบ มันจะพยายามเชื่อมต่อปุ่มและใช้เพื่อควบคุมการกระพริบของไฟ LED นี้ ไม่มีอะไรซับซ้อนเป็นพิเศษที่นี่ แต่มีข้อแม้หนึ่งที่เรียกว่า "การตีกลับแบบสัมผัส" วิธีการเชื่อมต่อปุ่มอย่างถูกต้อง อาร์ดูโน่“การตีกลับแบบสัมผัส” คืออะไร ผลกระทบนี้ปรากฏอย่างไร และวิธีการต่อสู้กับมันจะมีการพูดคุยกันในวันนี้

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

ถ้ากุญแจ ส 1เปิดอยู่ (ปล่อยปุ่ม) จากนั้นไปที่อินพุตดิจิตอล ดี อินไมโครคอนโทรลเลอร์เราจะมีแรงดันไฟฟ้า 5V ซึ่งสอดคล้องกับตรรกะ เมื่อกดปุ่มแล้วให้เข้าไป ดี อินเชื่อมต่อกับกราวด์ซึ่งสอดคล้องกับระดับศูนย์ลอจิคัล และแรงดันไฟฟ้าทั้งหมดจะตกคร่อมตัวต้านทาน ร 1ค่าที่เลือกขึ้นอยู่กับข้อเท็จจริงที่ว่าเมื่อกดปุ่มจะมีกระแสไม่ไหลผ่านมากเกินไป (ปกติประมาณ 10-100 kOhm)

หากคุณเพียงเชื่อมต่อปุ่มระหว่างอินพุตดิจิตอลและกราวด์ (โดยไม่มีตัวต้านทาน ร 1เชื่อมต่อกับ +5V) หรือระหว่างอินพุตกับ +5V จากนั้นในตำแหน่งที่ไม่ได้กดปุ่ม จะมีแรงดันไฟฟ้าที่ไม่ได้กำหนดปรากฏบนอินพุตดิจิทัลของไมโครคอนโทรลเลอร์ (อาจตรงกับระดับ 0 หรืออาจเป็น 1) และเราจะอ่านสถานะแบบสุ่ม ดังนั้นจึงใช้ตัวต้านทาน ร 1ซึ่งว่ากันว่าให้ "ดึง" อินพุตไปที่ +5V เมื่อปล่อยปุ่ม

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

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

ไมโครคอนโทรลเลอร์ แอทเมล เอวีอาร์ เอทีเมก้า(บนพื้นฐานที่มันถูกสร้างขึ้น อาร์ดูโน่) มีตัวต้านทานโหลดที่เชื่อมต่อกับซอฟต์แวร์ในตัว ร 20 kOhm และเราสามารถใช้มันได้โดยทำให้แผนภาพการเชื่อมต่อง่ายขึ้น

ตัวต้านทานโหลดภายในเชื่อมต่อกันโดยการเขียนลอจิคัลหนึ่งไปยังบิตที่ต้องการของพอร์ต

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

การตั้งค่าเป็นโมฆะ () ( pinMode (13, OUTPUT); // LED บนพิน 13 pinMode (2, INPUT); // 2 พินอยู่ในโหมดอินพุต ปุ่มเชื่อมต่อกับกราวด์ digitalWrite (2, สูง); // เชื่อมต่อตัวต้านทานแบบดึงขึ้น ) void loop() ( digitalWrite(13, !digitalRead(2)); // อ่านสถานะปุ่มแล้วเปลี่ยน LED )

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

ติดต่อเด้ง

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

ในตัวอย่างข้างต้น เมื่อเราเปิดและปิด LED โดยใช้ปุ่ม เราไม่ได้สังเกตเห็นสิ่งนี้ เนื่องจากการเปิด/ปิด LED ในขณะที่ "เด้ง" เกิดขึ้นอย่างรวดเร็วมาก และเราก็ไม่เห็นมันด้วย ดวงตา

ไลบรารีนี้มีวิธีการดังต่อไปนี้:

• เด้ง()— การเริ่มต้นของวัตถุ Bounce
• ช่วงเวลาเป็นโมฆะ (ช่วงเวลายาวที่ไม่ได้ลงนาม)— ตั้งเวลาป้องกันการตีกลับเป็นมิลลิวินาที
• แนบเป็นโมฆะ (int pin)— ตั้งค่าพินที่ปุ่มเชื่อมต่ออยู่และเชื่อมต่อตัวต้านทานแบบดึงขึ้นในตัวเข้ากับพินนี้
• int อัพเดต()- เพราะว่า เด้งไม่ได้ใช้ คุณกำลัง "อัปเดต" วัตถุก่อนที่คุณจะอ่านสถานะและต้องทำอย่างต่อเนื่อง (เช่นภายใน วนซ้ำ- วิธี อัปเดต อัพเดตวัตถุและส่งคืน จริง(1) หากสถานะของพินเปลี่ยนไป (กดปุ่มหรือปล่อยในทางกลับกัน) และ เท็จ(0) มิฉะนั้น การเรียกวิธีการ อัปเดต ข้างใน วนซ้ำต้องทำเพียงครั้งเดียวเท่านั้น
• int อ่าน()— ส่งคืนสถานะที่อัปเดตของพิน

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

พารามิเตอร์ ช่วงเวลาที่มั่นคงตีกลับไลบรารี

ตัดสินใจแล้ว

#กำหนด BOUNCE_LOCK-OUT

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

นี่คือตัวอย่างการใช้ไลบรารีนี้:

#รวม เด้ง คนโกหก = เด้ง(); การตั้งค่าเป็นโมฆะ () ( pinMode (2 , INPUT); // ปุ่มบนพิน 2 digitalWrite (2 , สูง); คนโกหก .แนบ (2); // ตั้งค่าปุ่มคนโกหก .interval (5); Serial.begin (9600) ; // ตั้งค่าพอร์ตอนุกรมเป็น 9600 bps) void loop() ( if (bouncer.update()) ( //ถ้ามีเหตุการณ์เกิดขึ้นถ้า (bouncer.read()==0) ( //ถ้ากดปุ่ม Serial .println("pressed"); //แสดงข้อความเกี่ยวกับการกด ) else Serial.println("released"); //แสดงข้อความเกี่ยวกับการกด ) )

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

#รวม #define pressed_long 2000 // กดแบบยาว = 2 วินาที #define num_modes 5 // หมายเลขโหมดสูงสุดสั้น int max_mode = num_modes + 1; // ตัวแปรเสริม Bounce Bouncer = Bounce(); //สร้างอินสแตนซ์ของคลาส Bounce ที่ไม่ได้ลงนาม long pressed_moment; // ช่วงเวลาที่กดปุ่ม int current_mode = 0; // การตั้งค่าเป็นโมฆะโหมดปัจจุบัน () ( pinMode (2 ,INPUT); // ปุ่มบนพิน 2 digitalWrite (2 ,HIGH); // เชื่อมต่อตัวโกหกตัวต้านทานแบบดึงขึ้นในตัว .แนบ (2); // ติดตั้ง ปุ่มโกหก .interval( 5); // ตั้งค่าช่วงเวลาคงที่ของพารามิเตอร์ = 5 ms Serial.begin(9600); // ตั้งค่าพอร์ตอนุกรมเป็น 9600 bps) void loop() ( if (bouncer.update()) //หากสิ่งนี้เกิดขึ้น เหตุการณ์ if (bouncer.read()==0) ( //หากกดปุ่ม pressed_moment = millis(); // จำเวลาที่กด ) else ( // ปุ่มจะถูกปล่อย if(( มิลลิวินาที() - pressed_moment)< pressed_long) { // если кнопка была нажата кратковременно current_mode++; // увеличиваем счетчик текушего режима current_mode %= max_mode; // остаток от целочисленного деления if (current_mode == 0) current_mode = 1; // режим меняется от 1 до num_modes } else { // кнопка удерживалась долго current_mode = 0; pressed_moment = 0; // обнуляем момент нажатия } Serial.println("Current mode:"); Serial.println(current_mode); // выводим сообщение о текущем режиме } } }

โปรแกรมแรกควรควบคุม LED โดยใช้ปุ่ม:

• เมื่อกดปุ่มไฟ LED จะสว่างขึ้น
• เมื่อกดปุ่ม ไฟ LED จะไม่สว่างขึ้น

การเชื่อมต่อปุ่มและ LED เข้ากับบอร์ด Arduino

ในการสื่อสารกับองค์ประกอบภายนอก คอนโทรลเลอร์ Arduino UNO มีพินดิจิทัล 14 ตัว แต่ละพินสามารถกำหนดโดยโปรแกรมเป็นอินพุตหรือเอาต์พุต

เอาต์พุตดิจิตอลมีเพียงสองสถานะคือสูงและต่ำ สถานะสูงสอดคล้องกับแรงดันเอาต์พุตประมาณ 5 V สถานะต่ำคือ 0 V เอาต์พุตอนุญาตให้เชื่อมต่อโหลดกับกระแสสูงถึง 40 mA

เมื่อพินถูกกำหนดให้เป็นอินพุตแล้ว โดยการอ่านสถานะ จะสามารถกำหนดระดับแรงดันไฟฟ้าที่อินพุตได้ ที่แรงดันไฟฟ้าใกล้กับ 5 V (จริงๆ แล้วมากกว่า 3 V) สถานะสูงจะถูกอ่าน ซึ่งสอดคล้องกับค่าคงที่ HIGH เมื่อแรงดันไฟฟ้าใกล้กับ 0 (น้อยกว่า 1.5 V) จะถูกอ่านสถานะต่ำหรือค่าคงที่ LOW

เราต้องเชื่อมต่อ LED เข้ากับพินโดยกำหนดให้เป็นเอาต์พุต และปุ่มเชื่อมต่อกับพินด้วยโหมดอินพุต

LED เชื่อมต่อผ่านตัวต้านทานจำกัดกระแส นี่คือแผนภาพทั่วไป

ตัวต้านทานคำนวณโดยใช้สูตร I = Uoutput – Udrop บน LED / R

Uoutput = 5 V, Udrop บน LED สามารถรับได้เท่ากับ 1.5 V (ระบุไว้อย่างแม่นยำยิ่งขึ้นในหนังสืออ้างอิง) ปรากฎว่าในวงจรของเรากระแสไฟฟ้าผ่าน LED ตั้งไว้ที่ 10 mA

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

เราเชื่อมต่อปุ่มเข้ากับพินอื่น ๆ เช่น 12. ฮาร์ดแวร์ของวงจรเชื่อมต่อปุ่มจะต้องมีระดับแรงดันไฟฟ้า 0 V เมื่อกดปุ่มและ 5 V เมื่อปุ่มว่าง ซึ่งสามารถทำได้ด้วยแผนภาพง่ายๆ

เมื่อกดปุ่ม ตัวต้านทานจะสร้าง 5 V ที่เอาต์พุต และเมื่อกด อินพุตจะลัดวงจรลงกราวด์ ฉันจะเขียนคำแนะนำในการเลือกตัวต้านทานในบทเรียนสุดท้ายเกี่ยวกับปุ่มต่างๆ ตอนนี้ฉันจะเสนอทางเลือกอื่น พินทั้งหมดของบอร์ดมีตัวต้านทานภายในคอนโทรลเลอร์ที่เชื่อมต่อกับ 5 V โดยสามารถเปิดหรือปิดใช้งานซอฟต์แวร์ได้จากพิน ความต้านทานของตัวต้านทานเหล่านี้อยู่ที่ประมาณ 20-50 kOhm มากเกินไปสำหรับวงจรจริง แต่สำหรับโปรแกรมของเราและปุ่มที่ติดตั้งใกล้กับคอนโทรลเลอร์ ก็ค่อนข้างยอมรับได้

ดังนั้นแผนภาพการเชื่อมต่อจะมีลักษณะดังนี้

สามารถบัดกรีปุ่มบนสายไฟเข้ากับขั้วต่อได้ ฉันติดตั้งมันบนเขียงหั่นขนมโดยไม่ต้องบัดกรี ฉันซื้อมันมาเพื่อสาธิตบทเรียนโดยเฉพาะ

ฟังก์ชั่นการควบคุม I/O

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

pinMode (พิน, โหมด)

ตั้งค่าโหมดเอาต์พุต (อินพุตหรือเอาต์พุต)

อาร์กิวเมนต์: พินและโหมด

• พิน – หมายเลขพิน;
• โหมด – โหมดเอาต์พุต

ฟังก์ชั่นไม่ส่งคืนสิ่งใด

digitalWrite (พิน, ค่า)

ตั้งค่าสถานะเอาต์พุต (สูงหรือต่ำ)

พินอาร์กิวเมนต์และค่า:

• พิน – หมายเลขพิน;
• ค่า – สถานะเอาต์พุต

ฟังก์ชั่นไม่ส่งคืนสิ่งใด

ดิจิตอลอ่าน(พิน)

อ่านสถานะอินพุต

อาร์กิวเมนต์: หมายเลขพิน - หมายเลขพิน

คืนสถานะการเข้าสู่ระบบ:

โปรแกรมควบคุมแอลอีดี

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

/* โปรแกรม scetch_5_1 บทที่ 5
*/

ปุ่มบูลีนสถานะ; - สร้างตัวแปรส่วนกลาง buttonState

การตั้งค่าเป็นโมฆะ () (
พินโหมด(13, เอาท์พุต); -

}

// วงจรไม่มีที่สิ้นสุด
เป็นโมฆะวน() (



}

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

คัดลอกหรือเขียนโค้ดโปรแกรมใหม่ลงในหน้าต่าง Arduino IDE ดาวน์โหลดไปยังคอนโทรลเลอร์และตรวจสอบ

เพื่อบันทึกโปรเจ็กต์ Arduino ฉันได้สร้างโฟลเดอร์ d:\Arduino Projects\Lessons\Lesson5 ในแต่ละบทเรียนของโปรแกรม ฉันเรียกว่า scetch_5_1, scetch_5_2, ... คุณสามารถทำเช่นเดียวกันหรือเข้าสู่ระบบการบันทึกไฟล์ของคุณเอง

บล็อกโปรแกรม:

สถานะปุ่ม = digitalRead(12); - อ่านสถานะของอินพุต 12 (ปุ่ม) และเขียนไปที่ buttonState
สถานะปุ่ม = ! ปุ่มสถานะ; - การผกผันของตัวแปร buttonState
digitalWrite (13, สถานะปุ่ม); - เขียนสถานะจาก buttonState ไปยังเอาต์พุต 13 (LED)

สามารถเขียนได้โดยไม่ต้องใช้ตัวแปร buttonState ระดับกลาง

digitalWrite(13, ! digitalRead(12));

อาร์กิวเมนต์ของฟังก์ชัน digitalWrite() คือฟังก์ชัน digitalRead() สไตล์ที่ดีเป็นเพียงตัวเลือกดังกล่าว ไม่ต้องใช้ตัวแปรเพิ่มเติม ใช้ข้อความน้อยลง

เหล่านั้น. ฟังก์ชันสามารถใช้เป็นอาร์กิวเมนต์ของฟังก์ชันอื่นได้ สามารถเรียกใช้ฟังก์ชันได้จากฟังก์ชัน

โปรแกรมเดียวกันเวอร์ชันอื่นที่ใช้คำสั่ง if แบบมีเงื่อนไข

/* โปรแกรม scetch_5_2 บทที่ 5
ไฟ LED สว่างขึ้น (พิน 13) เมื่อกดปุ่ม (พิน 12) */

การตั้งค่าเป็นโมฆะ () (
พินโหมด(13, เอาท์พุต); - กำหนดพิน 13 (LED) เป็นเอาต์พุต
pinMode(12, INPUT_PULLUP); - กำหนดพิน 12 (ปุ่ม) เป็นอินพุต
}

// วงจรไม่มีที่สิ้นสุด
เป็นโมฆะวน() (
ถ้า (digitalRead(12) == ต่ำ) digitalWrite(13, สูง);
อย่างอื่น digitalWrite (13, ต่ำ);
}

ในการวนซ้ำไม่รู้จบ สถานะของพิน 12 (ปุ่ม) จะถูกตรวจสอบ และหากสถานะต่ำ (LOW) สถานะสูง (HIGH) จะถูกสร้างขึ้นที่พิน 13 (LED) มิฉะนั้นสถานะ LED จะต่ำ

#กำหนดคำสั่ง

ในตัวอย่างทั้งหมดสำหรับฟังก์ชันอินพุต/เอาท์พุต เราได้ระบุอาร์กิวเมนต์พิน ซึ่งกำหนดหมายเลขพินเป็นตัวเลขเฉพาะ - ค่าคงที่ เราจำได้ว่าค่าคงที่ 12 คือหมายเลขพินของปุ่ม และ 13 คือหมายเลขพินของ LED สะดวกกว่ามากในการทำงานกับชื่อสัญลักษณ์ เพื่อจุดประสงค์นี้ ในภาษา C จะมีคำสั่งเชื่อมโยงตัวระบุพร้อมค่าคงที่และนิพจน์

คำสั่ง #define กำหนดตัวระบุและลำดับของอักขระที่แทนที่ตัวระบุแต่ละครั้งที่ปรากฏในข้อความของโปรแกรม

โดยทั่วไปจะมีลักษณะดังนี้:

#กำหนดชื่อ character_sequence

หากเราเขียนในโปรแกรมของเรา:

#กำหนด LED_PIN 13 //

จากนั้นทุกครั้งที่พบชื่อ LED_PIN ในโปรแกรมสัญลักษณ์ 13 จะถูกแทนที่ระหว่างการแปลฟังก์ชั่นการเปิด LED มีลักษณะดังนี้:

digitalWrite (LED_PIN, สูง);

โปรแกรมสุดท้ายโดยใช้ #define

/* โปรแกรมบทเรียนที่ 5
ไฟ LED สว่างขึ้น (พิน 13) เมื่อกดปุ่ม (พิน 12) */

#กำหนด LED_PIN 13 // หมายเลขพิน LED คือ 13
#กำหนด BUTTON_PIN 12 // หมายเลขพินของปุ่มคือ 12

การตั้งค่าเป็นโมฆะ () (
pinMode(LED_PIN, เอาท์พุต); - กำหนดพิน 13 (LED) เป็นเอาต์พุต
pinMode(BUTTON_PIN, INPUT_PULLUP); - กำหนดพิน 12 (ปุ่ม) เป็นอินพุต
}

// วงจรไม่มีที่สิ้นสุด
เป็นโมฆะวน() (
digitalWrite(LED_PIN, ! digitalRead(BUTTON_PIN));
}

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

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