การเชื่อมต่อแป้นพิมพ์เมทริกซ์กับ Arduino การเชื่อมต่อแป้นพิมพ์เมทริกซ์กับการเชื่อมต่อแป้นพิมพ์ Arduino 16 ปุ่ม stm32 arduino

บอร์ดพัฒนา F103C8T6 ที่ใช้ STM32 นั้นเหนือกว่า Arduino Nano หรือ Leonardo ที่มีขนาดใกล้เคียงกันอย่างมากในแง่ของพารามิเตอร์ และความเร็วใกล้เคียงกับ Arduino DUE มีความสนใจที่จะลองใช้ แต่ผู้เริ่มต้นอาจประสบปัญหาในการเปิดและเขียนโปรแกรมบอร์ดนี้เป็นครั้งแรก ตอนนี้คุณสามารถอัพโหลดภาพร่างผ่าน Arduino IDE ได้แล้ว รายละเอียดเพิ่มเติม...

1. ความแตกต่างระหว่าง STM32F103C8T6 และ Arduino Nano v3.0
2. การเตรียมธาตุเหล็ก
3. การเตรียมซอฟต์แวร์
4. กำลังอัปโหลดภาพร่าง (กะพริบ) ไปที่กระดาน

1. ความแตกต่างระหว่าง STM32F103C8T6 และ Arduino Nano v3.0

2. การเตรียมธาตุเหล็ก

ในการทำงานเราจะต้อง:

• ตัวบอร์ด STM32F103C8T6 นั้นเอง
• สายเชื่อมต่อ Dupont หญิงกับหญิง

ในการเปิดใช้งานโหมดการเขียนโปรแกรมต้องตั้งค่าจัมเปอร์บนบอร์ด STM: ตัวแรกถึง 1 ตัวที่สองเป็น 0

สลับตัวแปลง FTDI เป็นแหล่งจ่ายไฟ 3.3 โวลต์ (จัมเปอร์/จัมเปอร์)

เชื่อมต่อบอร์ด (P) และคอนเวอร์เตอร์ (K) ด้วยสายไฟ:

P(A9) -> K(RX)

ป(A10) -> เค(เท็กซัส)

P(GND) -> K(GND)

P(3.3) -> K(VCC)

3. การเตรียมซอฟต์แวร์

1. ดาวน์โหลดส่วนเสริมสำหรับ Arduino IDE ที่จะรองรับบอร์ด STM32
2. แตกไฟล์เก็บถาวรลงในโฟลเดอร์ HARDWARE ซึ่งสามารถพบได้ในโฟลเดอร์ Arduino IDE ของคุณ
3. เปิด Arduino IDE (หรือรีสตาร์ทหากเปิดอยู่) และตรวจสอบว่าพาร์ติชันปรากฏขึ้นหรือไม่ บอร์ด STM32ในรายการ Plats
   

4. การอัปโหลดภาพร่าง (กะพริบ) ไปที่กระดาน

ในโฟลเดอร์ที่เราแตกไฟล์ในขั้นตอนที่ 3.b ให้ไปที่พาธต่อไปนี้: Arduino_STM32\examples\Digital\Blink\ และผ่าน Arduino IDE ให้เปิดไฟล์ Blink.ino หรือคุณสามารถรับข้อความจากที่นี่:

• เลือกบอร์ด ซีรีส์ STM32F103C ทั่วไป
• เลือก ตัวแปร: (20k RAM แฟลช 64k)
• เลือก วิธีการอัพโหลด: "อนุกรม"
• เลือก ท่าเรือ:(พอร์ตที่สอดคล้องกับตัวแปลง FTDI)

กดปุ่ม โหลดและควรเห็นผลทันที

• บทช่วยสอน

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

หัวข้อ Arduino ดึงดูดความสนใจของมนุษยชาติมากขึ้น แต่ไม่ช้าก็เร็วเราก็ต้องเผชิญกับความจริงที่ว่าเราขาดบางสิ่งบางอย่างไป เช่น งบประมาณ/ขนาด/พินพอร์ต/ความจุบิต/ประสิทธิภาพ... ดังที่ปราชญ์คนหนึ่งกล่าวไว้ - “ใครอยากได้ก็แสวงหาโอกาส “ใครไม่อยากก็หาเหตุผล”

คนดีๆ เข้าใจสิ่งนี้ และค่อยๆ เริ่มแนะนำ STM32 ในหัวข้อ Arduino เนื่องจากไมโครคอนโทรลเลอร์ AVR 8 บิต ซึ่งใช้บอร์ด Arduino จำนวนมาก ไม่สามารถรับมือกับงานที่ได้รับมอบหมายได้เสมอไป

บทสรุปโดยย่อของบทความนี้ในรูปแบบวิดีโอ:

เริ่มต้นด้วยการเปรียบเทียบพารามิเตอร์หลักของบอร์ด STM32 และราคาอะนาล็อก - Arduino Nano V3.0:

• ความถี่ในการทำงาน 72 MHz เทียบกับ 16 สำหรับ Arduino;
• ความจุหน่วยความจำแฟลช 64 KB เทียบกับ 32;
• STM32 มี RAM มากถึง 20 KB หรือที่เรียกว่า RAM (ซึ่งเป็นที่เก็บตัวแปร) ในขณะที่ Arduino มีเพียง 2 ตัวเท่านั้น
• ADC 12 บิตที่รวดเร็ว ในขณะที่บอร์ด Arduino ที่ใช้ไมโครคอนโทรลเลอร์ AVR (ซึ่งโดยปกติจะเป็นส่วนใหญ่) จะใช้ ADC 10 บิต หมายความว่าในกรณีของ STM32 ฟังก์ชัน analogRead(*); จะส่งคืนค่า 0..4095 เทียบกับ 0..1023 ซึ่งในกรณีแรกจะทำให้การวัดแม่นยำยิ่งขึ้น
• PWM ฮาร์ดแวร์ 16 บิต เทียบกับ 8 บนบอร์ด Arduino นั่นคือฟังก์ชัน analogWrite(*) pwmWrite(*); สามารถรับค่า 0..65535 เทียบกับค่าแย่ 0..255 ซึ่งจะช่วยให้เราควบคุมมอเตอร์ เซอร์โว และอุปกรณ์อื่นๆ ที่ขับเคลื่อนด้วย PWM ได้แม่นยำยิ่งขึ้น
• ฮาร์ดแวร์ใช้งานได้กับ USB ซึ่งไม่ใช่บอร์ด Arduino ตัวเดียวที่มีราคาต่ำกว่า 2 ดอลลาร์สามารถอวดได้
• แรงดันไฟฟ้า - ตั้งแต่ 2 ถึง 3.6V (ปรับแต่งโดยตรงสำหรับแบตเตอรี่ AA 2 ก้อน) เทียบกับ 2.7...5V สำหรับบอร์ด Arduino;
• ราคาในขณะที่เขียนคือ 1.9 ดอลลาร์เทียบกับ 1.8 (aliexpress)

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

เรามาเริ่มเตรียมบอร์ดเพื่อใช้งานกับ Arduino IDE กันดีกว่า สิ่งแรกที่คุณต้องทำคืออัปโหลด bootloader พิเศษลงในไมโครคอนโทรลเลอร์ ซึ่งจะช่วยให้คุณสามารถแฟลชบอร์ดผ่านฮาร์ดแวร์ USB ได้โดยตรงจากสภาพแวดล้อมการพัฒนา ในการดำเนินการนี้ คุณจะต้องย้ายจัมเปอร์ด้านบน (หรือที่เรียกว่า "BOOT0") ไปที่ตำแหน่ง "1":

จัมเปอร์ BOOT0 และ BOOT1 มีไว้เพื่ออะไร?

ความจริงก็คือ STM32 มี bootloader พิเศษที่แฟลชจากโรงงานไปยังหน่วยความจำระบบที่เรียกว่าซึ่งช่วยให้คุณสามารถแฟลชบอร์ดผ่านอะแดปเตอร์ USB เป็น UART ที่ใช้กันทั่วไปโดยไม่ต้องใช้โปรแกรมเมอร์ประเภทเฉพาะ เอสที-ลิงค์ V2.

ต่อไปเราต้องมีอะแดปเตอร์จาก USB เป็น UART มันคุ้มค่าที่จะจดจำสิ่งนั้น STM32 นี่คือลอจิก 3.3 Vไม่รับประกันความเข้ากันได้กับ 5V ดังนั้นจึงขอแนะนำให้ใช้ USB เป็น UART ซึ่งมีความสามารถในการเลือกโหมดการทำงานด้วยตรรกะ 3.3/5V ฉันใช้อะแดปเตอร์ราคาถูกที่ใช้ CH340G:

* อย่างที่คุณเห็นผู้ผลิตไม่ได้สนใจในการถอดฟลักซ์ออก แต่แน่นอนว่าไม่มีผลกระทบต่องานแต่อย่างใด

ฉันเชื่อมต่อบอร์ดกับอะแดปเตอร์ USB เป็น UART ดังนี้:

ช<->จีเอ็นดี;
5V<->5V;
PA10<->เท็กซัส;
PA9<->RXD.

* PA10/PA9 บนบอร์ดมีป้ายกำกับง่ายๆ ว่า A10/A9 - พอร์ตเหล่านี้เป็นฮาร์ดแวร์ USART ตัวแรก มี 3 พอร์ตบนบอร์ด นอกจากนี้ยังมีฮาร์ดแวร์ I2C 2 ตัวและ SPI 2 ตัว

เพื่อความสะดวกฉันจึงจ่ายไฟให้กับบอร์ดจาก 5 V สำหรับไฟจาก 3.3 V มีพิน "3.3" บนบอร์ด โปรดทราบ 5 V อาจทำให้ไมโครคอนโทรลเลอร์เสียหายได้ง่ายดังนั้นควรใส่ใจกับการเชื่อมต่อด้วย

ดาวน์โหลด ติดตั้ง และรัน Flash Loader Demonstrator (มีอยู่ในไฟล์เก็บถาวรสำหรับบทความ):

เราเลือกหมายเลขพอร์ต COM ของอะแดปเตอร์ของเรา ในกรณีของฉันคือ COM43 จากนั้นคลิก "ถัดไป":

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

คลิก "ตกลง":

เนื่องจากบอร์ดพัฒนาของฉันใช้ไมโครคอนโทรลเลอร์ STM32F103 C8- มีหน่วยความจำ Flash ขนาด 64 KB นอกจากนี้ยังมี STM32F103 ซี.บี.ไมโครคอนโทรลเลอร์ที่มีแฟลชมากกว่าสองเท่า

“ถัดไป” อีกครั้ง และเราจะเห็นหน้าต่างต่อไปนี้:

เลือก "ดาวน์โหลดไปยังอุปกรณ์" และคลิกที่ "...":

เราเปลี่ยนประเภทไฟล์เป็น *.bin และเปิดไฟล์ “generic_boot20_pc13.bin” (มีอยู่ในไฟล์เก็บถาวรด้วย) ซึ่งสามารถนำมาจากโครงการ STM32duino-bootloader

จากนั้นคุณจะต้องดาวน์โหลดคอร์ STM32 พิเศษสำหรับสภาพแวดล้อมการพัฒนา Arduino IDE (มีอยู่ในไฟล์เก็บถาวรสำหรับบทความด้วย) มีความแตกต่างเล็กน้อยที่นี่ในขณะที่เขียนบทความนี้ เคอร์เนลไม่ทำงานบนสภาพแวดล้อมการพัฒนาเวอร์ชันที่สูงกว่า 1.6.5ฉันมี 1.6.5-r5 ซึ่ง
ประสิทธิภาพของเคอร์เนลได้รับการทดสอบบน.

ในกรณีของฉัน เส้นทางแบบเต็มจะเป็นดังนี้ - “C:\Users\RSK\Documents\Arduino\hardware”

แน่นอนว่าระบบจะไม่สามารถตรวจจับอุปกรณ์ได้ ดังนั้นคุณต้องติดตั้งไดรเวอร์บนบอร์ดด้วย ไปที่โฟลเดอร์ “My Documents\Arduino\hardware\Arduino_STM32\drivers\win” (หรือ “drivers\win” ในกรณีที่เป็นไฟล์เก็บถาวรสำหรับบทความ) และเรียกใช้ไฟล์ “install_drivers.bat” ในฐานะผู้ดูแลระบบ:

หลังจากนั้น ให้ย้ายจัมเปอร์ด้านบน (อันที่เป็น “BOOT0”) ไปที่ตำแหน่ง “0” และเชื่อมต่อบอร์ดเข้ากับคอมพิวเตอร์ผ่านสาย microUSB:

ควรกำหนดไว้ในตัวจัดการอุปกรณ์เป็น “Maple DFU” หรือ “Maple Serial (COM*)”:

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

ที่นี่คุณจะต้องติดตั้งเคอร์เนลสำหรับบอร์ด Arduino Due เลือกเวอร์ชันล่าสุดแล้วคลิก "ติดตั้ง":

จากนั้นเครื่องมือ -> บอร์ด -> "Generic STM32F103C" จากนั้นเลือกตัวแปร: "STM32F103C8 (20k RAM. 64k Flash)", วิธีการอัปโหลด: "STM32duino bootloader", พอร์ต - หมายเลขพอร์ต COM ของบอร์ดโดยทั่วไปทุกอย่างเป็น เช่นเดียวกับในภาพหน้าจอ:

เพียงเท่านี้ บอร์ดก็พร้อมสำหรับเฟิร์มแวร์และการเขียนโปรแกรมในสภาพแวดล้อมการพัฒนา Arduino IDE เรามาฉายภาพร่างจากตัวอย่างที่ "เย็บ" ลงในเคอร์เนลกัน ไปที่ File -> Folder with Sketches -> hardware -> Arduino_STM32 -> STM32F1 -> libraries -> A_STM32_Examples -> Digital -> Blink:

“Hello World” สุดคลาสสิกในโลกของไมโครคอนโทรลเลอร์ เราเปลี่ยน PB1 เป็น PC13 เนื่องจาก LED บนบอร์ดเชื่อมต่อกับพอร์ตนี้:

* อีกอย่างไฟจะสว่างที่ระดับต่ำบนขา PC13

คลิกปุ่ม "อัปโหลด" หลังจากกระพริบเฟิร์มแวร์แล้ว สภาพแวดล้อมการพัฒนาจะแสดงสิ่งที่ต้องการ:

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

แต่โหลดเฟิร์มแวร์ได้สำเร็จแม้ว่าจะไม่เป็นเช่นนั้นเสมอไป แต่บางครั้ง Arduino IDE จะแสดงข้อความอื่น ๆ

ไม่พบอุปกรณ์ DFU

เมื่อคุณเห็นข้อความเช่น:

"dfu-util - © 2007-2008 โดย OpenMoko Inc.
ไม่พบอุปกรณ์ DFU:
โปรแกรมนี้เป็นซอฟต์แวร์ฟรีและไม่มีการรับประกันอย่างแน่นอน"

ซึ่งหมายความว่าไม่สามารถแฟลชบอร์ดได้

กำลังค้นหาอุปกรณ์ DFU...

เมื่อปัญหาเกี่ยวกับสภาพแวดล้อมการพัฒนา:

"กำลังค้นหาอุปกรณ์ DFU...
สมมติว่าบอร์ดอยู่ในโหมด perpetual bootloader และพยายามเขียนโปรแกรม dfu ต่อไป…”

และไม่มีอะไรเกิดขึ้นอีก ลองรีบูตบอร์ดในขณะนี้โดยคลิกปุ่มรีเซ็ต หากเทียบกันแล้ว ก็เหมือนกับ Arduino Pro Mini

และตอนนี้เกี่ยวกับ "แมลงวันในครีม" ที่ฉันเขียนไว้ตอนต้นบทความ: ด้วยเหตุผลบางประการจึงเป็นไปไม่ได้เสมอไปที่จะแฟลชบอร์ดในสภาพแวดล้อมการพัฒนา ยิ่งไปกว่านั้นคอมพิวเตอร์ก็ไม่ได้ตรวจพบเสมอไป . ฉันตัดสินใจสิ่งนี้ด้วยตัวเองด้วยวิธีต่อไปนี้: ก่อนที่จะโหลดเฟิร์มแวร์ (ก่อนที่จะคลิกปุ่ม "อัปโหลด") ฉันคลิก "รีเซ็ต" บนบอร์ดและหลังจากกระพริบเฟิร์มแวร์ฉันก็รีบูทบอร์ดอีกครั้ง ในกรณีนี้ เปอร์เซ็นต์ความน่าจะเป็นที่กระดานจะกระพริบคือ 99% ยังไม่ชัดเจนว่าเหตุใดจึงทำงานในลักษณะนี้ แต่เป็นข้อเท็จจริง ฉันคิดว่าไม่ช้าก็เร็วข้อผิดพลาดนี้จะได้รับการแก้ไข และทุกอย่างจะรีบูตโดยอัตโนมัติตามความจำเป็น และเพื่อแก้ไขปัญหานี้ให้เร็วขึ้น ชุมชนของบอร์ดดีบัก STM32 ที่ยอดเยี่ยมนี้จำเป็นต้องเติบโต ดังนั้นแบ่งปันบทความนี้กับเพื่อน ๆ ของคุณ โดยเฉพาะเพื่อนโปรแกรมเมอร์ของคุณ

เกี่ยวกับพินเอาท์:

คลิกได้

สิ่งที่ดีที่สุดที่ฉันหาได้คือ pinout ของไมโครคอนโทรลเลอร์เอง (เปิดในแท็บใหม่):

(ค) www.stm32duino.com/viewtopic.php?p=11137

ต้องเข้าถึงพอร์ตด้วยชื่อเต็ม ตัวอย่างเช่น:

digitalWrite (PB0, ต่ำ);
อะนาล็อกเขียน(PA8, 65535); pwmWrite(PA8, 65535);
อะนาล็อกอ่าน(PA0);
จอแอลซีดีคริสตัลเหลว (PB0, PA7, PA6, PA5, PA4, PA3);

ฉันขอแนะนำให้ไปที่เว็บไซต์ docs.leaflabs.com/docs.leaflabs.com/index.html มีสิ่งที่น่าสนใจมากมายในหัวข้อการเขียนโปรแกรมใน Arduino IDE แม้ว่าจะเป็นภาษาอังกฤษก็ตาม

ฉันค้นหาไฟล์เคอร์เนลและพบไฟล์ที่น่าสนใจหนึ่งไฟล์:
เอกสาร\Arduino\hardware\Arduino_STM32\STM32F1\variants\generic_stm32f103c\board.cpp

พอร์ตทั้งหมดที่รองรับมีอยู่ในรายการ:

• PWM นั่นคือฟังก์ชัน analogWrite() pwmWrite(); - PB0, PA7, PA6, PA3, PA2, PA1, PA0, PB7, PB6, PA10, PA9, PA8 และนี่ไม่ใช่ทั้งหมดที่มีการทำเครื่องหมายไว้บน pinout ของชิป
• ADC หรืออ่านแบบอะนาล็อก(); - PB0, PA7, PA6, PA5, PA4, PA3, PA2, PA1, PA0.

ดังนั้นจงจำไว้เสมอ แม้ว่านี่จะเกินพอสำหรับบอร์ดราคา 1.9 ดอลลาร์ก็ตาม

ฉันยังสังเกตเห็นว่าพิน PA12/PA11 เชื่อมต่อกับ D+/D- USB อีกครั้ง เป็นการดีกว่าที่จะไม่แตะต้องพวกมันเลย เพราะสิ่งที่เป็นเดิมพันไม่ใช่ไฟเบอร์กลาสราคา 2 ดอลลาร์ที่มีชิป แต่เป็นมาเธอร์บอร์ดของคอมพิวเตอร์ .

แผนภาพคณะกรรมการพัฒนา:

และในที่สุดก็:

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

ข้อความส่วนใหญ่มีคำอธิบายเกี่ยวกับโค้ดโปรแกรม คุณสามารถดาวน์โหลดหรือดูวิดีโอด้านล่างบทความได้

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

แป้นพิมพ์เมทริกซ์มีไว้เพื่ออะไร?

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

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

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

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

หลังจากที่คุณติดตั้งลงในไลบรารีแล้ว คุณสามารถไปที่ Arduino IDE (โปรแกรมจากเว็บไซต์ Arduino) และดูภาพร่างตัวอย่างได้

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

#รวม // เชื่อมต่อห้องสมุดของเรา




{"2","5","8","0"},
{"3","6","9","#"},
("เอบีซีดี")
};




การตั้งค่าเป็นโมฆะ())(
อนุกรม.เริ่มต้น(9600);
}
เป็นโมฆะวน()

ถ้า (customKey)(
อนุกรม.println(customKey);
}
}

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

หากทำไม่ถูกต้อง ตัวอย่างเช่น เมื่อคุณกดหมายเลข 4 หมายเลข 6 หรือสัญลักษณ์อื่น ๆ จะถูกส่งไปยังพอร์ต ซึ่งสามารถกำหนดได้ด้วยประสบการณ์และสามารถจัดเรียงอักขระตามที่อยู่บนแป้นพิมพ์ได้

ในการทำงาน การตั้งค่าเป็นโมฆะระบุความเร็วของการเชื่อมต่อแบบอนุกรมกับมอนิเตอร์พอร์ต 9600 บอด- ฟังก์ชันนี้จำเป็นสำหรับการจ่ายไฟให้กับโมดูลเท่านั้น ในการทำงาน วงโมฆะเราเขียนเงื่อนไข ตัวแปร ถ่านใช้สำหรับจัดเก็บอักขระเพียงตัวเดียว เช่น 1, A หรือ 5 แล้วแต่จำนวนใดจะเหมาะสมกับสถานการณ์ หากมีการลงทะเบียนการกด สัญลักษณ์จะถูกส่งออกไปยังมอนิเตอร์พอร์ตโดยใช้ฟังก์ชัน การพิมพ์แบบอนุกรมในวงเล็บ คุณต้องระบุว่าตัวแปรใดกำลังส่งออกไปยังพอร์ต หากทุกอย่างถูกต้องในการตรวจสอบพอร์ตเราจะได้รับสัญลักษณ์ที่ถูกคลิก อย่าลืมตั้งค่าอัตราการถ่ายโอนข้อมูลในมอนิเตอร์พอร์ตที่ด้านล่างขวาให้เท่ากับในภาพร่าง

วงจรพร้อมจอแสดงผลและแป้นพิมพ์เมทริกซ์

มาแสดงข้อมูลกัน

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

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

#รวม // เชื่อมต่อห้องสมุดของเรา
#รวม
จอแอลซีดี LiquidCrystal_I2C (0x27, 16, 2);
ไบต์ const แถว = 4; //จำนวนบรรทัดบนคีย์บอร์ดของเรา
const ไบต์ COLS = 4; //จำนวนคอลัมน์สำหรับคีย์บอร์ดของเรา
ถ่าน hexaKeys = (
(“S”,”4”,”7”,”*”), // ที่นี่เราใส่ชื่อคีย์ของเรา เช่น บนคีย์บอร์ด เพื่อความสะดวกในการใช้งาน
("โอ", "5", "8", "0"),
("ส", "6", "9", "#"),
("ฉัน", "B", "C", "D")
};
ไบต์แถวพิน = (5, 4, 3, 2); // เราเชื่อมต่อการควบคุมบรรทัดกับพินใด
ไบต์ colPins = (9, 8, 7, 6); // เราเชื่อมต่อการควบคุมคอลัมน์กับพินใด
// เริ่มต้นอินสแตนซ์ของคลาส NewKeypad
ปุ่มกด customKeypad = ปุ่มกด (makeKeymap (hexaKeys), rowPins, colPins, ROWS, COLS);
การตั้งค่าเป็นโมฆะ())(
อนุกรม.เริ่มต้น(9600);
จอแอลซีดี.เริ่มต้น(); // เริ่มต้นหน้าจอ
จอแอลซีดีแบ็คไลท์();
}
เป็นโมฆะวน()
ถ่าน customKey = customKeypad.getKey();
ถ้า (customKey)(
อนุกรม.println(customKey);
จอแอลซีดี setCursor (1,4); //ตั้งเคอร์เซอร์
จอแอลซีดีพิมพ์(customKey);
}
}

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

เนื่องจากจอแสดงผลทำงานผ่านอินเทอร์เฟซ I2C เราจึงเชื่อมต่อเข้ากับพินอะนาล็อก เราเชื่อมต่อเอาต์พุต SDA และ SCL เข้ากับ A4 และ A5 ตามลำดับ และอีกสองเอาต์พุตที่เหลือเป็นแบบจ่ายไฟและกราวด์อยู่แล้ว

อย่างที่คุณเห็นเมื่อคลิกที่สัญลักษณ์ใด ๆ เราจะเห็นการแสดงผลบนหน้าจอ

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

การเชื่อมต่อคีย์บอร์ดกับ Arduino และการควบคุมการทำงาน

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

ลองเปิดหรือปิด LED เมื่อกดปุ่มบางปุ่ม เพิ่มลงในไดอะแกรม

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

ฉันจะใช้เขียงหั่นขนมและตัวต้านทาน (ควรอยู่ระหว่าง 150 ถึง 220 โอห์ม) ฉันจะปิดวงจรด้วยจัมเปอร์สองตัวโดยเชื่อมต่อเข้ากับพินกำลังและกราวด์บนบอร์ด Arduino

วงจรจะทำงานดังนี้: เมื่อคุณกด 1 ไฟ LED จะเปิดขึ้น เมื่อคุณกด 2 ไฟ LED จะดับลง

LED ในตัวอย่างเชื่อมต่อกับขา 8 บนบอร์ด Arduino

#รวม
ไบต์ const แถว = 4; // สี่แถว
const ไบต์ COLS = 4; // สามคอลัมน์
ปุ่มถ่าน = ( // กำหนด Keymap
("1", "4", "7", "*"), // ที่นี่เราใส่ชื่อคีย์ของเรา เช่น บนแป้นพิมพ์ เพื่อความสะดวกในการใช้งาน
{"2","5","8","0"},
{"3","6","9","#"},
("เอบีซีดี")
};
ไบต์ rowPins = ( 5, 4, 3, 2 ); // เชื่อมต่อปุ่มกด ROW0, ROW1, ROW2 และ ROW3 เข้ากับพิน Arduino เหล่านี้
ไบต์ colPins = ( 9, 8, 7,6); // เชื่อมต่อปุ่มกด COL0, COL1 และ COL2 เข้ากับพิน Arduino เหล่านี้
ปุ่มกด kpd = ปุ่มกด (makeKeymap (คีย์), rowPins, colPins, ROWS, COLS); // สร้างปุ่มกด
#กำหนด ledpin 8
การตั้งค่าเป็นโมฆะ ()
{
pinMode (ledpin, เอาท์พุท);
อนุกรม.เริ่มต้น(9600);
}
เป็นโมฆะวน()
{
คีย์ถ่าน = kpd.getKey();
if(key) // ตรวจสอบคีย์ที่ถูกต้อง
{
สวิตช์ (กุญแจ)
{
กรณี "1":
digitalWrite (ledpin, สูง);
หยุดพัก;
กรณี "2":
digitalWrite (ledpin, ต่ำ);
หยุดพัก;
}
}
}

มาดูภาพร่างกัน

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

ถ้าไม่ใช่เพราะห้องสมุด ปุ่มกดสำหรับคีย์บอร์ด คุณจะต้องเขียนเหมือนกันสำหรับ 8 พินที่เชื่อมต่อคีย์บอร์ดอยู่ ในการทำงาน ห่วงเป็นโมฆะเงื่อนไข. การกดคีย์ใดคีย์หนึ่งจะ "เท่ากัน" กับค่าของตัวแปร สำคัญ.คำสั่ง Switch จะเปรียบเทียบค่าของตัวแปร สำคัญและ “ให้” คำสั่งบางอย่างขึ้นอยู่กับค่านี้ ประกอบด้วยตัวดำเนินการเสริมสองตัว กรณีและ หยุดพัก- พูดง่ายๆ ก็คือ หากพบค่าตัวแปรเท่ากับ 1 การดำเนินการก็จะดำเนินการ ผู้ดำเนินการ หยุดพักทำหน้าที่เป็นคำสั่งออกจากคำสั่ง กรณี.

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

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

คีย์บอร์ดที่ใช้กันมากที่สุดสำหรับ Arduino คือ:

คีย์บอร์ด 4x4 แบบ 16 คีย์ที่พบบ่อยที่สุด หลักการทำงานนั้นค่อนข้างง่าย Arduino จะสลับตรรกะหนึ่งอันให้กับแต่ละคอลัมน์ 4 คอลัมน์ ในขณะนี้ อินพุต 4 ตัวของ Arduino อ่านค่าและมีอินพุตเดียวเท่านั้นที่ส่งสูง มันค่อนข้างง่ายถ้าคุณทราบความสามารถในการจัดการพอร์ตเอาท์พุตใน Arduino รวมถึงพอร์ตอินพุต/อินพุต

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

เราเชื่อมต่อคีย์บอร์ดเข้ากับพอร์ตอินพุต/เอาท์พุตใดๆ

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

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

Int PinOut (5, 4, 3, 2); // พินเอาท์พุต int PinIn (9, 8, 7, 6); // อินพุตพิน int val = 0; ค่าถ่าน const ( ("1", "4", "7", "*"), ("2", "5", "8", "0" ), ("3", "6", " 9", "#"), ("A", "B", "C", "D") ); // อาร์เรย์คู่แสดงถึงปุ่ม int b = 0; // ตัวแปรที่มีการวางตัวเลขจากอาร์เรย์ (หมายเลขปุ่ม) การตั้งค่าเป็นโมฆะ () ( pinMode (2, OUTPUT); // เตรียมใช้งานพอร์ตเอาต์พุต (จ่ายศูนย์ให้กับคอลัมน์) pinMode (3, OUTPUT); pinMode (4 , OUTPUT) ; pinMode (5, OUTPUT); pinMode (6, INPUT); ; digitalWrite(8, HIGH); digitalWrite(9, HIGH); // เปิดพอร์ตอนุกรม ) โมฆะเมทริกซ์ () // สร้างฟังก์ชันสำหรับปุ่มอ่าน ( for (int i = 1; i<= 4; i++) // цикл, передающий 0 по всем столбцам { digitalWrite(PinOut, LOW); // если i меньше 4 , то отправляем 0 на ножку for (int j = 1; j <= 4; j++) // цикл, принимающих 0 по строкам { if (digitalRead(PinIn) == LOW) // если один из указанных портов входа равен 0, то.. { Serial.println(value); // то b равно значению из двойного массива delay(175); } } digitalWrite(PinOut, HIGH); // подаём обратно высокий уровень } } void loop() { matrix(); // используем функцию опроса матричной клавиатуры }

การใช้ไลบรารีทำให้การอ่านข้อมูลจากแป้นพิมพ์ตัวเลขง่ายขึ้น

#รวม ไบต์ const แถว = 4; const ไบต์ COLS = 3; ปุ่มถ่าน = (("1", "2", "3"), ("4", "5", "6"), ("7", "8", "9"), ("#" ,"0", "*") ); ไบต์ rowPins = (5, 4, 3, 2); ไบต์ colPins = (8, 7, 6); ปุ่มกด = ปุ่มกด (makeKeymap (คีย์), rowPins, colPins, ROWS, COLS); การตั้งค่าเป็นโมฆะ())( Serial.begin(9600); ) void loop())( char key = keypad.getKey(); if (key != NO_KEY)( Serial.println(key); ) )

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

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

สำหรับงานที่อธิบายไว้ในบทความนี้ เราใช้บอร์ดดีบัก STM32F4Discovery และแป้นพิมพ์เมทริกซ์ ในกรณีของเรามี 7 พิน สภาพแวดล้อมการพัฒนา CoIDE 1.7.6

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

ก่อนที่เราจะเริ่มเขียนโปรแกรม เรามากำหนดข้อตกลงกันก่อน:

1. พินที่เชื่อมต่อคีย์บอร์ดแบ่งออกเป็นสองกลุ่ม: การสแกนและแหล่งจ่ายไฟ (รูปที่ 1) หมุดสแกนทำงานเป็นอินพุต พินจ่ายไฟทั้งหมดถูกตั้งค่าเป็นศูนย์ตามค่าเริ่มต้น แต่หลังจากการรีเซ็ตตัวจับเวลา TIM2 ครั้งแรก แรงดันไฟฟ้าลอจิคัล "1" จะถูกตั้งค่าที่พิน PA3 ดังนั้นด้วยการประมาณบางอย่างเราสามารถพูดได้ว่าชุดค่าผสม "1" ถูกตั้งค่าไว้ที่ จ่ายพินในแต่ละครั้งใกล้กับพินเริ่มต้น -0-0-0"
2. ตามข้อความของโปรแกรม การกำหนดพินจะสอดคล้องกับรูปที่ 1 นั่นคือ ค่าของพิน PA0, PA1, PA2 เมื่อทำการโพลจะถูกเขียนไปยังตัวแปร a, b, c ตามลำดับเพื่อดำเนินการต่อไป
3. หมุดจ่ายไฟ PA3 - PA4 ถูกกำหนดตั้งแต่ 1 ถึง 4 ซึ่งเป็นตัวเลขที่กล่าวถึงในข้อความของโปรแกรม

รูปที่ 1 – การเชื่อมต่อคีย์บอร์ด

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

เมื่อสิ้นสุดแต่ละรอบ ตัวจับเวลา TIM3 จะสแกนสถานะของพิน PA0-PA2 โดยเขียนผลลัพธ์ลงในตัวแปร a, b และ c จากนั้น ไมโครคอนโทรลเลอร์จะเปรียบเทียบว่าพินจ่ายไฟตัวใดมีแรงดันไฟฟ้าแบบลอจิคัล “1” (ตัวแปร out_state) และพิน PA0 – PA2 ตัวใดมีระดับลอจิคัลสูง (ตัวแปร a, b, c) การดำเนินการเหล่านี้ดำเนินการโดยฟังก์ชัน TIM3_IRQHandler (ตัวจัดการขัดจังหวะจากตัวจับเวลา 3)

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

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

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

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

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

ตอนนี้เรามาพูดถึงการเริ่มต้นอุปกรณ์ต่อพ่วงที่ใช้ โปรเจ็กต์นี้ใช้พอร์ต A และ D เป็นพอร์ต I/O รวมถึงตัวจับเวลา TIM2 และ TIM3 รายการโปรแกรมมาพร้อมกับความคิดเห็นโดยละเอียดเกี่ยวกับรายการการตั้งค่าอุปกรณ์ต่อพ่วง