การแสดงผล 7 ส่วนเชื่อมต่อกับไมโครคอนโทรลเลอร์ pic

นี่คือวิธีการสอนที่ 8 ของเราในการเรียนรู้ไมโครคอนโทรลเลอร์ PIC ใช้ MPLAB XC8 เราคิดมาตลอดตั้งแต่การติดตั้ง MPLABX ไปจนถึงการใช้ LCD พร้อม PIC MCU หากคุณยังใหม่อยู่ที่นี่ให้ดูบทช่วยสอนก่อนหน้านี้ซึ่งคุณสามารถเรียนรู้ตัวจับเวลาไฟ LED กะพริบการเชื่อมต่อ LCD ฯลฯ คุณสามารถดูบทแนะนำ PIC ทั้งหมดของเราได้ที่นี่ ในการกวดวิชาสุดท้ายที่เราเห็นเราวิธีการที่เราสามารถสร้างตัวละครที่กำหนดเองที่มีจอแสดงผล LCD ของเรา 16 * 2 ตอนนี้ให้เราจัดให้ตัวเองของเรากับชนิดของการแสดงโมดูลอื่นที่เรียกว่าจอแสดงผล 7 ส่วนและติดต่อกับไมโครคอนโทรลเลอร์

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

7-Segment และ 4-Digit 7-Segment Display Module:

7 Segment Display มีเจ็ดส่วนในนั้นและแต่ละส่วนมี LED หนึ่งดวงอยู่ข้างในเพื่อแสดงตัวเลขโดยการส่องสว่างส่วนที่เกี่ยวข้อง เช่นเดียวกับถ้าคุณต้องการให้ 7 ส่วนแสดงหมายเลข "5" คุณต้องเรืองแสงส่วน a, f, g, c และ d โดยทำให้หมุดที่เกี่ยวข้องสูง มีการแสดง 7 เซ็กเมนต์สองประเภท: แคโทดทั่วไปและแอโนดทั่วไปที่นี่เรากำลังใช้การแสดงส่วนแคโทดเจ็ดส่วนทั่วไป เรียนรู้เพิ่มเติมเกี่ยวกับการแสดงผล 7 ส่วนที่นี่

ตอนนี้เรารู้วิธีแสดงอักขระตัวเลขที่เราต้องการบนจอแสดงผล 7 ส่วนเดียว แต่เห็นได้ชัดว่าเราต้องการจอแสดงผล 7 ส่วนมากกว่าหนึ่งจอเพื่อถ่ายทอดข้อมูลใด ๆ ที่มากกว่าหนึ่งหลัก ดังนั้นในบทช่วยสอนนี้เราจะใช้โมดูลการแสดงผล 7 ส่วน 4 หลักดังที่แสดงด้านล่าง

อย่างที่เราเห็นมีการเชื่อมต่อจอแสดงผลเจ็ดส่วนสี่ส่วนเข้าด้วยกัน เราทราบดีว่าโมดูล 7 เซ็กเมนต์แต่ละโมดูลจะมี 10 พินและสำหรับ 4 เซกเมนต์เจ็ดส่วนจะมีทั้งหมด 40 พินและมันจะเป็นเรื่องยากสำหรับทุกคนที่จะบัดกรีพวกมันบนกระดานดอทดังนั้นฉันขอแนะนำให้ทุกคนซื้อโมดูล หรือสร้าง PCB ของคุณเองโดยใช้จอแสดงผล 7 ส่วน 4 หลัก แผนผังการเชื่อมต่อสำหรับสิ่งเดียวกันดังแสดงด้านล่าง:

เพื่อให้เข้าใจว่าโมดูลเซกเมนต์ 7 หลัก 4 หลักทำงานอย่างไรเราต้องดูแผนผังข้างต้นดังที่แสดงหมุด A ของจอแสดงผลทั้งสี่จอเชื่อมต่อเพื่อรวบรวมเป็น A เดียวและเหมือนกันสำหรับ B, C…. ไม่เกิน DP โดยพื้นฐานแล้วถ้าทริกเกอร์ A เปิด A ทั้งสี่ตัวควรจะสูงใช่ไหม?

แต่นั่นไม่ได้เกิดขึ้น เรามีพินเพิ่มเติมอีกสี่พินจาก D0 ถึง D3 (D0, D1, D2 และ D3) ซึ่งสามารถใช้เพื่อควบคุมว่าการแสดงผลใดจากทั้งสี่ควรอยู่ในระดับสูง ตัวอย่างเช่นหากฉันต้องการให้เอาต์พุตของฉันแสดงเฉพาะบนจอแสดงผลที่สองควรทำให้ D1 สูงเท่านั้นในขณะที่ทำให้พินอื่น ๆ (D0, D2 และ D3) ต่ำ เพียงแค่เราสามารถเลือกได้ว่าจะให้จอแสดงผลใดใช้งานได้โดยใช้หมุดจาก D0 ถึง D3 และอักขระใดที่จะแสดงโดยใช้หมุดจาก A ถึง DP

การเชื่อมต่อโมดูลเซกเมนต์เจ็ดหลัก 4 หลักกับไมโครคอนโทรลเลอร์ PIC:

ที่นี่เราใช้ไมโครคอนโทรลเลอร์ PIC PIC16F877Aและแผนผังสำหรับวงจรดังแสดงด้านล่าง

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

หมายเหตุ: ขากราวด์ของโมดูลควรเชื่อมต่อกับกราวด์ของ MCU ซึ่งไม่ได้แสดงไว้ที่นี่

การเขียนโปรแกรมโดยใช้ PIC16F877A:

ตอนนี้ที่เรารู้วิธีโมดูลนี้ใช้งานได้จริงให้เราได้เรียนรู้วิธีการ PIC16F877A โปรแกรมที่จะทำให้มันแสดงหมายเลข ให้เราเพิ่มตัวแปรจาก 0 ถึง 1,000 และพิมพ์บนจอแสดงผล 7 ส่วน เปิดโปรแกรม MPLABX และสร้างโครงการใหม่ให้เราเริ่มต้นด้วยบิตการกำหนดค่า

#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (เปิดใช้งาน PWRT) # pragma config BOREN = ON // Brown-out Reset Enable bit (เปิดใช้งาน BOR) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 เป็น Digital I / O, HV บน ต้องใช้ MCLR ในการเขียนโปรแกรม) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory อาจเขียนถึงโดยการควบคุม EECON) #pragma config CP = OFF // บิตการป้องกันรหัสหน่วยความจำโปรแกรมแฟลช (ปิดการป้องกันรหัส)

ตามปกติเราใช้หน้าต่าง set configuration bits เพื่อตั้งค่าบิตเหล่านี้ หากคุณไม่แน่ใจว่าหมายถึงอะไรให้ไปที่บทแนะนำการกะพริบ LED ที่นี่

ต่อไปให้เรากำหนดพินเอาต์พุตสำหรับการสลับระหว่างแต่ละหลักของจอแสดงผล

// *** กำหนดพินสัญญาณของทั้งสี่จอแสดงผล *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** สิ้นสุดการกำหนด ** ////

ที่นี่หมุด RC0, RC1, RC2 และ RC3 ใช้สำหรับเลือกระหว่างตัวเลขสี่หลักของโมดูลการแสดงผล 7 ส่วนของเรา หมุดเหล่านี้กำหนดเป็น s1, s2, s3 และ s4 ตามลำดับ

ต่อไปให้เราข้ามไปที่ void main () ซึ่งเรามีการประกาศตัวแปรต่อไปนี้:

int ผม = 0; // ค่า 4 หลักที่จะแสดง int flag = 0; // สำหรับการสร้างความล่าช้าที่ไม่ได้ลงนาม int a, b, c, d, e, f, g, h; // ตัวแปรที่ไม่ได้ลงนาม int seg = {0X3F, // ค่า Hex เพื่อแสดงตัวเลข 0 0X06, // ค่า Hex เพื่อแสดงตัวเลข 1 0X5B, // ค่า Hex เพื่อแสดงหมายเลข 2 0X4F, // ค่า Hex ที่จะแสดง หมายเลข 3 0X66, // ค่า Hex เพื่อแสดงหมายเลข 4 0X6D, // ค่า Hex เพื่อแสดงตัวเลข 5 0X7C, // ค่า Hex เพื่อแสดงตัวเลข 6 0X07, // ค่า Hex เพื่อแสดงหมายเลข 7 0X7F, / / ค่า Hex เพื่อแสดงตัวเลข 8 0X6F // ค่า Hex เพื่อแสดงตัวเลข 9}; // End of Array สำหรับแสดงตัวเลขตั้งแต่ 0 ถึง 9

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

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

ที่อยู่ของอาร์เรย์เริ่มต้นจากศูนย์เสมอ ดังนั้นอาร์เรย์นี้จะมีค่าฐานสิบหกของตัวเลข (0-9) เก็บไว้ในที่อยู่ซึ่งเหมือนกับของตัวเลขดังที่แสดงด้านล่าง

ตัวแปร:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
รหัส Hex:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. หมายเลขตัวเลข:	0	1	2	3	4	5	6	7	8	9

ดังนั้นหากคุณต้องการแสดงหมายเลข 0 บน 7 ส่วนของคุณคุณสามารถเรียก seg ได้ เช่นเดียวกันหากคุณต้องการแสดงหมายเลข 6 คุณก็ต้องใช้ seg

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

ตอนนี้ให้เราไปยังส่วนถัดไปของโค้ดซึ่งเป็นการกำหนดค่า I / O:

// ***** การกำหนดค่า I / O **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** สิ้นสุดการกำหนดค่า I / O ** ///

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

ตอนนี้ให้เรากระโดดเข้าสู่วงรอบที่ไม่มีที่สิ้นสุดของเรา (ในขณะที่ (1)) ที่นี่เราต้องแบ่งค่าของ "i" เป็นสี่หลักและแสดงบน 7 ส่วน ก่อนอื่นให้เราเริ่มต้นด้วยการแยกค่าที่ "i"

// *** การแบ่ง "i" เป็นสี่หลัก *** // a = i% 10; // หลักที่ 4 บันทึกไว้ที่นี่ b = i / 10; c = b% 10; // หลักที่ 3 ถูกบันทึกไว้ที่นี่ d = b / 10; e = d% 10; // หลักที่ 2 บันทึกไว้ที่นี่ f = d / 10; ก = f% 10; // หลักที่ 1 บันทึกไว้ที่นี่ h = f / 10; // *** สิ้นสุดการแยก *** //

ด้วยการใช้โมดูลัสอย่างง่ายและการหารตัวเลข 4 หลัก (i) จะถูกแยกออกเป็นตัวเลขแต่ละตัว ในกรณีของเราให้เรายกตัวอย่างโดยที่ค่าของ "i" คือ 4578 จากนั้นในตอนท้ายของกระบวนการนี้ตัวแปร g = 4, e = 5, c = 7 และ a = 8 ตอนนี้การแสดงตัวเลขแต่ละหลักจะเป็นเรื่องง่ายเพียงแค่ใช้ตัวแปรนั้น

PORTD = seg; s1 = 1; // เปิดการแสดงผล 1 และพิมพ์ตัวเลขที่ 4 __delay_ms (5); s1 = 0; // ปิดการแสดงผล 1 หลังจากล่าช้า 5ms PORTD = seg; s2 = 1; // เปิดการแสดงผล 2 และพิมพ์ตัวเลขหลักที่ 3 __delay_ms (5); s2 = 0; // ปิดการแสดงผล 2 หลังจากล่าช้า 5ms PORTD = seg; s3 = 1; // เปิดแสดง 3 และพิมพ์ตัวเลขที่ 2 __delay_ms (5); s3 = 0; // ปิดการแสดงผล 3 หลังจากล่าช้า 5ms PORTD = seg; s4 = 1; // เปิดการแสดงผล 4 และพิมพ์หลักที่ 1 __delay_ms (5); s4 = 0; // ปิดการแสดงผล 4 หลังจากล่าช้า 5ms

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

แล้วเราจะทำอย่างไรกับสิ่งนี้?

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

เราเลือกหนึ่งหลักที่จะแสดงมันรอ 5ms เพื่อให้ MCU และ 7-segment สามารถประมวลผลได้จากนั้นปิดตัวเลขนั้นและไปยังหลักถัดไปและทำเช่นเดียวกันจนกว่าเราจะถึงหลักสุดท้าย ความล่าช้า 5 มิลลิวินาทีนี้ไม่สามารถสังเกตได้ด้วยตามนุษย์และตัวเลขทั้งสี่หลักดูเหมือนจะเปิดพร้อมกัน

นั่นคือในที่สุดเราก็เพิ่มมูลค่าของตัวเลขที่แสดงโดยใช้การหน่วงเวลาดังที่แสดงด้านล่าง

ถ้า (แฟล็ก> = 100) // รอจนกว่าแฟล็กจะถึง 100 {i ++; flag = 0; // เฉพาะในกรณีที่แฟล็กเป็นร้อย "i" จะถูกเพิ่มขึ้น} flag ++; // ค่าสถานะที่เพิ่มขึ้นสำหรับแต่ละแฟลช

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

รหัสที่สมบูรณ์ได้รับด้านล่างและกระบวนการที่ยังจะมีการอธิบายในวิดีโอที่สิ้นสุด

การติดตั้งและทดสอบฮาร์ดแวร์:

เช่นเคยให้เราจำลองโปรแกรมโดยใช้ Proteus ก่อนที่เราจะใช้ฮาร์ดแวร์ของเราจริง หากการจำลองสำเร็จคุณควรเห็นสิ่งนี้

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