Matriks Keyboard Prototipe 64-Key untuk Arduino

Tentang proyek ini

Pembaruan:Saya telah meningkatkan kode, lihat "Pembaruan" di bagian akhir.

Saat ini saya sedang mengerjakan proyek yang akan memiliki keyboard terintegrasi, yang menimbulkan masalah:bagaimana cara memasukkan keyboard dalam prototipe papan pengembangan? Saya tidak dapat menggunakan keyboard USB atau keyboard berbasis Arduino yang ada, karena keyboard dalam proyek sebenarnya terhubung langsung ke mikrokontroler yang menangani semua fungsi lainnya. Jadi saya merancang matriks keyboard prototipe 64-tombol berbasis PCB ini.

PCB ini tidak mengandung IC (sirkuit terintegrasi). Baris dan kolom matriks keyboard terhubung langsung ke pin header sehingga keyboard dapat dihubungkan ke Arduino atau mikrokontroler lainnya. Ini sempurna untuk membuat prototipe proyek Anda yang akan menyertakan keyboard terintegrasi.

Saya telah menyertakan kode terperinci yang banyak dikomentari untuk membuat ini berfungsi dengan papan pengembangan yang kompatibel dengan Arduino yang memiliki cukup pin I/O yang tersedia — 11 pin diperlukan. Keyboard memiliki 64 tombol, termasuk pengubah untuk shift, caps, ctrl, alt, fn, dan "special." Ada juga enam tombol tambahan yang dapat digunakan untuk apa pun yang Anda suka. Fungsi setiap tombol dapat didefinisikan secara individual, termasuk fungsi setiap tombol saat pengubah aktif. Menurut saya, ini signifikan lebih berguna daripada kode keyboard yang ada yang sangat membatasi kemampuan Anda untuk menyesuaikan perilaku tombol.

Kode yang diberikan akan mencetak teks ke Serial. Ini dapat dengan mudah diubah jika Anda ingin teks dipindahkan ke tempat lain.

Catatan Mengenai Ukuran Program:

Kode yang saya berikan cukup besar, karena tidak menggunakan library yang ada sama sekali. Saya menulis kode ini sepenuhnya dari awal untuk mengaktifkan kemampuan penyesuaian yang saya butuhkan. Pada Arduino UNO, ini akan menggunakan 9100 byte (28%) ruang penyimpanan program dan variabel global menggunakan 394 byte (19%) memori dinamis.

Kode saya mungkin bisa lebih efisien dan di sana perpustakaan dan sketsa untuk keyboard tentu saja lebih kecil, tetapi ini adalah satu-satunya cara yang dapat saya pikirkan untuk memberikan fleksibilitas penuh pada setiap tombol dengan setiap pengubah. Ini juga memperhitungkan penggunaan keyboard dunia nyata. Misalnya, dengan kode saya menekan tombol Shift saat Caps Lock diaktifkan akan menghasilkan huruf kecil sebagaimana mestinya. Secara default, menahan tombol FN sambil menekan ESC tidak akan melakukan apa pun. Namun perilaku tersebut sepenuhnya dapat disesuaikan, sehingga Anda dapat mengubahnya sesuka Anda.

Persediaan:

• PCB khusus
• Tombol tekan sesaat taktil 6x6x5mm (x64)
• 1N4148 switching dioda (x64)
• Header pin 1x8, perempuan atau laki-laki (x2)
• daftar shift 74HC595
• Kabel jumper
• Papan tempat memotong roti
• Arduino Uno atau papan pengembangan mikrokontroler yang kompatibel dengan Arduino

Langkah 1:Cara Kerja Matriks Keyboard

Mengapa matriks keyboard diperlukan?

Keyboard ini memiliki 64 tombol. Jika Anda ingin menghubungkan setiap tombol tersebut ke papan pengembangan Anda secara langsung, Anda akan memerlukan 64 pin I/O. Itu banyak pin dan lebih dari kebanyakan papan pengembangan yang tersedia. Untuk menurunkannya ke angka yang jauh lebih masuk akal, kita dapat menggunakan matriks keyboard, yang hanya membutuhkan sejumlah pin yang sama dengan akar kuadrat (dibulatkan ke atas) dari jumlah tombol.

Matriks keyboard diatur sehingga setiap sakelar tombol dalam satu baris terhubung dan setiap sakelar tombol dalam satu kolom terhubung. Ketika kita ingin melihat tombol mana yang ditekan, kita "mengaktifkan" baris pertama dan kemudian memeriksa setiap kolom. Jika kolom tertentu aktif, kita tahu bahwa tombol di kolom dan baris 1 itu telah ditekan. Kami kemudian menonaktifkan baris 1 dan mengaktifkan baris 2, lalu periksa semua kolom lagi. Setelah semua baris diaktifkan, kita cukup memulai kembali dari baris pertama.

Bagaimana kami memindai matriks keyboard:

Karena kita bekerja dengan mikrokontroler, "aktifkan" berarti menyetel baris itu ke RENDAH atau TINGGI. Dalam hal ini, kami menyetel baris ke RENDAH karena kami menggunakan resistor pullup bawaan mikrokontroler. pada pin input kolom kami. Tanpa resistor pullup atau pulldown, pin input akan bereaksi secara tidak terduga sebagai akibat dari antarmuka, yang akan mencatat penekanan tombol yang salah.

Mikrokontroler ATmega328P yang digunakan pada Arduino UNO tidak memiliki resistor pulldown bawaan, hanya resistor pullup. Jadi kami menggunakan itu. Resistor pullup menghubungkan setiap pin input ke 5V, memastikan bahwa mereka selalu membaca HIGH sampai tombol ditekan.

Semua baris juga biasanya diatur ke TINGGI, yang mencegah pin kolom terhubung ke pin baris apakah tombol telah ditekan atau tidak. Namun ketika kita siap untuk memeriksa sebuah baris, kita dapat menyetel baris tersebut ke RENDAH . Jika tombol di baris itu ditekan, ini akan menyediakan jalur untuk pin input ditarik ke ground—menghasilkan kolom itu sekarang terbaca sebagai RENDAH .

Jadi, untuk meringkas:kami menetapkan baris ke LOW dan kemudian kami memeriksa untuk melihat pin kolom mana yang sekarang membaca LOW. Itu sesuai dengan tombol yang ditekan. Proses ini terjadi sangat dengan cepat, sehingga kami dapat memindai seluruh keyboard berkali-kali per detik. Kode saya membatasi ini hingga 200 kali per detik, yang menyeimbangkan kinerja, pantulan, dan memastikan setiap penekanan tombol tertangkap.

Dioda, ghosting, dan rollover n-key:

Dioda di sirkuit ada untuk mencegah penekanan tombol yang tidak diinginkan ketika kombinasi tombol tertentu ditekan. Dioda hanya memungkinkan arus mengalir dalam satu arah, yang mencegah ghosting. Jika kita tidak menggunakan dioda, maka menekan tombol tertentu dapat menyebabkan kunci lain yang tidak ditekan untuk didaftarkan, karena arus mengalir melalui sakelar yang berdekatan. Ini ditunjukkan dalam grafik yang disederhanakan di mana menekan tiga tombol yang berdekatan menyebabkan kunci di sudut keempat terdaftar bahkan ketika tidak ditekan. Dioda mencegahnya dan mengaktifkan "n-key rollover," yang berarti kita dapat menekan tombol sebanyak yang kita inginkan dalam kombinasi apa pun yang kita inginkan tanpa masalah.

Menyimpan pin dengan register geser:

Orang yang cerdik di antara Anda mungkin memperhatikan bahwa saya mengatakan bahwa matriks keyboard memerlukan sejumlah pin yang sama dengan akar kuadrat dari jumlah tombol, tetapi saya juga mengatakan bahwa desain keyboard saya hanya membutuhkan 11 pin. Seharusnya 16, kan? Tidak, karena kami menggunakan register geser 74HC595. Register geser ini memungkinkan kita menggunakan hanya tiga pin I/O Arduino untuk mengontrol hingga delapan pin keluaran. Ketiga pin tersebut memungkinkan kita mengirim satu byte (delapan bit) ke register geser, yang menetapkan delapan pin outputnya ke TINGGI atau RENDAH. Dengan menggunakan register geser untuk pin baris keluaran, kami menghemat 5 pin I/O utuh!

"Jadi mengapa tidak menggunakan register geser untuk pin input juga?" Anda bertanya. Jawaban paling sederhana adalah bahwa input memerlukan jenis register geser yang berbeda dan saya tidak memiliki jenis itu. Tetapi menggunakan register geser untuk input juga memperumit cara kita membaca kolom dan dapat menyebabkan masalah dengan kebisingan dan "memantul". Cukuplah untuk mengatakan bahwa itu adalah sakit kepala yang tidak perlu saya tangani dalam kasus ini.

Langkah 2:Desain PCB

Desain Skema

Sekarang setelah Anda memahami cara kerja matriks keyboard, desain PCB saya seharusnya sudah jelas. Saya mendesain PCB di KiCAD (maaf juri Eagle) dan mulai dengan skema. Saya hanya menempatkan simbol tombol dan simbol dioda, lalu menyalin dan menempelkannya sampai saya memiliki kisi 64 kunci. Kemudian saya menambahkan dua simbol header pin 1x8, satu untuk baris dan satu untuk kolom. Satu sisi tombol terhubung dalam kolom dan sisi lain tombol terhubung dalam baris.

Langkah selanjutnya adalah menetapkan footprint PCB ke masing-masing simbol skematis tersebut. Pustaka footprint yang disertakan KiCAD memiliki footprint yang diperlukan di dalamnya. Saat Anda mendesain PCB Anda sendiri, Anda harus sangat berhati-hati untuk memilih footprint yang benar, karena itulah yang akan benar-benar berakhir di PCB Anda. Ada banyak komponen yang memiliki footprint yang sangat mirip, tetapi dengan nada yang sedikit berbeda atau apa pun. Pastikan Anda memilih yang cocok dengan komponen dunia nyata Anda.

Jejak Kaki dan Nomor Pin

Berikan perhatian khusus pada nomor pin. KiCAD memiliki masalah aneh di mana nomor pin simbol dioda skema tidak cocok dengan nomor pin footprint. Hal ini menyebabkan dioda menjadi mundur, yang merupakan masalah serius mengingat polaritasnya. Saya tidak menangkap kesalahan itu dan harus membuang batch pertama PCB yang saya pesan. Untuk memperbaiki masalah ini pada revisi kedua, saya harus membuat tapak dioda khusus dengan nomor pin yang ditukar.

Tata Letak PCB

Dengan skema selesai dan jejak kaki yang ditetapkan, saya pindah ke tata letak PCB yang sebenarnya. Kerangka papan dibuat di Autodesk Fusion 360, diekspor sebagai DXF, dan kemudian diimpor ke KiCAD pada layer Edge Cuts. Sebagian besar pekerjaan setelah itu hanyalah mengatur tombol sehingga memiliki tata letak yang mirip dengan keyboard biasa.

Kemudian semua jejak diarahkan. Karena tata letak tombol yang sebenarnya tidak sesuai dengan matriks yang rapi dan rapi dalam skema, bagian ini menjadi sedikit berantakan dan saya harus menggunakan vias di beberapa tempat. Vias memungkinkan Anda merutekan jejak dari satu lapisan ke lapisan lainnya, yang sangat membantu saat Anda menggunakan papan 2 lapis yang memiliki banyak jejak yang tumpang tindih. Akhirnya, saya menambahkan wilayah yang terisi, karena ini praktik yang baik.

Fabrikasi PCB

Dengan papan yang dirancang, saya hanya memplot semua lapisan dan menambahkannya ke folder zip. Folder tersebut disediakan di sini dan dapat diunggah langsung ke layanan fabrikasi PCB seperti JLCPCB.

Berikut ini tautan ke file PCB Gerber:https://drive.google.com/file/d/10YriLLtghV0Sb84Wm...

Langkah 3:Perakitan PCB

Ini adalah langkah termudah, tetapi paling membosankan, dalam keseluruhan proyek. Cukup solder semua komponen di tempatnya. Mereka semua komponen melalui lubang dan mudah disolder. Berikan perhatian khusus pada orientasi dioda. Tanda pada dioda harus sesuai dengan tanda pada PCB.

Dalam pengalaman saya, paling mudah untuk menahan PCB di tempatnya dengan tangan ketiga dan meletakkan semua dioda terlebih dahulu. Kemudian balikkan papan dan solder semuanya, lalu jepit ujungnya. Kemudian letakkan semua tombol dan solder itu. Kemudian solder pin header di tempatnya. Anda dapat menggunakan header pin perempuan atau laki-laki, itu sepenuhnya terserah Anda. Jika Anda menggunakan kepala laki-laki dan letakkan di bawah papan, jaraknya benar untuk menempelkannya langsung ke papan tempat memotong roti.

Langkah 4:Hubungkan Keyboard ke Arduino Anda

Pengkabelan terlihat rumit, tetapi sebenarnya tidak terlalu buruk jika Anda memperhatikan ke mana arahnya.

Delapan kabel jumper akan langsung dari header kolom ke pin Arduino berikut:

• Kolom 1> A0
• Kolom 2> A1
• Kolom 3> A2
• Kolom 4> A3
• Kolom 5> A4
• Kolom 6> A5
• Kolom 7> 5
• Kolom 8> 6

Selanjutnya, tempatkan register geser 74HC595 di papan tempat memotong roti Anda mengangkangi jeda tengah. Perhatikan orientasi chip! Titik menunjukkan Pin 1

Lihatlah diagram pengkabelan untuk melihat di mana koneksi 5V dan Ground pergi. Register geser memiliki dua pin yang terhubung ke 5V dan dua pin yang terhubung ke Ground.

Hanya tiga kabel yang diperlukan untuk menghubungkan register geser ke Arduino. Mereka adalah:

• Shift (Jam) 11> 4
• Shift (Kait) 12> 3
• Pergeseran (Data) 14> 2

Untuk beberapa alasan konyol, pin keluaran register geser diatur dengan cara yang berlawanan dengan intuisi. Berikan perhatian khusus pada diagram pinout register geser saat menghubungkannya ke pin baris Anda. Mereka adalah:

• Baris 1> Shift (Q0) 15
• Baris 2> Shift (Q1) 1
• Baris 3> Shift (Q2) 2
• Baris 4> Shift (Q3) 3
• Baris 5> Shift (Q4) 4
• Baris 6> Shift (Q5) 5
• Shift 7> Shift (Q6) 6
• Shift 8> Shift (Q7) 7

Tidak ada yang terhubung ke pin Arduino 0 atau 1, karena itu juga digunakan untuk port Serial dan menyebabkan konflik.

Langkah 5:Flash Kode Arduino

Flash Arduino Anda dengan kode yang disediakan di sini. Tidak ada yang istimewa tentang ini, cukup unggah kode seperti yang Anda lakukan dengan proyek Arduino lainnya.

Segala sesuatu dalam kode memiliki komentar mendetail yang dapat Anda baca, jadi saya tidak akan membahasnya secara rinci di sini. Pada dasarnya, pin diatur sebagai input dan output. Loop utama hanya berisi fungsi pengatur waktu. Setiap 5 ms, ia memanggil fungsi untuk memindai keyboard. Fungsi itu memanggil fungsi terpisah untuk mengatur register geser sebelum setiap kolom diperiksa. Tombol yang ditekan mencetak nilainya ke Serial.

Jika Anda ingin mengubah apa yang dicetak saat Anda menekan tombol, cukup ubah Serial.print("_"); dalam pernyataan if yang sesuai dengan kondisi. Misalnya, Anda dapat mengatur apa yang dicetak saat Anda menahan FN dan menekan N. Hal yang sama berlaku untuk setiap tombol lain dengan setiap pengubah.

Banyak kunci tidak melakukan apa-apa dalam kode ini, karena hanya mencetak ke Serial. Itu berarti tombol backspace tidak berpengaruh, karena Anda tidak dapat menghapus dari monitor Serial—data tersebut telah diterima. Namun, Anda bebas menggunakan perubahan itu jika Anda mau.

Menggunakan Keyboard dengan Proyek Anda Sendiri

Sangat bagus untuk mencetak ke serial, tapi bukan itu inti dari keyboard ini. Tujuan keyboard ini adalah untuk membuat prototipe proyek yang lebih kompleks. Itu sebabnya mudah untuk mengubah fungsionalitasnya. Jika, misalnya, Anda ingin mencetak teks yang diketik ke layar OLED, Anda cukup mengganti setiap Serial.print( dengan display.print( atau apa pun yang dibutuhkan tampilan khusus Anda. Ganti Semua Arduino IDE alat ini sangat bagus untuk mengganti semuanya dalam satu langkah cepat.

Terima kasih telah membaca ini dan saya harap keyboard ini membantu proyek Anda!

1/30/21 Pembaruan:

​Kode baru ini sepenuhnya ditulis ulang dan berkinerja lebih baik daripada kode aslinya. Ini sebagian besar dilakukan untuk mengatasi masalah dengan algoritme saya yang membuat karakter tidak dapat dimasukkan setiap kali tombol ditekan. Kode asli diperiksa untuk memastikan kunci tertentu bukan terakhir tombol yang akan ditekan. Ini menyebabkan masalah jika 2 kunci atau lebih ditekan, yang akan menyebabkan sesuatu seperti "fgfgfgfgfgfgfgfgfgfg" dimasukkan. Ini juga mencegah Anda memasukkan kunci yang sama berulang-ulang dengan sangat cepat, seperti saat Anda mengetik dua m pada kata "bummer."

Kode baru memecahkan kedua masalah ini dan juga lebih elegan. Alih-alih melacak tombol terakhir yang ditekan, kami memeriksa status seluruh keyboard dan membandingkannya dengan seluruh status keyboard di loop terakhir. Ini berarti loop dapat berjalan lebih cepat, dan Anda juga dapat memasukkan kunci yang sama berulang-ulang dengan sangat cepat. Performa meningkat secara dramatis. Semua karakter juga ada dalam array di bagian atas, sehingga Anda dapat menemukannya dan mengubahnya dengan mudah. Ada array independen untuk setiap pengubah. Kodenya juga jauh lebih pendek.

Satu-satunya kelemahan dari pendekatan baru ini adalah ia menggunakan memori yang lebih dinamis—meskipun menggunakan ruang program yang jauh lebih sedikit. Pada Arduino Uno, sekarang menggunakan:3532 byte (10%) ruang penyimpanan program dan 605 byte (29%) memori dinamis.

Sebagai bonus tambahan, kode ini bekerja dengan baik pada mikrokontroler cepat seperti ARM Cortex-M4. Pengatur waktu interval untuk memeriksa keyboard dalam mikrodetik, sehingga akan melakukan hal yang sama pada papan apa pun. Anda juga dapat dengan mudah menyesuaikan seberapa sering keyboard diperiksa. Secara default, ini menjalankan satu loop setiap 500 mikrodetik. Diperlukan 8 loop untuk memeriksa keyboard, dengan total 4000 mikrodetik (4 milidetik, atau 250 kali per detik)—meskipun mungkin perlu waktu lebih lama jika mikro tidak cukup cepat untuk menjalankan kode secepat itu.

Tidak ada pratinjau (hanya unduhan).

/* Sketch for Prototyping Keyboard V1.2 * oleh Cameron Coward 1/30/21 * * Diuji pada Arduino Uno. Memerlukan PCB kustom * dan register geser 74HC595. * * Info lebih lanjut:https://www.hackster.io/cameroncoward/64-key-prototyping-keyboard-matrix-for-arduino-4c9531 */const int rowData =2; // register geser Pin data untuk rowsconst int rowLatch =3; // shift register Latch pin untuk rowsconst int rowClock =4; // shift register Pin jam untuk baris// ini adalah pin input kolom kami. Pin 0 dan Pin 1 tidak digunakan,// karena menyebabkan masalah (mungkin karena TX dan RX)const int colA =A0; const int colB =A1; const int colC =A2; const int colD =A3;const int colE =A4;const int colF =A5;const int colG =5;const int colH =6;// shiftRow adalah byte register geser yang diperlukan untuk setiap baris, rowState akan berisi tombol yang ditekan untuk setiap baris rowconst byte shiftRow[] ={B01111111, B10111111, B11011111, B11101111, B11110111, B11111011, B11111101, B11111110};byte rowState[] ={B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};byte sebelumnya ] ={B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};// Kode ASCII untuk kunci tanpa pengubah yang ditekan. Pengubah adalah NULL (0),// karena kami akan memeriksanya secara terpisah dan nilainya tidak boleh dicetak.const char key[] ={ 0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 91, 93, 92, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 59, 39, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk tombol dengan penekanan shift AND caps aktifconst char capsShiftKey[] ={ 0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 113, 119, 101, 114, 116, 121, 117, 105, 111, 112, 123, 125, 124, 7, 97, 115, 100, 102, 103, 104, 106, 107, 108, 58, 22, 0, 0, 122, 120, 99, 118, 98, 110, 109, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk tombol dengan penekanan shift.const char shiftKey[] ={ 0, 33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 95, 43, 0, 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 123, 125, 124, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 58, 22, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk tombol dengan ctrl ditekan.const char ctrlKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk kunci dengan spcl ditekan.const char spclKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk tombol dengan alt ditekan.const char altKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk tombol dengan fn ditekan.const char fnKey[] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};// Kode ASCII untuk kunci dengan huruf besar adalah activeconst char capsKey[] ={ 0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 45, 61, 0 , 9, 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 91, 93, 92, 7, 65, 83, 68, 70, 71, 72, 74, 75, 76, 59 , 39, 0, 0, 90, 88, 67, 86, 66, 78, 77, 44, 46, 47, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0 };panjang sebelumnyaKeyboardMicros =0; // akan menyimpan terakhir kali keyboard diperiksa // variabel berikut panjang karena waktu, diukur dalam milidetik,// akan dengan cepat menjadi angka yang lebih besar daripada yang dapat disimpan dalam int.long keyboardInterval =500; // interval untuk memeriksa keyboard (mikrodetik)int rowToCheck =0; // Kami memeriksa satu baris per loop dari checkKeyboard(), ini dikombinasikan dengan keyboardInterval // memberikan waktu shiftRegister untuk sepenuhnya memperbarui antara baris checksbool caps =false; // apakah caps lock aktif?bool shift =false; // apakah shift kiri atau kanan ditekan?bool capsShift =false; // apakah shift AND caps aktif?bool ctrl =false; // apakah tombol ctrl ditekan?bool spcl =false; // apakah tombol spcl ditekan?bool alt =false; // apakah tombol alt ditekan?bool fn =false; // apakah tombol fungsi ditekan?void setup() { Serial.begin(9600); // siapkan semua pin kolom sebagai input dengan resistor pullup internal pinMode(colA, INPUT_PULLUP); pinMode(colB, INPUT_PULLUP); pinMode(colC, INPUT_PULLUP); pinMode(dingin, INPUT_PULLUP); pinMode(colE, INPUT_PULLUP); pinMode(colF, INPUT_PULLUP); pinMode(colG, INPUT_PULLUP); pinMode(colH, INPUT_PULLUP); // output yang diperlukan untuk mengontrol 74HC595 register geser pinMode(rowLatch, OUTPUT); pinMode(rowClock, OUTPUT); pinMode(rowData, OUTPUT); updateShiftRegister(B11111111); // pastikan register geser mulai TINGGI}void loop() { mainTimer();}void mainTimer() { unsigned long currentMicros =micros(); // berapa mikrodetik Arduino telah berjalan? if(currentMicros - PreviousKeyboardMicros> keyboardInterval) { // jika waktu yang telah berlalu sejak pemeriksaan terakhir melebihi interval // simpan terakhir kali keyboard diperiksa sebelumnyaKeyboardMicros =currentMicros; periksaKeyboard(); // periksa semua kunci dan cetak hasilnya ke serial }}void updateShiftRegister(byte row) { //fungsi ini mengatur shift register sesuai dengan byte yang diteruskan ke digitalWrite(rowLatch, LOW); // setel latch ke low sehingga kita dapat menulis seluruh byte sekaligus shiftOut(rowData, rowClock, MSBFIRST, row); // tulis byte itu digitalWrite(rowLatch, HIGH); // setel latch kembali ke high sehingga register geser akan tetap stabil sampai perubahan berikutnya}void checkKeyboard() { // setel register geser ke nilai byte baris saat ini, dari array byte shiftRow[] byte updateShiftRegister(shiftRow[rowToCheck]); // Periksa setiap kolom if (digitalRead(colA) ==LOW) { bitSet(rowState[rowToCheck], 0); } else { bitClear(rowState[rowToCheck], 0); } if (digitalRead(colB) ==LOW) { bitSet(rowState[rowToCheck], 1); } else { bitClear(rowState[rowToCheck], 1); } if (digitalRead(colC) ==LOW) { bitSet(rowState[rowToCheck], 2); } else { bitClear(rowState[rowToCheck], 2); } if (digitalRead(colD) ==LOW) { bitSet(rowState[rowToCheck], 3); } else { bitClear(rowState[rowToCheck], 3); } if (digitalRead(colE) ==LOW) { bitSet(rowState[rowToCheck], 4); } else { bitClear(rowState[rowToCheck], 4); } if (digitalRead(colF) ==LOW) { bitSet(rowState[rowToCheck], 5); } else { bitClear(rowState[rowToCheck], 5); } if (digitalRead(colG) ==LOW) { bitSet(rowState[rowToCheck], 6); } else { bitClear(rowState[rowToCheck], 6); } if (digitalRead(colH) ==LOW) { bitSet(rowState[rowToCheck], 7); } else { bitClear(rowState[rowToCheck], 7); } // setel semua pin register geser ke HIGH, ini menjaga nilai dari "bleeding" ke loop berikutnya updateShiftRegister(B11111111); rowToCheck =rowToCheck + 1; // beralih ke baris berikutnya // setelah memeriksa baris ke-8, periksa status (tekanan tombol) dan kemudian mulai dari baris pertama if (rowToCheck> 7 ) { checkPressedKeys(); rowToCheck =0; }}void checkPressedKeys() { // periksa apakah salah satu tombol shift ditekan jika (bitRead(rowState[5], 1) | bitRead(rowState[6], 4)) { shift =true; } lain { shift =salah; } // periksa apakah salah satu tombol ctrl ditekan if (bitRead(rowState[6], 5) | bitRead(rowState[7], 3)) { ctrl =true; } lain { ctrl =salah; } // periksa apakah salah satu tombol spcl ditekan if (bitRead(rowState[6], 6) | bitRead(rowState[7], 2)) { spcl =true; } else { spcl =salah; } // periksa apakah salah satu tombol alt ditekan if (bitRead(rowState[6], 7) | bitRead(rowState[7], 1)) { alt =true; } lain { alt =salah; } // periksa apakah tombol FN ditekan if (bitRead(rowState[7], 4)) { fn =true; } lain { fn =salah; } // centang caps aktif dan shift ditekan if (shift ==true &&caps ==true) { capsShift =true; } else { capsShift =salah; } for (int i =8; i>=0; i--) { // iterate melalui setiap baris for (int j =7; j>=0; j--) { // iterate melalui setiap bit di baris itu bool newBit =bitRead(rowState[i], j); // periksa status bit itu bool prevBit =bitRead(prevRowState[i], j); // periksa status sebelumnya dari bit tersebut if ((newBit ==1) &&(prevBit ==0)) { // hanya mengizinkan penekanan tombol jika status telah berubah menjadi true int thisChar =(i * 8) + j; // menghitung posisi mana dalam array char yang akan dipilih jika (capsShift ==true) { processKey(capsShiftKey[thisChar]); } else if (shift ==true) { processKey(shiftKey[thisChar]); } else if (ctrl ==true) { processKey(ctrlKey[thisChar]); } else if (alt ==true) { processKey(altKey[thisChar]); } else if (spcl ==true) { processKey(spclKey[thisChar]); } else if (fn ==true) { processKey(fnKey[thisChar]); } else if (caps ==true) { processKey(capsKey[thisChar]); } else { processKey(key[thisChar]); } } if (newBit ==1) { bitSet(prevRowState[i], j); // setel status bit sebelumnya ke true jika tombol ditekan } else { bitClear(prevRowState[i], j); // setel status bit sebelumnya ke false jika kunci tidak ditekan, sehingga dapat ditekan lagi } } }}void processKey(char acceptKey) { if (receivedKey ==7) { // periksa fungsi khusus dengan cara yang sama sebagai caps (tambahkan pernyataan "else if" baru) caps =!caps; } else { Serial.print(receivedKey); // jika char tidak sesuai dengan fungsi khusus, cukup cetak char itu }}