7 Antarmuka tampilan segmen dengan mikrokontroler pic

Ini adalah tutorial ke 8 kami tentang Mempelajari mikrokontroler PIC menggunakan MPLAB dan XC8. Kami telah datang jauh-jauh dari menginstal MPLABX hingga menggunakan LCD dengan PIC MCU. Jika Anda baru di sini, lihat tutorial sebelumnya di mana Anda dapat mempelajari pengatur waktu, LED berkedip, antarmuka LCD, dll. Anda dapat menemukan semua Tutorial PIC kami di sini. Dalam tutorial terakhir kami, kami melihat bagaimana kami dapat menghasilkan karakter Kustom dengan layar LCD 16 * 2 kami, sekarang mari kita melengkapi diri kami dengan jenis modul tampilan lain yang disebut tampilan 7-segmen dan menghubungkannya dengan Mikrokontroler PIC.

Meskipun LCD 16x2 jauh lebih nyaman daripada layar 7-segmen, tetapi ada beberapa skenario di mana tampilan 7-segmen akan lebih praktis daripada layar LCD. LCD mengalami kekurangan karena memiliki ukuran karakter yang rendah dan akan berlebihan untuk proyek Anda jika Anda hanya berencana untuk menampilkan beberapa nilai numerik. 7-segmen juga memiliki keunggulan terhadap kondisi pencahayaan yang buruk dan dapat dilihat dari sudut lager dibandingkan layar LCD biasa. Jadi, mari kita mulai mengetahuinya.

Modul Tampilan 7-Segmen dan 4-Digit 7-Segmen:

7 Tampilan Segmen memiliki tujuh segmen di dalamnya dan setiap segmen memiliki satu LED di dalamnya untuk menampilkan angka dengan menerangi segmen yang sesuai. Seperti jika Anda ingin 7-segmen menampilkan angka "5" maka Anda perlu memancarkan segmen a, f, g, c, dan d dengan membuat tinggi pin yang sesuai. Ada dua jenis tampilan 7 segmen: Common Cathode dan Common Anode, di sini kami menggunakan tampilan tujuh segmen Common Cathode. Pelajari lebih lanjut tentang tampilan 7 segmen di sini.

Sekarang kita tahu bagaimana menampilkan karakter numerik yang kita inginkan pada satu tampilan 7-segmen. Namun, sangat jelas bahwa kita membutuhkan lebih dari satu tampilan 7-segmen untuk menyampaikan informasi yang lebih dari satu digit. Jadi, dalam tutorial ini kita akan menggunakan 4-digit 7-Segment Display Module seperti yang ditunjukkan di bawah ini.

Seperti yang bisa kita lihat, ada Four Seven Segment Display yang terhubung bersama. Kita tahu bahwa setiap modul 7-segmen akan memiliki 10 pin dan untuk 4 tampilan tujuh segmen akan ada total 40 pin dan akan sangat sibuk bagi siapa pun untuk menyoldernya di papan titik, jadi saya akan sangat menyarankan siapa pun untuk membeli modul. atau buat PCB Anda sendiri untuk menggunakan tampilan 4-digit 7-segmen. Skema koneksi untuk hal yang sama ditunjukkan di bawah ini:

Untuk memahami cara kerja modul tujuh segmen 4-digit, kita harus melihat skema di atas, seperti yang ditunjukkan, pin A dari keempat layar dihubungkan untuk berkumpul sebagai satu A dan sama untuk B, C…. hingga DP. Jadi, pada dasarnya jika trigger A aktif, maka keempat A harus naik kan?

Tapi, itu tidak terjadi. Kami memiliki empat pin tambahan dari D0 ke D3 (D0, D1, D2 dan D3) yang dapat digunakan untuk mengontrol tampilan mana dari empat yang harus menjadi tinggi. Sebagai contoh: Jika saya ingin keluaran saya hanya ada di tampilan kedua maka hanya D1 yang harus dibuat tinggi sambil menjaga pin lain (D0, D2, dan D3) tetap rendah. Secara sederhana kita dapat memilih tampilan mana yang harus aktif menggunakan pin dari D0 hingga D3 dan karakter apa yang akan ditampilkan menggunakan pin dari A ke DP.

Menghubungkan Modul Tujuh Segmen 4-Digit dengan Mikrokontroler PIC:

Di sini kami telah menggunakan mikrokontroler PIC PIC16F877A dan skema rangkaiannya ditunjukkan di bawah ini.

Kami memiliki 12 pin keluaran dari modul di mana 8 digunakan untuk menampilkan karakter dan empat digunakan untuk memilih satu tampilan dari empat. Oleh karena itu, semua 8 pin karakter ditetapkan ke PORTD dan pin pemilihan tampilan ditetapkan ke empat pin pertama PORTC.

Catatan: Pin ground modul juga harus dihubungkan ke ground MCU yang tidak ditampilkan di sini.

Pemrograman menggunakan PIC16F877A:

Sekarang, setelah kita mengetahui bagaimana sebenarnya modul ini bekerja, mari kita pelajari cara memprogram PIC16F877A agar menampilkan angka 4 digit. Mari kita tingkatkan variabel dari 0 menjadi 1000 dan mencetaknya pada tampilan 7-segmen. Luncurkan program MPLABX dan buat proyek baru, mari kita mulai dengan bit konfigurasi.

#pragma config FOSC = HS // Bit pilihan osilator (osilator HS) #pragma config WDTE = OFF // Pengatur Waktu Pengawas Bit pengaktifan (WDT dinonaktifkan) #pragma config PWRTE = ON // Pengatur Waktu Penyalaan Bit pengaktifan (PWRT diaktifkan) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Tegangan Rendah (Pasokan Tunggal) In-Circuit Serial Programming Enable bit (RB3 adalah I / O digital, HV aktif MCLR harus digunakan untuk pemrograman) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Perlindungan kode EEPROM Data mati) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory dapat ditulis oleh kontrol EECON) #pragma config CP = OFF // Bit Perlindungan Kode Memori Program Flash (Perlindungan kode tidak aktif)

Seperti biasa kami menggunakan jendela bit konfigurasi set untuk mengatur bit ini. Jika Anda tidak yakin apa artinya, kunjungi tutorial berkedip LED di sini.

Selanjutnya mari kita tentukan pin keluaran untuk beralih di antara setiap digit tampilan.

// *** Tentukan pin sinyal dari keempat tampilan *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** End of definition ** ////

Di sini pin RC0, RC1, RC2 dan RC3 digunakan untuk memilih di antara empat digit modul tampilan 7-segmen kami. Pin ini masing-masing didefinisikan sebagai s1, s2, s3 dan s4.

Selanjutnya mari kita masuk ke void main (), di dalamnya kita memiliki deklarasi variabel berikut:

int i = 0; // nilai 4 digit yang akan ditampilkan int flag = 0; // untuk membuat penundaan unsigned int a, b, c, d, e, f, g, h; // hanya variabel unsigned int seg = {0X3F, // Nilai hex untuk menampilkan angka 0 0X06, // Nilai hex untuk menampilkan angka 1 0X5B, // Nilai hex untuk menampilkan angka 2 0X4F, // Nilai hex untuk ditampilkan angka 3 0X66, // Nilai hex untuk menampilkan angka 4 0X6D, // Nilai hex untuk menampilkan angka 5 0X7C, // Nilai hex untuk menampilkan angka 6 0X07, // Nilai hex untuk menampilkan angka 7 0X7F, / / Nilai hex untuk menampilkan angka 8 0X6F // Nilai hex untuk menampilkan angka 9}; // End of Array untuk menampilkan angka dari 0 hingga 9

Di sini variabel i dan flag digunakan untuk menyimpan nilai yang akan ditampilkan dan masing-masing membuat penundaan. The variabel unsigned integer ke jam digunakan untuk memecahkan empat digit angka dalam satu digit dan menyimpannya (yang akan dijelaskan nanti di sini).

Satu hal penting yang perlu diperhatikan di sini adalah deklarasi array "seg" . Dalam program ini kami menggunakan tipe data baru yang disebut Array. Array tidak lain adalah kumpulan nilai tipe data yang serupa. Di sini, kami telah menggunakan larik ini untuk menyimpan semua nilai hex ekuivalen untuk menampilkan angka dari 0 hingga 9.

Alamat array selalu dimulai dari nol. Jadi array ini akan memiliki nilai hex dari angka numerik (0-9) yang disimpan di alamat yang sama dengan angka seperti yang ditunjukkan di bawah ini

Variabel:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Kode Hex:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Persamaan. Nomor numerik:	0	1	2	3	4	5	6	7	8	9

Jadi sederhananya, jika Anda ingin menampilkan angka 0 pada 7 segmen Anda, Anda dapat memanggil seg, demikian juga jika Anda ingin menampilkan angka 6 Anda hanya perlu menggunakan seg.

Untuk memahami bagaimana nilai HEX sebenarnya diperoleh, mari kita lihat tabel di bawah ini. Nilai HEX yang setara untuk setiap angka desimal disimpan dalam array sehingga dapat dipanggil untuk menampilkan satu angka tertentu.

Sekarang, mari kita lanjutkan ke bagian kode berikutnya yang merupakan konfigurasi I / O:

// ***** Konfigurasi I / O **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Akhir dari konfigurasi I / O ** ///

Konfigurasi I / O sederhana karena semua pin pada 7-segmen kami adalah pin keluaran, dan koneksinya ditunjukkan dalam diagram rangkaian di atas, jadi cukup nyatakan sebagai keluaran dan inisialisasi ke nol.

Sekarang mari kita lompat ke loop tak terbatas kita (while (1)). Di sini kita harus membagi nilai "i" menjadi empat digit dan menampilkannya pada 7-segmen. Pertama mari kita mulai dengan membagi nilai pada "i"

// *** Membagi "i" menjadi empat digit *** // a = i% 10; // Digit keempat disimpan di sini b = i / 10; c = b% 10; // Digit ke-3 disimpan di sini d = b / 10; e = d% 10; // Digit ke-2 disimpan di sini f = d / 10; g = f% 10; // Digit pertama disimpan di sini h = f / 10; // *** Akhir pemisahan *** //

Dengan menggunakan modulus sederhana dan operasi pembagian, 4 digit angka (i) dipisahkan menjadi angka individu. Dalam kasus kita, mari kita ambil contoh di mana nilai "i" adalah 4578. Kemudian pada akhir proses ini variabel g = 4, e = 5, c = 7, dan a = 8. Jadi sekarang akan mudah untuk menampilkan setiap digit hanya dengan menggunakan variabel itu.

PORTD = seg; s1 = 1; // Nyalakan tampilan 1 dan cetak digit keempat __delay_ms (5); s1 = 0; // Matikan tampilan 1 setelah penundaan 5ms PORTD = seg; s2 = 1; // Nyalakan tampilan 2 dan cetak digit ke-3 __delay_ms (5); s2 = 0; // Matikan tampilan 2 setelah penundaan 5ms PORTD = seg; s3 = 1; // Nyalakan tampilan 3 dan cetak digit kedua __delay_ms (5); s3 = 0; // Matikan tampilan 3 setelah penundaan 5ms PORTD = seg; s4 = 1; // Nyalakan tampilan 4 dan cetak digit pertama __delay_ms (5); s4 = 0; // Matikan tampilan 4 setelah penundaan 5ms

Di sinilah sebenarnya MCU berbicara dengan 7-segmen. Seperti yang kita ketahui, kita hanya dapat menampilkan satu digit pada satu waktu, tetapi kita memiliki empat digit untuk ditampilkan dan hanya jika keempat digit tersebut Ada, empat digit angka lengkap akan terlihat oleh pengguna.

Jadi, bagaimana kita melakukannya?

Beruntung bagi kami MCU kami jauh lebih cepat daripada mata manusia, jadi yang sebenarnya kami lakukan: kami menampilkan satu digit pada satu waktu tetapi kami melakukannya dengan sangat cepat seperti yang ditunjukkan di atas.

Kita pilih tampilan satu digit itu tunggu 5ms sehingga MCU dan 7-segmen bisa memprosesnya lalu matikan digit itu dan lanjutkan ke digit berikutnya dan lakukan hal yang sama sampai kita mencapai digit terakhir. Penundaan 5 md ini tidak dapat diamati oleh mata manusia dan keempat digitnya tampak Hidup pada saat yang bersamaan.

Itu dia, akhirnya kita hanya menambah nilai digit yang ditampilkan menggunakan penundaan seperti yang ditunjukkan di bawah ini

if (flag> = 100) // tunggu hingga flag mencapai 100 {i ++; flag = 0; // hanya jika flag seratus "i" akan bertambah} flag ++; // tanda increment untuk setiap flash

Penundaan digunakan agar waktu yang dibutuhkan untuk berpindah dari satu nomor ke nomor lain cukup lama untuk kita perhatikan perubahannya.

The kode lengkap diberikan di bawah ini dan proses ini juga menjelaskan dalam Video di akhir.

Penyiapan dan Pengujian Perangkat Keras:

Seperti biasa, mari kita simulasikan program menggunakan Proteus sebelum kita benar-benar menggunakan perangkat keras kita. Jika simulasi berhasil, Anda akan melihat sesuatu seperti ini

Proyek ini tidak memiliki pengaturan perangkat keras yang rumit, kami kembali menggunakan papan Mikrokontroler PIC yang sama yang telah kami buat di Tutorial berkedip LED. Cukup hubungkan Modul 7-segmen dengan papan Mikrokontroler PIC Anda sesuai dengan diagram koneksi. Setelah Anda selesai dengan koneksi, cukup buang kode menggunakan pemrogram PicKit 3 Anda dan itu menikmati hasil Anda.