Introduction To Microprocessor-Based Systems Design - Removed

Machine Translated by Google
Giuliano Donzellini
Andrea Mattia Garavagno
Luca Oneto
Perkenalan pada
Berbasis Mikroprosesor
Desain Sistem
Isi
Kata Pengantar Prof. Donatella Sciuto .......................... VII
Kata Pengantar Penulis ................................................... XI
Isi Digital Buku. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XVII
Isi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIX
1 Pengantar jaringan komputasi yang dapat diprogram. . . . . . . .

1.1 Pengenalan umum mikroprosesor. . . . . . . . . . . . . . . . . .
1 1 1.1.1 Sejarah singkat mikroprosesor. . . . . . . . . . . . . . . . . . . 2 1.1.2 Jenis
mikrokomputer . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1.3 Mikrokomputer dan
sistem . . . . . . . . . . . . . . . . . . . . . . . 3 1.1.4 Struktur dasar komputer generik. . . . . . . . . . . .
4 1.1.5 Koneksi bus umum . . . . . . . . . . . . . . . . . . . . . . . . 6 1.2 Desain jaringan
komputasi yang dapat diprogram. . . . . . . . . . . . . . 9 1.2.1 Spesifikasi desain: jaringan
komputasi khusus 9 1.2.1.1 Solusi kombinasional . . . . . . . . . . . . . . . . . . . . . 9 1.2.1.2 Solusi
berurutan . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.2.1.3 Algoritma
sequencer . . . . . . . . . . . . . . . . . . . . 15 1.2.1.4
Simulasi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.2.2 Penghitung dan
sequencer berbasis memori ROM. . . . . . . . . . 16 1.2.3 Memperluas
kemungkinan komputasi . . . . . . . . . . . . . . . . . . . 19 1.2.4 Jaringan komputasi
berbasis ALU . . . . . . . . . . . . . . . . . . . . . 22 1.2.4.1 Contoh komputasi
lainnya . . . . . . . . . . . . . . . . 23 1.2.5 “Petunjuk”. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25 1.2.6 “Program”, “pemrograman” dan istilah penting lainnya 29 1.3 Urutan, instruksi
mikro dan program mikro . . . . . . . . . . . 30 1.3.1 Sequencer yang lebih
ringkas . . . . . . . . . . . . . . . . . . . . . . . . . 30 1.3.2 Sequencer yang diprogram
mikro. . . . . . . . . . . . . . . . . . . . 32
XIX
XX Isi
1.3.3 Sequencer yang diprogram mikro dan komputasinya

jaringan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34 1.3.4 Cara kerjanya . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36 1.3.5 Mengeksekusi urutan instruksi . . . . . . . . . . . . . . . . . 39 1.3.6
Mengeksekusi instruksi pertama saat start up . . . . . . . . 40 1.3.7 “Pipa
instruksi” . . . . . . . . . . . . . . . . . . . . . . . . . . 41 1.3.8 Mendefinisikan
program mikro . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 1.3.9 Menulis
ulang program rata-rata empat operan. 44 1.4 Lompatan, putaran, dan
keputusan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 1.4.1 Instruksi loop
dan lompat . . . . . . . . . . . . . . . . . . . . . . . . 47 1.4.2 Keputusan dan
instruksi lompatan bersyarat . . . . . . . . . . 51 1.4.3 Register
BENDERA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 1.4.4 Mengontrol
kondisi lompatan . . . . . . . . . . . . . . . . . . . . . . . . 53 1.4.5 Contoh: Cara
menggunakan lompatan bersyarat . . . . . . . . . . . . . . 58 1.5 Port input
dan output. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.5.1 Port
masukan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.5.2
Port keluaran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 1.5.3
Cara menggunakan port . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
1.5.3.1 Membangkitkan bentuk gelombang segitiga periodik . . . .
63 1.5.3.2 Membangkitkan bentuk gelombang trapesium
periodik . . . 65 1.5.3.3 Membangkitkan sinyal dengan teknik
PWM. . 67 1.6 Konstanta, variabel dan memori baca/tulis . . . . . . . . . . . . . . . .
70 1.6.1 Konstanta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70 1.6.2 Instruksi pengalamatan langsung . . . . . . . . . . . . . . . . . . . 73
1.6.3 Variabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
1.6.4 Memori baca/tulis (RAM) . . . . . . . . . . . . . . . . . . . . . . . . 75 1.6.5
RAM instruksi baca/tulis . . . . . . . . . . . . . . . . . . . . . . . 75 1.6.6 RAM
dan prosesor . . . . . . . . . . . . . . . . . . . . . . . . 76 1.6.7 Instruksi dengan
pengalamatan langsung . . . . . . . . . . . . . . . . . . 79 1.6.8 Penggunaan
jaringan Mp8E: contoh . . . . . . . . . . . . . . . . . 80 1.6.8.1 Menghitung
ekspresi logika . . . . . . . . . . . . . . 80 1.6.8.2 Perhitungan
ekspresi matematika . . . . . 81 1.6.8.3 Membangkitkan sampel
gelombang sinusoidal . . . 83 1.6.9 Pertimbangan terakhir
tentang prosesor yang dikembangkan di sini. . . 85 1.7
Latihan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 1.7.1
Jaringan komputasi khusus . . . . . . . . . . . . . . . . . . . . . . 87 1.7.2
Jaringan komputasi yang dapat diprogram. . . . . . . . . . . . . . . . . . 87
1.7.3 Pemrograman mikro instruksi baru. . . . . . . . . . . . . . . . . 91 1.8
Solusi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 1.8.1
Jaringan komputasi khusus . . . . . . . . . . . . . . . . . . . . . . 96 1.8.2
Jaringan komputasi yang dapat diprogram . . . . . . . . . . . . . . . . . . 100
1.8.3 Pemrograman mikro instruksi baru . . . . . . . . . . . . . . . . . 107
Pengantar jaringan komputasi yang dapat

diprogram
Abstrak Setelah pembukaan singkat tentang dunia mikroprosesor, bab ini secara bertahap
akan memperkenalkan gagasan membangun jaringan yang dapat diprogram digital yang
mampu memecahkan berbagai masalah. Pembaca akan dipandu melalui dasar-dasar
mikroprosesor, memperkenalkan langkah demi langkah landasan arsitektur komputer
mikro. Beberapa konsep, seperti sequencer, ALU, register, memori RAM dan ROM, dan
port input/output akan disajikan. Pada saat yang sama, pembaca akan belajar bagaimana
memprogram eksploitasi jaringan, untuk pertama kalinya, kode mesin, kode mnemonic,
bahasa rakitan, dan pemrograman mikro.
Pada akhir bab ini, pembaca akan dapat memahami komponen mikroprosesor yang lebih
lengkap.
1.1 Pengantar umum untuk mikroprosesor
Mikroprosesor adalah salah satu perangkat yang paling umum digunakan dalam
elektronika digital. Mereka termasuk bagian dasar dari komputer digital, terintegrasi ke
dalam satu komponen. Mereka adalah elemen sentral dalam komputer pribadi, tablet,
smartphone dan printer, tetapi ditemukan di banyak perangkat lain seperti satelit, mobil,
pabrik industri atau di mana pun sejumlah besar perhitungan logis aritmatika diperlukan.
Komputer digital membantu kita untuk memecahkan masalah Fisika seperti bagaimana
menghitung lintasan rudal atau asteroid, atau bahkan suatu objek di lingkungan virtual
seperti video game. Mereka membantu memecahkan masalah pemantauan seperti
menghitung manuver yang harus dilakukan satelit untuk tetap berada di orbit geostasioner,
atau apa yang harus dilakukan oleh lengan robot untuk melintasi jarak terpendek untuk
menangkap objek. Pada dasarnya, mereka membantu dengan masalah apa pun yang
membutuhkan banyak perhitungan untuk dipecahkan dan keputusan berdasarkan hasil.
© Penulis, di bawah lisensi eksklusif untuk Springer Nature Switzerland AG 1

2022 G. Donzellini et al., Pengantar Desain Sistem Berbasis Mikroprosesor,
https://doi.org/10.1007/978-3-030-87344-8_1
2 1 Pengantar jaringan komputasi yang dapat diprogram
1.1.1 Sejarah singkat mikroprosesor
Produksi mikroprosesor dimungkinkan saat ini karena pengembangan teknologi

sirkuit terpadu berbiaya rendah pada chip silikon LSI dan VLSI1 pada 1970-an.
Chip ini memungkinkan untuk membuat sirkuit terintegrasi yang sangat kecil
(beberapa mm per sisi) namun cukup kompleks. Salah satu teknologi integrasi
yang paling terkenal adalah SGT (Self-aligned Gate Transistor), yang sebagian
besar masih digunakan dalam produksi mikroprosesor saat ini.
Mikroprosesor pertama yang dibuat dengan teknologi ini disebut 4004, dan dijual
oleh Intel pada tahun 1971 di bawah arahan Federico Faggin2 . Prosesor mikro
sangat terbatas; itu bekerja dengan hanya satu unit perhitungan 4-bit. Namun,
pada saat itu, hal baru adalah bahwa semua sirkuitnya disertakan dalam satu
komponen terintegrasi, sehingga mengurangi biaya produksi.
Meskipun produknya masih sangat baru, potensi keberhasilan komersial
perangkat elektronik jenis ini sudah jelas. Biaya produksi yang relatif rendah
bersama dengan keserbagunaan produk menjadikannya komponen yang ideal
untuk skala ekonomi.
Mikroprosesor pertama yang sukses secara komersial adalah Intel 8080, yang
dapat melakukan operasi aritmatika dan logika 8-bit pada tahun 1974. Pada
tahun-tahun yang sama, perusahaan besar lainnya merancang dan
mengkomersialkan mikroprosesor mereka: Z80 (Zilog), 6800 (Motorola) dan
6502 (Teknologi MOS). Pada tahun-tahun berikutnya, potensi besar
mikroprosesor, bersama dengan biaya rendah mereka membawa usia Komputer
Pribadi pertama seperti APPLE II pertama (berdasarkan 6502) dan PC IBM,
awalnya didasarkan pada 8088, versi biaya 8086 yang dibuat untuk aplikasi industri.
Selama dekade berikutnya, mikroprosesor menjadi semakin kompleks dan
efisien. Beberapa contohnya adalah Motorola 68000 (dan penerusnya); Intel
80286, 80386 dan 80486; seluruh seri Pentium dan Core I7, hanya untuk
menyebutkan beberapa keberhasilan komersial. Mikroprosesor ARM, oleh
“Advanced Risc Machines”, dapat ditemukan di sebagian besar smartphone saat
ini (misalnya chip ARM Cortex-A8).
1
Integrasi Skala Besar dan Integrasi Skala Sangat Besar. LSI memiliki 100 hingga 9.999 gerbang
logika dalam satu komponen; VLSI memiliki dari 10.000 menjadi jutaan dan seterusnya.
2
Federico Faggin (kelas 1941) adalah seorang fisikawan, penemu, dan pengusaha Italia yang
menjadi warga negara AS pada tahun 1968. Di Intel, ia bertanggung jawab untuk
mengembangkan mikroprosesor 4004, 8008, 4040, dan 8080. Ia juga bekerja di bidang
teknologi sirkuit terpadu. Dia mengembangkan teknologi MOS (Metal Oxide Semiconductor),
contoh utamanya adalah SGT (Self-aligned Gate Transistor), yang datang dengan mikroprosesor
pertama dengan memori yang dapat dihubungkan. Pada tahun 1974, ia mengundurkan diri dari
Intel dan mendirikan Zilog, sebuah perusahaan yang didedikasikan khusus untuk mikroprosesor,
dan menciptakan Z80-CPU yang terkenal. Kemudian, ia ikut mendirikan perusahaan Synaptics
(yang menciptakan touchpad dan layar sentuh pertama).
1.1 Pengantar umum untuk mikroprosesor 3
Tergantung pada jenisnya, mikroprosesor saat ini dapat terdiri dari ratusan ribu atau bahkan
miliaran transistor yang terintegrasi pada satu chip silikon (atau bahan semikonduktor lainnya).
1.1.2 Jenis mikrokomputer
Mikroprosesor dan mikrokomputer tidaklah sama. Sederhananya, prosesor mikro, juga

dikenal sebagai Central Processing Unit (CPU), adalah elemen sentral dari mikrokomputer.
Sebenarnya seperti yang akan kita lihat berikut ini, komputer mikro adalah sistem lengkap
yang mencakup mikroprosesor ditambah perangkat lain: memori, sirkuit input/output data,
dll. Komputer pribadi, tablet, dan telepon pintar adalah contoh mikrokomputer.
Ketika semua perangkat komputer mikro terintegrasi pada satu perangkat, itu disebut
komputer mikro chip tunggal. Jenis tertentu dari mikrokom puter chip tunggal disebut
mikrokontroler. Seperti namanya, mikrokontroler dirancang untuk aplikasi kontrol. Selain
elemen dasar dari semua mikrokomputer, kami menemukan modul input/output khusus yang
dirancang untuk mengontrol pabrik industri dan/atau sistem khusus seperti timer, Analog to
Digital Converters (ADCs) dan Digital to Analog Converters (DACs).
Komputer mikro yang dimasukkan ke dalam sistem yang lebih kompleks "tertanam". Dalam
jenis aplikasi ini, pengguna melihat dan menggunakan seluruh sistem tanpa secara langsung
memperhatikan mikrokomputer di dalamnya. Dalam kehidupan sehari-hari, misalnya, kita
menemukan mikrokomputer dan mikrokontroler yang digunakan di televisi, peralatan
multimedia, peralatan rumah tangga, mobil, dan pemutar video dan musik.
Jenis lain dari komputer mikro khusus adalah Digital Signal Processor (DSP), yang dirancang
dan dioptimalkan secara jelas untuk rekayasa sinyal dengan teknik digital. Pertimbangkan
rekayasa sinyal audio dalam sistem multimedia, misalnya kartu suara di komputer pribadi,
alat musik, stasiun kerja musik atau produksi film.
1.1.3 Mikrokomputer dan sistem
Komputer mikro standar yang dimasukkan ke dalam sistem melakukan fungsi-fungsi berikut:
• memperoleh data eksternal

• menyimpan data •
memproses data, menghasilkan dan menyimpan hasil
• berdasarkan hasil tersebut, mengambil tindakan dalam sistem
Pertimbangkan, misalnya, komputer mikro yang digunakan dalam kontrol pabrik industri.
Data diperoleh melalui sensor atau transduser di pabrik (sensor kecepatan, sensor tekanan,
sensor suhu, dll.); setelah data disimpan dan diproses, mikrokomputer akan menggunakan
hasil tersebut untuk mengambil tindakan dalam
tanam melalui aktuator tertentu (motor, elektromagnet, piston hidrolik, katup solenoid,
rem listrik, dll.).
Pada prinsipnya, seseorang dapat merancang jaringan sekuensial digital yang
kompleks berdasarkan gerbang logika dan unit memori dasar alih-alih komputer mikro,
dan dapat melakukan fungsi yang sama ("sistem kabel"). Yang mengatakan, jenis
sistem ini akan sangat kompleks sehingga hampir tidak dapat dikelola dalam tahap
desain atau dalam pemeliharaan. Itu akan "didedikasikan" secara khusus untuk
aplikasi tertentu dan algoritma operasinya3 tidak akan dapat dimodifikasi secara
posteriori tanpa mendesain ulang dan membangunnya kembali karena cara kerjanya
bergantung pada koneksi spesifik antara perangkat logikanya.
Selain alasan teknis yang disebutkan di atas, produksi sirkuit khusus hanya dapat
dibenarkan oleh skala ekonomi atau kurangnya komponen alternatif. Bagaimanapun,
hanya perusahaan yang sangat besar yang mampu memproduksi sirkuit khusus.
Sebuah kontrol mikrokomputer, bagaimanapun, memiliki banyak keuntungan;

memungkinkan efisiensi dan fleksibilitas yang jauh lebih besar. Urutan operasi untuk
menghitung diperoleh oleh perancang melalui program yang ditulis dalam bahasa
yang dimengerti mesin (ini mengacu pada sistem yang diprogram). Arsitektur sistem
dirancang untuk memungkinkan perubahan urutan operasi yang akan dilakukan tanpa
mengubah sirkuit yang menjalankannya (perangkat keras), melainkan dengan
mengubah hanya program (perangkat lunak).
Salah satu keuntungan mikrokomputer adalah tipe arsitektur modularnya yang umum,
yang dapat disesuaikan dengan aplikasi tertentu dengan memilih perangkat yang
tepat dan menulis program yang tepat.
Seringkali, sistem komersial yang sama dapat digunakan dalam aplikasi yang berbeda
hanya dengan mengubah program yang menentukan cara kerjanya. Selain itu,
arsitektur modular standar umumnya memungkinkan untuk menjaga biaya desain
tetap rendah karena perancang dan pemrogram menggunakan kembali fungsionalitas
yang sama untuk berbagai proyek.
1.1.4 Struktur dasar komputer generik
Salah satu fitur dasar komputer digital adalah kemampuannya untuk mengeksekusi
urutan instruksi yang berurutan dengan cukup cepat. Daftar instruksi disebut program
dan dieksekusi melalui struktur internal khusus yang dibuat secara tegas untuk
melaksanakan instruksi.
3
Algoritma adalah proses yang menyediakan solusi untuk suatu masalah dalam sejumlah
langkah yang terdefinisi dengan baik. Istilah "algoritma" berasal dari transkripsi ke dalam
alfabet Latin "al-Khuw¯arizm", nama keluarga matematikawan Persia, Muhammad ibn
M¯usa, yang hidup pada abad ke-9 Masehi. Dia termasuk orang pertama yang
menggambarkan konsep prosedur yang teratur untuk memecahkan masalah. Dalam teori
informasi, suatu masalah didefinisikan sebagai dapat dihitung jika dapat dijelaskan
dengan suatu algoritma.
Instruksi adalah perintah yang dikirim ke mesin yang mengidentifikasi urutan operasi
dasar yang spesifik dan terbatas yang akan dilakukan mesin. Komputer dirancang
untuk mengeksekusi serangkaian instruksi yang terbatas. Misalnya, satu instruksi
mungkin untuk menyalin sekelompok bit dari satu elemen memori ke elemen memori
lainnya; instruksi kedua mungkin untuk melakukan penambahan atau menambah
angka satu per satu, dll.
Selain fungsi dasar untuk melakukan perhitungan matematis, fitur penting lainnya
dari komputer adalah mereka dapat mengambil keputusan berdasarkan hasil
pemrosesan data. Keputusan ini diterjemahkan ke dalam pelaksanaan tugas yang
berbeda tergantung pada keputusan yang dibuat.
Arsitektur yang paling umum digunakan dalam produksi komputer saat ini adalah Von
Neumann4 dan Harvard5 . Arsitektur Von Neumann telah digunakan sejak awal
komputer, yaitu sejak tahun 1940-an. Itu dirancang untuk kesederhanaan sirkuit
maksimum dan dapat dipecah menjadi tiga blok, dari sudut pandang logis (lihat
gambar di bawah).
Di sisi kiri atas kita melihat Central Processing Unit (CPU); di sebelah kanan,
subsistem Memori (Memori); sedangkan blok bawah adalah subsistem Input/Output,
yang memungkinkan komputer menerima data dari dunia luar dan mengembalikan
hasil pemrosesan ke dalamnya.
4
John Von Neumann (1903-1957), matematikawan, fisikawan, dan ilmuwan Hungaria, yang
mengajar Fisika Matematika di Universitas Princeton (AS). Pada tahun 1945 ia menerbitkan
First Draft of a Report on the EDVAC (Electronic Discrete Variable Automatic Calculator), salah
satu komputer digital elektronik pertama berdasarkan sistem bilangan biner, yang ia bantu
kembangkan sebagai konsultan. Arsitektur ini dinamai menurut namanya meskipun awalnya
dirancang oleh desainer John Mauchly dan John Presper Eckert (University of Pennsylvania),
yang juga menemukan ENIAC (Electronic Numerical Integrator and Computer) sebelumnya
berdasarkan sistem desimal.
5
Istilah ini mengacu pada arsitektur salah satu komputer digital elektromekanis pertama, Harvard
Mark I (1943), dirancang oleh Howard Hathaway Aiken (1900-1973), di Universitas Harvard
(AS).
Sebuah mesin Von Neumann didasarkan pada kriteria dasar berikut:
— hanya ada satu unit pemrosesan (CPU) — hanya

satu instruksi yang dieksekusi pada satu waktu (di dalam CPU) —
memori berisi data yang digunakan komputer dan program yang memproses data
tersebut.
CPU memainkan peran mendasar, karena tugasnya adalah mengambil instruksi yang
membentuk program dari memori dan menjalankannya satu per satu.
Perhitungan satu instruksi dapat sesuai dengan satu perhitungan dasar, tambahan
misalnya, atau pertukaran data dengan memori atau dunia luar.
Seluruh sistem hanya akan menjalankan tugas-tugas yang diperlukan oleh program
(dan dengan ekstensi, programmer yang menulisnya), tidak lebih, tidak kurang. Itu
tidak melakukan apa pun secara mandiri, tidak ada yang tidak berasal dari instruksi individu.
Arsitektur Harvard adalah variasi dari Von Neumann, dan berbeda pada kriteria
terakhir. Data dan programnya berada di subsistem memori yang berbeda dan dapat
diakses secara terpisah (lihat gambar di bawah).
Pada mesin Von Neumann, CPU diharuskan untuk mengeksekusi instruksi akses
memori secara berurutan, sedangkan arsitektur Harvard memungkinkan untuk
mendapatkan instruksi program dan mengakses data secara bersamaan. Arsitektur
Harvard yang lebih mahal akan hemat biaya jika ukuran datanya sama dengan ukuran
programnya.
Komputer yang paling banyak tersedia secara komersial didasarkan pada arsitektur
Von Neumann. Beberapa mikrokontroler dan prosesor sinyal digital menggunakan
model Har vard.
1.1.5 Koneksi bus umum
Sebuah komputer mikro berdasarkan kriteria Von Neumann biasanya diatur di sekitar
satu bus umum tunggal (lihat gambar di bawah). Bus adalah sekumpulan kabel paralel
yang digunakan bersama di antara unit sistem yang berbeda. Namanya terkait dengan
bus angkutan umum dan pada kenyataannya, kabel ini mengangkut informasi dari satu unit ke
unit lainnya.
Jenis sambungan ini digunakan terutama karena ekonomis dan modular.

Gambar tersebut menunjukkan tiga blok yang disebutkan sebelumnya. Komunikasi terjadi di
antara mereka melalui kumpulan kabel (bus) yang melewati mereka. Hanya satu unit pada satu
waktu yang dapat menggunakan kabel ini untuk mengirim informasi di bus, sementara unit lain
mungkin menerimanya secara bersamaan.
Unit yang mengirimkan data pada setiap titik disebut "pembicara", sedangkan penerima adalah
"pendengar". Unit yang mengatur siapa yang dapat menggunakan kabel bus di setiap titik
adalah "master" (atau "arbiter"), sedangkan yang lain yang mematuhi adalah "budak". Ada
sistem "multi-master", tetapi di sini kita akan membatasi diri pada sistem dengan CPU sebagai
satu-satunya master.
Mari kita lihat kelebihan dan kekurangan koneksi bus. Semua subunit sistem dihubungkan oleh
bundel kabel yang sama yang menjadikan bus sebagai sumber daya bersama. Jelas, semua
perangkat yang berbagi bundel kabel yang sama dapat menimbulkan batasan fungsional: jika
dua subunit terlibat dalam dialog, bus tidak tersedia untuk subunit lainnya.
Jika kami menghubungkan unit individu melalui koneksi yang dipesan, kami mendapatkan
sistem "bintang" yang berpotensi jauh lebih cepat (sistem yang terhubung sepenuhnya). Gambar
di bawah menunjukkan sistem bintang generik.
Meskipun demikian, pada prinsipnya ini bukanlah batasan yang parah untuk komputer mikro
dengan arsitektur Von Neumann karena hanya satu operasi yang akan dijalankan pada satu
waktu. Terlebih lagi, koneksi bus jauh lebih ekonomis daripada sistem bintang, yang akan
membutuhkan lebih banyak kabel untuk koneksi khusus.
Keuntungan dari koneksi bus adalah bahwa itu adalah modular. Misalnya, seseorang dapat
menambahkan memori baru atau elemen input/output jika diperlukan, hanya dengan
menghubungkannya ke bus tanpa harus menambahkan koneksi khusus. Keuntungan lain
dari menjadi modular adalah bus dapat distandarisasi, yaitu spesifikasinya dapat ditentukan
oleh lebih dari satu pembuat. Ini berarti setiap pengaya komputer yang dikembangkan secara
komersial dapat kompatibel satu sama lain.
Terakhir, sistem bus telah menambahkan manfaat dari sudut pandang diagnostik untuk fase
pengembangan proyek dan pemeliharaan sistem yang digunakan.
Faktanya, bus lebih mudah diamati daripada sistem bintang; seseorang dapat memecahkan
masalah malfungsi dengan lebih mudah dengan menghubungkan sistem diagnostik ke kabel
bus dan melihat apa yang dipertukarkan di antara modul yang berbeda.
1.2 Desain jaringan komputasi yang dapat diprogram 9
1.2 Desain jaringan komputasi yang dapat diprogram
Pengenalan istilah umum dan konsep dunia mikroprosesor telah selesai. Kemudian
pembaca dapat memulai langkah demi langkah untuk mempelajari komponen dan
mekanisme dasar yang membentuk mikroprosesor dan memungkinkannya untuk berjalan.
Dalam bab ini, kita akan mengambil sudut pandang perancang jaringan digital yang harus
membangun jaringan komputasi yang dapat diprogram dari komponen dan keterampilan
dasar mereka sendiri. Kami mulai dengan spesifikasi desain pengantar yang sederhana
dan membuatnya semakin fleksibel hingga semacam pendahulu mikroprosesor 8-bit
tercapai.
Ini adalah pendekatan bottom-up di mana pembaca (dibantu oleh penulis) mengambil
peran sebagai desainer yang perlu membuat jaringan yang dapat diprogram yang dapat
memecahkan berbagai macam masalah, tanpa harus mendesain ulang sirkuit yang sama
setiap saat.
Pada Bab 2, kita akan menganalisis arsitektur mikroprosesor yang lengkap dan teruji.
Sudut pandang yang dianut akan berbeda; tujuannya tidak lagi untuk mempelajari kerja
logis jaringan secara mendetail. Kali ini, penjelasannya akan fokus pada teknik
pemrograman dan desain sistem berbasis mikroprosesor yang dimaksudkan sebagai
komponen.
1.2.1 Spesifikasi desain: jaringan komputasi khusus
Mari kita bayangkan kita telah diminta untuk

merancang jaringan digital yang dapat menghitung
usia rata-rata empat bilangan bulat positif (OP3, OP2,
OP1, OP0), kurang dari 64 (6 bit signifikan).
Hasil RES juga akan menjadi bilangan bulat 6-bit
(lihat gambar di sebelah kanan).
1.2.1.1 Solusi kombinasi
Bayangkan rangkaian kombinasional murni yang menghitung rata-rata dengan terlebih

dahulu menambahkan empat operan yang dimasukkan melalui kaskade penambah (lihat
gambar berikut).
Kita dapat membagi dengan 4 melalui koneksi keluaran berskala (menskalakan keluaran
dua posisi ke kanan mengurangi bobot setiap bit dengan faktor 4). Dalam sampel
perhitungan pada gambar, kami mendapatkan 5 sebagai rata-rata dari 3, 2, 9 dan 6.
Beberapa keuntungan dari solusi ini adalah tidak memerlukan jam dan proses hasilnya
relatif cepat (dibutuhkan paling banyak 3 kali waktu yang dibutuhkan setiap penambah
untuk menghitung jumlah).
Di sisi lain, jaringan sulit untuk dikonfigurasi ulang. Misalnya, jika seseorang perlu
menambahkan lebih banyak operan di input atau menaikkan jumlah bit operan, sirkuit
perlu didesain ulang dan dibuat ulang, yang akan menambah biaya.
Jika kami perlu memiliki satu model jaringan tunggal yang dapat digunakan kembali
dalam berbagai kasus, kami dapat merancang sirkuit berukuran besar yang dilengkapi
dengan sejumlah besar operan dan lebih banyak bit.
Namun demikian, ini akan kurang dimanfaatkan di banyak aplikasi dan kami akan
menggunakan jaringan yang akan terlalu mahal untuk spesifikasinya. Untuk aplikasi lain,
mungkin tidak cukup dan ini mengharuskan kami untuk mendesain ulang.
Jika tingkat kerumitan ditentukan secara apriori, jaringan akan selalu sangat terspesialisasi.
1.2.1.2 Solusi berurutan
Untuk mendapatkan solusi yang lebih fleksibel dan dapat dikonfigurasi ulang, kita dapat mengasumsikan
bahwa kita akan menggunakan satu penambah tunggal dengan register paralel. Dengan hanya satu
penambah yang tersedia, kita harus mengeksekusi penjumlahan satu per satu saat kita mengingat hasil
parsial dalam register.
Keuntungan paling jelas dari pendekatan ini adalah bahwa jumlah operan untuk ditambahkan
tidak tergantung pada jumlah penambah di sirkuit. Gambar di bawah menunjukkan skema
rangkaian.
Untuk menambahkan operan, kami menunjukkan nilainya pada input OP dan mengaktifkan
register untuk satu siklus clock CK (dengan mengaktifkan EN). Jelas, pertama kita harus
mengosongkan register sehingga kita menambahkan nol ke operan pertama.
Melakukan semua operasi ini secara manual jelas tidak praktis sehingga kita perlu menambahkan
"pengontrol" ke jaringan aritmatika kita ("jalur data") untuk mengurutkan operasi secara otomatis.
Juga tidak nyaman untuk membaca operan hanya pada satu input. Juga jaringan masih tidak
dapat menjalankan pembagian terakhir.
Menambahkan pengamatan ini ke spesifikasi awal, kami dapat menyelesaikan skema jalur data
kami, seperti yang ditunjukkan pada gambar di bawah ini.
Seperti yang dapat kita lihat, operan untuk ditambahkan pada saat tertentu (OP3,
OP2, OP1 atau OP0) dipilih oleh multiplexer6 4-channel .
6
Perhatikan bahwa jika kita ingin menaikkan jumlah operan, kita tidak boleh mengubah
bagian aritmatika tetapi menambahkan multiplexer yang lebih besar. Ini berlaku sampai
penjumlahan operan tidak lagi melebihi jumlah maksimum yang dapat diungkapkan oleh
bagian aritmatika.
Untuk membuat skema lebih mudah dipahami subsistem akuisisi data di input
terlampir dalam bingkai bertanda "Input Data". Pemilihan saluran dikendalikan oleh
P1 dan P0. Pada titik simulasi yang ditangkap pada gambar, garis P1 = '0' dan P0 =
'1' membuat operand OP1 dirutekan oleh saluran yang dipilih oleh multiplexer pada
input penambah. Lihat panah pada gambar.
Register paralel telah digantikan oleh “register universal”, yang fungsinya dikendalikan
oleh garis S1 dan S0. Dengan cara ini, kita dapat memerintahkan register untuk
menggeser isinya dua posisi ke kanan di akhir operasi penjumlahan. Tabel di bawah
menunjukkan fungsi yang diperoleh register universal tergantung pada nilai S1 dan
S0.
Fungsi S1 S0
0 0 Konten tidak berubah

0 1 Pergeseran "Kanan"
1 0 Pergeseran "Kiri"
1 1 Pemuatan paralel
Dalam simulasi pada gambar, kita dapat melihat bahwa nomor '00000110' ada di
register. Penambah menambahkan nomor ini ke salah satu dari operan OP1,
'00001001', karena dipilih oleh pengaturan P1 dan P0. Kita bisa melihat hasilnya di
output: '00001111'.
Pada tepi naik berikutnya dari jam CK, S1 dan S0 diatur ke '1' berarti bahwa output
dari penambah akan disimpan dalam register. Hasil parsial baru akan menggantikan
yang sebelumnya.
Setelah menentukan jalur data jaringan, sekarang kita perlu mengurus pengurutan
otomatis garis S1, S0, P1 dan P0. Jadi mari tambahkan pengontrol Finite State
Machine (FSM), yang memberi kita skema definitif. Lihat gambar berikut.
Selain itu, jaringan memiliki output END tambahan yang berasal dari pengontrol dan
menandakan akhir dari suatu perhitungan.
Singkatnya, register universal digunakan dalam arsitektur ini untuk mengingat hasil
antara dari suatu penjumlahan dan untuk menggandakannya ke kanan.
Mulai sekarang, kita akan menyebut register ini sebagai “Akumulator”, karena dapat
mengingat (mengakumulasi) sebagian hasil perhitungan. Juga, output yang
memvisualisasikan konten akan disebut ACC.
FSM berfungsi sebagai sistem "Pengontrol", juga dikenal sebagai "Sequencer". Yaitu
menghasilkan urutan sinyal yang benar untuk dikirim ke komponen lain dari "Datapath"
yang memproses data untuk menjalankan tugas (dalam kasus kami, menghitung rata-
rata).

1.2.1.3 Algoritma sequencer
Bagan Algorithmic State Machine (ASM) di sebelah kanan

menjelaskan cara kerja algoritma sequencer.
Pada state (a) baris S1 (='1') dan S0 (='1') memerintahkan
untuk memuat data yang tersedia pada output penambah
ke dalam akumulator. Ini sama dengan jumlah operan OP0
(dipilih oleh pengaturan multiplexer P1='0', P0='0') dan isi
register itu sendiri, yang dibersihkan oleh. Reset sebelum
(dengan kata lain, nilai operan dimuat di register OP0).
Dalam keadaan (b) register diperintahkan (S1='1', S0='1')

untuk memuat nilai dari penambah, yang sama dengan
jumlah operan OP1 (dipilih oleh pengaturan multiplexer
P1='0 ', P0='1') dan register itu sendiri, yang seperti yang
telah kita lihat sama dengan operan OP0.
Dalam keadaan (c) akumulator (S1='1', S0='1') dipanggil
lagi untuk mengingat nilai yang dihasilkan oleh penambah.
Dalam hal ini, jumlah operan OP2 (memilih P1='1', P0='0')
adalah isi register saat ini (jumlah operan OP0 dan OP1).
Pada state (d), kita mempertahankan S1='1' dan S0='1',

dan memerintahkan register untuk terakhir kalinya memuat
output dari penambah, yang sama dengan jumlah operan
OP3 (memilih P1=' 1', P0='1') dan isi dari register itu sendiri,
yaitu jumlah operan OP0, OP1 dan OP2. Setelah operasi
terakhir ini, jumlah total dari 4 operan akan ada di register.
Di negara bagian (e) dan (f) kami memerintahkan register ke kanan menggeser isinya dua
kali dan memasukkan nol ke sisi kiri sehingga membagi empat.
Dalam keadaan (g) output END diaktifkan untuk menunjukkan "akhir proses",
dan FSM stand by sampai reset.
1.2.1.4 Simulasi
Simulasi diagram waktu memungkinkan kita untuk memeriksa evolusi sinyal

pada inisialisasi sistem. Lihat gambar di bawah ini.
Kita dapat melihat perubahan sinyal kontrol S1, S0, P1 dan P0 pada setiap tepi
naik jam CK. Hasil (Jumlah) dimuat ke register di tepi 2, 3, 4 dan 5. Pada tepi 6
dan 7, isinya bergeser ke kanan. Akhirnya, output END menunjukkan bahwa
komputasi telah berakhir (RIS = 5).
1.2.2 Penghitung dan sequencer berbasis memori ROM
Jenis sequencer yang lebih umum terdiri dari counter yang menangani memori
ROM (lihat Lampiran A.1) yang berisi urutan sinyal kontrol yang akan dipancarkan.
Lihat gambar di bawah ini.
Jenis ini memiliki keuntungan besar: tidak perlu mensintesis ulang FSM setiap kali kita ingin
mengubah urutan untuk dieksekusi. Yang diperlukan hanyalah mengubah bit dalam ROM.
Dengan kata lain, perangkat keras "fisik" dari sirkuit kami dapat tetap sama (tidak perlu didesain
ulang atau dibangun kembali); kita hanya perlu mengubah isi memori.
Untuk jaringan kami, kami telah memilih untuk menggunakan penghitung universal biner 8-bit
yang menghitung maju, mulai dari nol saat direset. Baris EN memungkinkan kita memulai dan
menghentikan hitungan.
Dengan 8 bit alamat kita dapat membaca 256 lokasi ROM. Alamat memori juga memiliki 8 bit
sehingga kita dapat menghubungkan paling banyak 8 bit jalur kontrol ke jalur data (dilambangkan
pada gambar sebagai D7, D6, ..., D0).
Sebagai contoh, pada gambar di atas, penghitung telah mencapai angka "00000011", selama
simulasi. Memori memberikan nilai “11000011”, yang terdapat di lokasi di alamat tersebut.
Jadi mari kita ganti FSM dengan sequencer baru dan dapatkan skema pada gambar di bawah
ini. Hanya 5 dari 8 jalur keluaran yang telah digunakan dari ROM, P1 dan P0 pada bit D7 dan
D6, S1 dan S0 pada bit D1 dan D0. Kami hanya akan menggunakan D4, D3 dan D2 pada contoh
berikutnya.
Jalur data identik dengan yang ada di jaringan sebelumnya kecuali untuk modifikasi kecil pada
jalur END. Seperti yang kita lihat, baris END dibawa kembali ke penghitung oleh NOT, sehingga
ketika diaktifkan, itu akan memungkinkan untuk menonaktifkan penghitung dan menghentikan
urutan.
ROM berisi urutan sinyal kontrol yang dipesan untuk dikirim ke komponen.
Dalam versi ini, kami ingin itu identik dengan yang dihasilkan oleh FSM sirkuit
sebelumnya.
Saat sistem direset, penghitung diinisialisasi ke nol sehingga memori akan
mengirimkan perintah yang disimpan di alamat nol. Jadi, lokasi ini harus berisi
sinyal yang dipancarkan oleh FSM versi sebelumnya dalam status (a), status
reset. Di tepi naik jam berikutnya, penghitung bertambah satu
dan mengirimkan konten dari lokasi kedua, yang seharusnya berisi

sinyal bahwa FSM memancarkan di negara bagian kedua ... dan seterusnya untuk sisa
lokasi.
Dengan mengikuti pendekatan ini, kami menyelesaikan pemrograman memori

lokasi dan mendapatkan hasil yang ditunjukkan pada tabel di bawah ini. Di sebelah setiap ROM
lokasi, kita melihat keadaan yang sesuai dari FSM sebelumnya. Kita tidak
tertarik pada lokasi memori lain sehingga mereka dapat berisi kode apa pun karena
jaringan kami tidak menanganinya.
Isi ROM FSM

Alamat (Hex) P1 P0 AKHIR xxx S1 S0 Negara
00000000 00j 0 0 (b) 0 000 1 1 (Sebuah)
0000001 01 jam 0 1 0 000 1 1

00000010 02h 1 0 0 000 1 1 (C)
00000011 03h 1 1 0 000 1 1 (D)
00000100 04 jam 0 0 0 00001 (e)
00000101 05 jam 0 0 0 00001 (F)
00000110 06 jam 0 0 1 00000 (G)
00000111 07h ... ... ... ... ... ... ... ... ...
00001000 08h ... ... ... ... ... ... ... ... ...
Jaringan kami tumbuh lebih kompleks tetapi juga lebih fleksibel. Dengan memperkenalkan
Memori ROM di sequencer, kami telah membuat perilaku sirkuit
lebih mudah didefinisikan ulang.
1.2.3 Memperluas kemungkinan komputasi
Hanya memiliki penambah yang tersedia tidak menawarkan banyak derajat kebebasan dalam
menggunakan sistem, tetapi ketika komponen baru diperkenalkan, sirkuit
kemungkinan mulai menjadi lebih menarik. Pertimbangkan opsi untuk mengganti
penambah dengan jaringan kombinasional yang dapat menjalankan operasi yang berbeda
seperti penjumlahan, pengurangan, operasi logika, dll.
Fungsi
Jika kita menambahkan opsi komputasi, kita dapat menentukan banyak hal
A+B
urutan operasi yang lebih fleksibel. Jaringan logika A-B
yang dapat mengeksekusi matematika dan logika yang berbeda
A dan B (sedikit demi sedikit)
operasi disebut Unit Logika Aritmatika (ALU).
A atau B (sedikit demi sedikit)
Tabel di sebelah kanan menunjukkan serangkaian fungsi exe
yang dapat dipotong. tidak a
tidak b
Mari kita rancang ALU yang menjalankan serangkaian fungsi
SEBUAH
ini. Gambar di bawah ini menunjukkan hasil kami.

B

Skema terdiri dari sirkuit aritmatika dan logika yang masing-masing menjalankan salah satu
fungsi yang tercantum di atas pada operan input. individu
keluaran sirkuit bergabung menjadi pemilih 8 saluran yang memungkinkan kita untuk memilih
operasi yang kita inginkan pada output F dalam fungsi input S2, S1 dan S0.
Perhatikan bahwa jaringan ini murni kombinasional. Tabel di bawah ini menunjukkan
Fungsi ALU tergantung pada input kontrolnya S2, S1 dan S0.
S2 S1 S0 Fungsi
0 0 0 A+B
0 0 1 A-B
0 1 0 A dan B (sedikit demi sedikit)
0 1 1 A atau B (sedikit demi sedikit)
1 0 0 bukan A
1 0 1 tidak b
1 1 0 SEBUAH
1 1 1 B
Dalam skema, kami menemukan komponen pelengkap di seberang penambah.

Ketika kita mengurangkan AB, ini dihitung sebagai A+C2(B). Komplemen dua adalah
dihitung dengan membalik semua bit operan B dan menambahkan '1'. Kami menambahkan '1'
dengan mengatur input penambah (Ci) sama dengan '1', dalam kasus pengurangan.
Ada juga dua output tambahan yang disebut ZF (Zero Flag) dan CO (Carry
Keluaran). ZF memberi sinyal saat hasilnya nol, sedangkan CO aktif kapan saja
sirkuit menghasilkan carry setelah menambahkan (atau permintaan pinjaman dalam kasus
pengurangan).
Keluaran tambahan disebut "Bendera" dan sangat berguna saat mengevaluasi
hasil pemrosesan, seperti yang akan kita lihat di depan. Misalnya, saat mengurangkan,
kita dapat menentukan apakah kedua operan itu sama dan jika tidak, mana yang lebih besar
daripada yang lain.
Kita dapat melakukan ini dengan menilai nilai bendera Bendera
setelah operasi. Lihat tabel di sebelah kanan. jika Hasil CO ZF

zero flag ZF diaktifkan, operandnya sama. Jika A=B0 1
tidak, keluaran pembawa CO aktif hanya jika A < B. Ini A>B0 0
konvensi digunakan dalam prosesor Intel, misalnya. A<B1 0
Di prosesor komersial, ada juga jenis bendera lain seperti Parity

Tandai PF yang menunjukkan jika jumlah bit pada '1' pada hasil ALU genap
atau aneh. Di sini, kami hanya akan mempertimbangkan flag dasar.
1.2.4 Jaringan komputasi berbasis ALU
Gambar di bawah menunjukkan jaringan yang sangat mirip dengan yang ditunjukkan di atas,
tetapi yang ini memiliki ALU daripada penambah sederhana.
Juga, skema berbeda dari yang sebelumnya dengan fakta bahwa ALU
kabel set-up terhubung ke jalur output ROM. Tabel di bawah ini menunjukkan
ringkasan koneksi antara 8 jalur ROM dan jalur kontrol
digunakan di jalur data.
D07 D06 D05 D04 D03 D02 D01 D00

P1 P0 AKHIR F2 F1 F0 S1 S0
Jaringan baru dapat menghitung rata-rata dari empat nilai dengan yang sama
setup bit seperti pada ROM versi sebelumnya, tanpa modifikasi.
Isi ROM
Alamat P1 P0 AKHIR F2 F1 F0 S1 S0 (Hex)

00h 000 0001 1 03 jam
01 jam 01 0 0001 1 43j
02 jam 100 0001 1 83j
03 jam 1 1 0 0001 1 C3h
04 jam 000 0 0 0 0 1 01j
05 jam 000 0 0 0 0 1 01j
06 jam 00 1 0 0 0 0 0 20j
Di versi sebelumnya sebenarnya, kami telah memaksa garis yang tidak digunakan ke nol sedangkan
sekarang mereka (di sini berganti nama menjadi F2, F1 e F0) mengontrol fungsi ALU dan
konfigurasi '000' tepat sesuai dengan fungsi jumlah dari
dua operan.
1.2.4.1 Contoh komputasi lain
Di sini, mari kita rekap apa yang mampu dilakukan oleh jaringan logika kita dalam konfigurasinya
saat ini:
1. melakukan hingga 256 operasi secara berurutan

2. melakukan 8 operasi aritmatika dan logika, seperti penjumlahan, pengurangan
dan operasi logika bitwise (AND, OR, NOT)
3. menghasilkan flag ZF dan CO untuk memberikan evaluasi operan kepada pengguna
dan hasilnya (hasil evaluasi ini belum dapat digunakan kembali oleh
jaringan itu sendiri dalam versi ini).
Sekarang, mari kita definisikan contoh komputasi lainnya. Kami ingin urutan
operasi yang mengevaluasi jika hasil dari jumlah operan OP0 dan OP1 adalah
lebih besar dari sama dengan atau lebih kecil dari operan OP2.
Eksekusi urutan dapat dibagi menjadi 3 langkah:

1. menambahkan operan OP0 ke operan OP1
2. mengurangkan operan OP2 dari hasil sebelumnya, menghasilkan flag ZF
dan CO, dan menghentikan urutan komputasi
3. mengevaluasi bendera.
Jaringan kami dapat melakukan dua langkah pertama jika memori ROM
diprogram dengan tepat. Langkah terakhir harus dilakukan oleh pengguna akhir atau
rangkaian logika lainnya.
— P1 dan P0: mengatur pemilihan operan input OP3..OP0

— END: digunakan untuk menghentikan pengurutan
— F2, F1, F0: menentukan operasi ALU;
— S1, S0: mengontrol fungsi register universal.
Melakukan langkah 1) berarti: memilih operan OP0 melalui multiplexer,
pengaturan P1='0', P0='0'; memerintahkan ALU untuk menyalin operan OP0 ke
output (F=B) dan karenanya menyetel F2='1', F1='1' dan F0='1'; berwibawa
akumulator untuk memperbarui isinya dengan hasil yang berasal dari ALU
(dengan kata lain, operan OP0), pengaturan S1='1' dan S0='1'. Jelas, kita harus
setel END='0'. Jadi kami mengakhiri pengkodean lokasi pertama memori ROM:
P1 P0 AKHIR F2 F1 F0 S1 S0 Deskripsi
0 0 0 1 1 1 1 1 A OP0
Kemudian, kita pilih operand OP1 membuat P1='0' dan P0='1'; perintah ALU
untuk menambahkan konten akumulator ke operan OP1, mendefinisikan F2='0',
F1='0' dan F0='0'; dan memaksa pembaruan konten akumulator
dengan hasil dari ALU (S1='1', S0='1'). Lokasi ROM berikutnya akan
kemudian memiliki nilai-nilai berikut:
P1 P0 AKHIR F2 F1 F0 S1 S0 Keterangan
0 1 0 00 0 1 1 A ( A + OP1 )
Pada langkah 2), untuk mengurangi operan OP2 dari hasil di akumulator, kita
harus memerintahkan multiplexer untuk memilih operan OP2 (P1='1', P0='0') dan
ke ALU untuk dikurangi (F2='0', F1='0', F0='1'). Di bawah ini kita melihat isinya
dari lokasi ketiga:
1 0 1 001 0 0 ( A - OP2 )
Untuk menghentikan urutan di akhir operasi ini, kami menetapkan END=1.

Perhatikan bahwa hasil di akumulator tidak diatur untuk memuat (S1='0', S0='0').
Ini karena operan dari pengurangan pada input ALU harus
tetap stabil sampai kita dapat melihat nilai yang diambil oleh flag. Tabel di bawah ini
menunjukkan evaluasi akhir (langkah 3).
Evaluasi Akhir
Hasil CO ZF
(OP0 + OP1) = OP2 0 1
(OP0 + OP1) > OP2 0 0
(OP0 + OP1) < OP2 1 0
Berikut di bawah ini adalah ringkasan kode untuk dimasukkan ke dalam ROM.
Isi ROM
Alamat ROM (Hex) P1 P0 END F2 F1 F0 S1 S0 Deskripsi

00h 00 0 1 1 1 1 1 A OP0
01 jam 01 0 0001 1 A ( A + OP1 )
02 jam 10 1 0 0 1 0 0 ( A - OP2 )
1.2.5 “Petunjuk”
Karena mesin melakukan operasi yang kita masukkan ke dalam memori,

mulai sekarang kami akan memanggil operasi yang dapat dilakukan jaringan "instruksi".
Mendefinisikan instruksi dalam ROM sedikit demi sedikit bisa menjadi pekerjaan yang panjang dan membosankan
mudah mengalami kesalahan. Untuk mempermudah ini, kami akan memperkenalkan kode mnemonik
yang akan kami kaitkan dengan setiap instruksi yang mungkin.
Dengan cara ini akan lebih mudah untuk menentukan isi ROM. Kami hanya akan
mengekspresikan algoritma yang ingin kita lakukan dalam hal kode mnemonic,
yang dapat dengan mudah diterjemahkan ke dalam kode biner yang sesuai (juga dikenal
sebagai "kode mesin").
Tahap penulisan kode mnemonic akan didukung oleh editor teks,
dan terjemahan ke dalam kode mesin akan dilakukan nanti.
Kembali ke contoh di atas, menggeser operan OP0 ke register A adalah

dilakukan dengan menggunakan kode berikut:
0 0 0 1 1 1 1 1 A OP0
Kode mesin ini dapat dikaitkan dengan mnemonik ini:
DI A,OP0
di mana IN mengacu pada "Input", mendapatkan operan dari luar; si A, yang

singkatan dari register akumulator, adalah tujuan operan, dan OP0
setelah koma mewakili sumber operan. Penggunaan mnemonik ini
kode umum dalam manual teknis untuk mikroprosesor.
Tentu kita perlu mendefinisikan kode yang sama untuk operan yang tersisa. Melihat
di bawah:
DI A,OP0
DI A,OP1
DI A,OP2
DI A,OP3
Keempat kode ini secara ringkas dapat diungkapkan dengan kode berikut:
DI A,P
di mana P mewakili salah satu dari empat kemungkinan input. Mengkodekan bit dengan menggunakan ini
empat mnemonik lebih cepat jika kita menunjukkan bit p1 dan p0 yang mengontrol mul
tiplexer:
Kode Mnemonik P1 P0 AKHIR F2 F1 F0 S1 S0
DI A,P p1 p0 0 1 1 1 1 1
Alasan yang sama dapat diterapkan pada penambahan: kode yang baik untuk direpresentasikan
tambahan adalah kata TAMBAH. Di jaringan kami, satu-satunya tujuan yang mungkin dari
hasilnya adalah register akumulator (ini berlaku untuk semua operasi ALU
melaksanakan) jadi A akan menjadi bagian kedua dari kode mnemonic.
Mengingat bahwa ada 4 kemungkinan operan untuk instruksi ini juga, yang terakhir
bagian dari kode mnemonic, setelah koma, adalah P. Jadi kita mendapatkan mnemonic ini:
TAMBAHKAN A,P
diwakili oleh kode biner di bawah ini:
TAMBAHKAN A,P p1 p0 0 0 0 0 1 1
Mengikuti alasan yang sama, kami akan mengaitkan kode untuk setiap operasi
yang dilakukan ALU, memberi kita mnemonik berikut. Harap dicatat bahwa jika
operan bertepatan dengan tujuan hasil, hanya tujuan
ditunjukkan.
Kode Mnemonic P1 P0 END F2 F1 F0 S1 S0 Deskripsi

DI A,P p1 p0 0 1 1 1 1 1 A P
TAMBAHKAN A,P p1 p0 0 0 0 0 1 1 A (A + P)
SUB A,P p1 p0 0 0 0 1 1 1 A (A - P)
DAN A,P p1 p0 0 0 1 0 1 1 A (A dan P)
ATAU A,P p1 p0 0 0 1 1 1 1 A (A atau P)
TIDAK A 0 0 0 1 0 0 1 1 A TIDAK(A)
Perhatikan juga bahwa ketika instruksi NOT A sedang dieksekusi sistem

mengabaikan dua bit pertama. Demi kesederhanaan, kami telah memutuskan untuk mengaturnya ke
0, tetapi nilai lain apa pun akan berfungsi dengan baik (metode ini juga akan menjadi
diadopsi sebagai berikut).
Apa yang telah kita periksa sejauh ini bukan satu-satunya instruksi yang jaringan
bisa mengeksekusi. Perhatikan misalnya menggeser ke kanan isi akumulator dengan
menempatkan 0 ke kiri, ditunjukkan pada deretan bit di bawah ini:

SRL A 00 0 0 0 001
6 bit pertama dapat mengambil nilai apa pun karena jaringan mengabaikannya saat
melaksanakan instruksi.
Operasi ini sangat berguna untuk membagi dua dan dapat dilambangkan dengan
inisial SRL yang menunjukkan Shift Right Logic.
Adapun instruksi shift, kata "Logika" biasanya digunakan untuk menunjukkan
menyisipkan nol di sebelah kiri. Kata "Aritmatika" bagaimanapun, digunakan dalam hubungan
ke kanan bergeser ketika bit paling signifikan itu sendiri (yang mewakili
tanda) disisipkan di sebelah kiri7 . Hasil dari operasi shifting dilakukan di
akumulator dan satu-satunya operan yang mungkin ada di sana, jadi kita punya
memilih mnemonic SRL A.
Demikian pula, kami akan menggunakan mnemonic SLL A untuk menunjukkan instruksi shift kiri,
yang akan memasukkan '0' di sebelah kanan:

SLL A 00 0 0 0 0 1 0
7
Karena sirkuit kami hanya dapat memasukkan nol dalam input serial (InR dan InL) dari
register universal, operasi pergeseran aritmatika tidak akan muncul di sini. Bagaimanapun,
akan berguna untuk memahami perbedaan ini.
Berguna untuk memformalkan operasi yang membuat hasil di akumulator tidak

berubah. Sebut saja operasi ini NOP (“Tidak Ada Operasi”). Lihat
konfigurasi yang sesuai dari bit di bawah ini:

TIDAK 00 0 0 0 000
Perhatikan bahwa 2 bit pertama dan yang terkait dengan ALU dapat mengambil bit lainnya
nilai karena mereka tidak memiliki pengaruh pada isi register A.
Akhirnya, kami telah menggunakan bit END untuk menghentikan eksekusi. Sebuah variasi
pada NOP ditunjukkan di bawah, di mana jaringan tidak melakukan apa-apa, tetapi
sequencer juga berhenti; kami akan menyebutnya HALT.

BERHENTI 00 1 0 0 000
Tabel berikut merangkum kode mnemonic:
Kode Mnemonic P1 P0 END F2 F1 F0 S1 S0 Deskripsi

DI A,P p1 p0 0 11 1 1 1AP
TAMBAHKAN A,P p1 p0 0 0001 1 A (A + P)

SUB A,P p1 p0 0 001 1 1 A (A - P)
DAN A,P p1 p0 0 0101 1 A (A dan P)
ATAU A,P p1 p0 0 01 1 1 1 A (A atau P)
TIDAK A 00 0 1001 1 A TIDAK(A)
SRL A 00 0 0 0 0 0 1 A (A div 2)
SLL A 00 0 0 0 0 1 0 A (A per 2)
TIDAK 00 0 0 0 0 0 0 Tanpa Operasi
BERHENTI 00 1 0 0 0 0 0 Sequencer Berhenti
Sebagai contoh, mari kita lihat tabel di bawah ini yang menunjukkan algoritma (dibahas
sebelumnya) yang menghitung rata-rata angka, dan menyandingkan kode
mesinnya dengan padanan mnemonik.
Jelas, kode mnemonic menawarkan pemahaman dan keterbacaan yang lebih besar.
Kode Mnemonik Kode Mesin

TAMBAHKAN A,OP0 0 0 0 0 0 0 1 1
TAMBAHKAN A,OP1 0 1 0000 1 1
TAMBAHKAN A,OP2 1 00000 1 1
TAMBAHKAN A,OP3 1 1 0000 1 1
SRL A 0000000 1
SRL A 0000000 1
BERHENTI 00100000
Tabel instruksi lengkap dengan semua varian dan skema jaringan

tersedia di Lampiran B.1 (jaringan ini disebut Mp8A).
1.2.6 "Program", "pemrograman" dan istilah penting lainnya
Kita telah melihat bahwa instruksi dalam kode mnemonik berguna untuk menunjukkan dasar
operasi mesin diminta untuk melakukan, dalam format yang cukup mudah dibaca.
Sampai sekarang, kami akan memanggil urutan instruksi yang menggambarkan urutan
operasi (algoritma) untuk dieksekusi, sebuah "program".
Kami akan "memprogram sistem" dalam dua fase: pada fase pertama kami menulis file teks
dengan urutan instruksi dalam kode mnemonic yang menjelaskan algoritma
yang ingin kita peroleh. Pada fase dua, kami menerjemahkan kode mnemonic menjadi
kode mesin untuk dimasukkan ke dalam ROM. Dilihat dari fungsinya,
ROM biasanya disebut Memori Program.
Seperti disebutkan di atas, fase satu didukung oleh editor teks, sedangkan fase dua
memerlukan penggunaan mnemonic code-machine code translator (atau "compiler")
(jenis aplikasi ini disebut "perakit").
Seperti yang telah kita lihat sebelumnya, alamat instruksi yang akan dieksekusi dihasilkan
oleh penghitung di dalam sequencer jaringan. Mulai sekarang, penghitung itu adalah
disebut dengan nama aslinya, “Program Counter” (PC), yang mengindeks
instruksi program individu, sehingga mereka dieksekusi secara berurutan, satu demi satu
satu. Dalam literatur teknis, istilah Penghitung Program bukanlah satu-satunya cara untuk
lihat ini; istilah "Petunjuk Instruksi" (IP) juga digunakan.
1.3 Urutan, instruksi mikro, dan program mikro
Di bagian ini kita akan mengubah sequencer sehingga sistem pemrosesan kita akan dapat
menjalankan tugas yang lebih kompleks. Kami akan memperkenalkan elemen baru seperti instruksi
mikro, memori program mikro dan jalur instruksi.
1.3.1 Sequencer yang lebih ringkas
Jaringan yang dirancang pada Bagian 1.2 dapat dikembangkan lebih lanjut. Sejauh ini, ia hanya
dapat mengeksekusi sekitar 10 instruksi. Itu belum mendapatkan kemampuan untuk melakukan
urutan instruksi yang berbeda berdasarkan hasil perhitungan menengah, yang merupakan dasar
untuk sistem pemrosesan apa pun. Sebagai contoh, dalam sistem kontrol sebuah instalasi
pemanas, jika sensor mengukur suhu lebih rendah dari yang diinginkan, urutan harus dilakukan
untuk menyalakan pemanas, jika suhu sudah pada tingkat yang tepat, tidak ada tindakan yang
diambil. .
Selanjutnya, untuk membuat jaringan pemrosesan lebih fleksibel, kami akan menambahkan banyak
elemen ke jalur data. Jaringan dan jumlah jalur yang diperlukan untuk mengontrolnya akan menjadi
lebih kompleks. Dengan struktur pengurutan saat ini, pengenalan garis kontrol baru memerlukan
penambahan bit lain ke kode mesin.
Harap dicatat bahwa, saat menulis sebuah program, kita akan menggunakan kode yang sama
berulang kali dan seiring bertambahnya ukuran, kita akan membutuhkan lebih banyak memori program.
Mengingat perubahan yang diperlukan ini, mungkin berguna untuk memikirkan kembali jaringan
pengurutan sistem saat ini (lihat gambar di bawah) dan menambahkan sistem pengkodean instruksi.
1.3 Urutan, instruksi mikro, dan program mikro 31
Pada gambar di atas, kami telah memisahkan sequencer dari sisa jaringan. Tujuan
pertama kami adalah meninjau strukturnya agar dapat menggunakan kode mesin
yang paling ringkas. Dalam konfigurasi saat ini, Penghitung Program (PC) menangani
Memori Program (PM). Dengan cara kombinasional, PM mengembalikan kode
instruksi yang ditemukan di alamat. Alamat yang dihasilkan PC bertambah pada tepi
aktif jam CK jika sinyal pengaktifan penghitung program (ENPC) telah diaktifkan.
Dalam struktur ini, kode instruksi diwakili oleh kumpulan bit yang diperlukan untuk
mengontrol elemen jalur data secara langsung. Seperti yang dikatakan sebelumnya,
jika kita mempertahankan pengaturan ini dan menaikkan elemen di jalur data, jumlah
bit per lokasi memori meningkat secara bersamaan. Kita perlu mencapai pemadatan
kode dari kode instruksi individu dengan memilih kriteria yang sesuai.
Gambar di bawah menunjukkan jaringan decoding instruksi yang berbeda. Seperti
yang Anda lihat, ada satu elemen lagi yang ditambahkan vis-a-vis struktur sebelumnya:
memori ROM baru di sisi kanan bawah.
Dalam versi baru ini, kode mesin yang dipasok oleh PM tidak lagi didefinisikan sebagai
kombinasi sinyal kontrol yang diaktifkan untuk menjalankan instruksi, tetapi sebagai
alamat yang memilih lokasi yang disimpan di ROM kedua.
Inilah yang berisi sinyal kontrol untuk diaktifkan.
Mulai sekarang, kita akan menyebut kumpulan sinyal kontrol yang terkait dengan
instruksi tertentu sebagai "Microcode", dan ROM yang berisi "Microcode Memory", (MCM').
Perancang jaringan sebelumnya akan mengingat semua mikrokode di MCM. Kode
mesin untuk instruksi itu sendiri (yang akan dimasukkan oleh programmer ke dalam
PM) sebenarnya akan menjadi alamat mikrokode.
Jelas, perancang jaringan perlu mendokumentasikan semua instruksi yang tersedia bersama
dengan kode mereka untuk digunakan oleh programmer.
Karena alamat lokasi memori tidak bergantung pada panjang kontennya, versi baru ini akan
membantu kami membuat panjang kode mesin tidak bergantung pada jumlah jalur kontrol.
Dalam contoh kita, MCM memiliki 256 lokasi pada masing-masing 16-bit. Ini berarti kita dapat
mengontrol hingga 16 jalur kontrol jalur data meskipun kita hanya menggunakan kode instruksi
8-bit.
Perhatikan bahwa MCM bertindak sebagai dekoder instruksi sehingga dapat ditempatkan
kembali oleh jaringan kombinatorial yang dirancang khusus. Solusi berbasis memori ROM,
bagaimanapun, lebih praktis karena memungkinkan kita untuk mengekspresikan mikrokode
secara eksplisit.
Terakhir, garis kontrol baru (LDPC) telah ditambahkan, dan terhubung ke perintah beban PC
(LD). Ini akan digunakan di Bagian 1.4 untuk memuat nilai baru di dalam PC, sebagai cara
untuk memvariasikan urutan eksekusi instruksi. Untuk saat ini, bagaimanapun, itu tetap tidak
aktif.
1.3.2 Sequencer yang diprogram mikro
Solusi yang dibahas di sini menyelesaikan masalah kode instruksi yang ringkas tetapi masih
memiliki batasan. Beberapa instruksi akan membutuhkan beberapa siklus clock untuk
diselesaikan, karena persyaratan pengaturan waktu komponen. Misalnya, instruksi untuk
mengubah konten PC, seperti yang akan kita lihat di Bagian 1.4.
Ini tidak mungkin dalam struktur saat ini; hanya satu konfigurasi sinyal kontrol yang sesuai
dengan setiap kode instruksi, dan dihasilkan melalui satu siklus clock tunggal. Kita perlu
membuatnya agar dihasilkan secara berurutan sehingga konfigurasi sinyal yang berbeda
disajikan ke jaringan dalam siklus clock yang berurutan.
Untuk mewujudkannya, kami membuat perubahan yang memungkinkan kami untuk

menjalankan instruksi seolah-olah masing-masing adalah program kecil yang terdiri dari
beberapa mikrokode berurutan.
Untuk mendapatkan perbedaan yang lebih baik tentang apa yang terjadi dalam konteks umum,
sebut saja mikrokode individu "instruksi mikro" dan kumpulan instruksi mikro yang mendefinisikan
perilaku instruksi "program mikro". Kami menyebut struktur baru ini sebagai "sequencer
mikroprogram".
Perubahan yang perlu kita lakukan terdiri dari menambahkan penghitung lain sebelum MCM
yang diperkenalkan sebelumnya. Kami mendapatkan struktur di mana kode mesin instruksi
yang diambil dari PM dimuat di penghitung baru daripada ke alamat MCM secara langsung.
Sebut saja elemen baru ini "Microprogram Counter" (MPC), dan ROM yang sebelumnya
ditambahkan, yang mulai sekarang akan berisi mikroprogram "Micro program Memory" (MPM).
Lihat gambar berikut.
Dalam sequencer baru ini, kode mesin tidak lagi sesuai dengan alamat mikrokode
individu tetapi mewakili alamat instruksi mikro pertama dari program mikro yang
dieksekusi. Setelah penghitung MPC menangani instruksi mikro pertama MPM, itu
bertambah sehingga menargetkan instruksi mikro berikutnya dari program mikro.
Bagian atas jaringan, terdiri dari PC dan PM memberikan instruksi. Bagian bawah
(MPC dan MPM) menjalankan program mikro yang sesuai.
Mikroprogram instruksi tertentu secara definitif terbentuk pada fase desain dan
tidak pernah diubah lagi kecuali ada koreksi yang harus dilakukan atau perluasan
yang harus dilakukan.
Kita dapat mengontrol semua elemen jaringan perhitungan dengan output MPM
D15..D0. Dari perspektif fungsional, MPM bekerja pada jaringan dengan cara yang
sama seperti MCM yang terlihat sebelumnya.
Seperti yang terlihat di bagian bawah skema, penghitung MPC dipaksa untuk selalu
menghitung maju kecuali saluran LDMC memaksanya untuk memuat. Saat aktif, kode
instruksi dalam output memori program dimuat di penghitung.
Jika kami selalu memerintahkan MPC untuk memuat, kami hanya akan mendapatkan
fungsi yang sama seperti jaringan sebelumnya. Setelah kode instruksi dimuat, masih
mungkin untuk menonaktifkan LDMC dan membuat pencacah MPC meningkat pada
setiap tepi naik jam yang berurutan.
Seperti disebutkan sebelumnya, kode instruksi dalam memori program dari struktur
baru ini mewakili alamat dari mana mikroprogram (sesuai dengan instruksi itu sendiri)
dimulai. Dalam kasus yang paling sederhana, program mikro terdiri dari hanya satu
instruksi mikro.
MPC dan MPM bersama-sama melakukan "penguraian kode berurutan" dari instruksi
yang diambil dari PM di mana mereka membuat semua sinyal kontrol yang diperlukan
untuk eksekusi tersedia dalam urutan yang ditentukan oleh instruksi mikro.
1.3.3 Sequencer yang diprogram mikro dan jaringan komputasi
Seperti yang telah kita lihat, fungsi sequencer baru dikendalikan oleh jalur LDPC,
ENPC dan LDMC. Kami akan membuatnya sehingga sequencer itu sendiri yang
menua mereka. Mari kita hubungkan output memori mikroprogram sehingga instruksi
mikro itu sendiri memutuskan apakah dan kapan harus menambah atau memuat PC,
memuat instruksi di MPC atau memaksanya maju.
Mari kita pertimbangkan jaringan perhitungan yang diperiksa di Bagian 1.2, dan ganti
sequencer-nya dengan yang diprogram mikro. Di sini, kami telah membagi skema
menjadi dua bagian dengan garis merah putus-putus agar lebih mudah dibaca. Seluruh
skema ditunjukkan pada Lampiran B.2.2 (jaringan ini disebut Mp8B).
Halaman berikutnya menunjukkan bagian dengan jalur data dengan beberapa adaptasi
kecil pada koneksi ke jalur kontrol baru. Halaman selanjutnya menunjukkan bagian
dengan sequencer yang diprogram mikro di mana jalur LDMC telah terhubung ke bit
D15 MPM dan jalur ENPC ke bit D14 sehingga mikrokode dapat langsung memaksa
PC maju (atau tidak) melalui ENPC, dan / atau memuat atau memajukan MPC melalui
LDMC.
Untuk saat ini, kita tidak perlu memuat ulang PC dengan nilai baru, itulah sebabnya
kami telah menghilangkan LDPC baris dari skema yang membuat perintah counter
load menjadi tidak aktif (kita akan menggunakan baris ini selanjutnya, di Bagian 1.4).
Perhatikan bahwa ada jalur kontrol yang belum digunakan tetapi akan ada di jaringan
berikutnya.

1.3.4 Cara kerjanya
Seperti yang telah kita lihat, setelah kode instruksi yang diberikan oleh PM dimuat di MPC, itu menjadi
alamat sumber untuk membaca MPM. Oleh karena itu, untuk menetapkan instruksi tertentu, kita hanya
perlu menulis instruksi mikro di lokasi tersebut dan di lokasi berikutnya. Setiap instruksi mikro harus
memiliki konfigurasi sinyal yang disesuaikan.
Untuk memeriksa sepenuhnya bagaimana sequencer bekerja, mari kita lihat jaringan Mp8B.
Tabel di bawah ini menunjukkan sinyal kontrol dan kata-kata bit mikrokode yang sesuai.
D15 D14 D13 D12 D11 D10 D09 D08 D07 D06 D05 D04 D03 D02 D01 D00
LDMC ENPC - - - - - - F2 F1 F0 S1 S0 P1 P0 -
Di bawah ini adalah ringkasan garis kontrol dan tugas yang mereka lakukan:
LDMC '1': pemuatan MPC; '0': Peningkatan MPC

ENPC '1': Peningkatan PC
F2, F1, F0 ALU fungsi pilih

S1, S0 Pilih fungsi register akumulator
P1, P0 Pilih saluran multiplexer input
Tabel di bawah ini menunjukkan contoh kode instruksi (perlu diingat bahwa
kode di kolom sebelah kiri hanya contoh). Kami melihat program mikro
terdiri dari satu atau lebih instruksi mikro.
Memori mikroprogram
Kode Instruksi Alamat Mikroprogram

st
1Ah 1Ah 1 mikroinstruksi
nd
1Bh 2 mikroinstruksi
st
1Ch 1Ch 1 mikroinstruksi
st
1Dh 1Dh 1 mikroinstruksi
dan
1Eh 2 mikroinstruksi
1Fh tanggal 3 mikroinstruksi
Contoh di atas adalah ilustrasi dari topik yang dibahas sejauh ini. Kita dapat
merujuk ke instruksi hanya dengan menunjukkan alamat di mana instruksi mikro program mikro
pertama dihafal.
Ini berarti bahwa kode mesin instruksi (alamat program mikro)

berfungsi sebagai pengidentifikasi operasi dasar yang harus benar-benar
dieksekusi. Operasi ini bahkan bisa sangat kompleks tetapi tetap dalam
logika sequencer itu sendiri dan tidak langsung terlihat oleh programmer.
Perancang instruksi mikro harus mengelola LDMC garis beban MPC,

yang dihasilkan oleh memori mikroprogram. Jalur LDMC harus
diaktifkan pada instruksi mikro terakhir dari setiap program mikro sehingga instruksi berikutnya
instruksi dimuat di MPC dan jaringan terus aktif.
Mari kita periksa diagram waktu pada gambar di bawah ini, di mana kita melihat LDMC
aktif antara CK clock edge 2 dan 3. Instruksi diambil dari
PM dimuat di MPC di tepi 3.
PC telah bertambah sebelumnya sehingga menargetkan instruksi saat ini.

Karena kode mesin instruksi tidak

lebih dari alamat yang diberikan
ke MPM, ini akan mengeluarkan
sinyal kontrol yang merespons
setelah tepi 3 dan sebelum tepi 4
(ingat bahwa memori ROM adalah
jaringan kombinasional dan
menghasilkan output setelah
penundaan sederhana) .
Seperti yang telah kita lihat,

instruksi mikro berisi kombinasi
sinyal kontrol yang perlu aktif pada
waktu tertentu sehingga logika
komputasi akan menghasilkan
hasil yang diinginkan.
Hasilnya akan diingat hanya pada
tepi aktif jam berikutnya (4 pada
gambar), jadi jika hanya terdiri dari
satu mikroinstruksi, kita dapat
mengasumsikan bahwa instruksi
telah dieksekusi pada tepi tersebut.
Misalnya, hasil penjumlahan yang

dihasilkan oleh ALU disimpan di
akumulator pada saat ini.
Mari kita ambil kasus sebuah

instruksi yang terdiri dari beberapa
instruksi mikro yang akan
membutuhkan beberapa siklus
clock untuk dieksekusi.
Kita perlu membuat alamat di MPC maju secara progresif sehingga memori
mikroprogram menghasilkan instruksi mikro berikutnya satu per satu di output. Untuk
memungkinkan MPC maju pada setiap siklus clock, kita hanya perlu memastikan
bahwa MPC tidak diperintahkan untuk memuat (LDMC = '0') dalam instruksi mikro saat
ini.
Secara singkat, siklus Ambil terjadi pada tepi jam 2, siklus Dekode pada tepi 3 dan
siklus Jalankan pada tepi 4.
Siklus, suksesi terus menerus dari peristiwa ini disebut siklus instruksi. Melihat
gambar di bawah ini.
1.3.5 Menjalankan urutan instruksi
Pertimbangkan instruksi (A) dan instruksi berikut (B). Untuk memastikan

dua instruksi dieksekusi satu demi satu, instruksi mikro pertama B harus dieksekusi dalam
siklus jam segera setelah instruksi terakhir A
instruksi mikro.
Mempertimbangkan urutan waktu operasi yang diperiksa di atas, pendahuluan

solusinya bisa dengan mengaktifkan ENPC (untuk memaksa instruksi selanjutnya diambil)
di instruksi kedua hingga terakhir dan aktifkan LDMC di instruksi terakhir.
Oleh karena itu, program mikro standar sejauh menyangkut dua baris ini
akan dalam format yang ditunjukkan di bawah ini. Baris lain, yang tidak signifikan untuk
masalah ini, ditampilkan dalam bentuk umum di sini.
Instruksi Umum
LDMC ENPC D13..D0
st
0 0 xxxxxxxxxxxxxxx 1 mikroinstruksi
dan
0 0 ... ...
0 1 xxxxxxxxxxxxxxx (N-1)th Microinstruction
1 0 xxxxxxxxxxxxxxx Instruksi Mikro ke- N
Solusi ini tidak optimal karena membutuhkan mikroprogram untuk memiliki

setidaknya dua instruksi mikro. Jika kita hanya membutuhkan satu instruksi mikro untuk dieksekusi
instruksi tertentu, kita masih harus menambahkan yang kedua sehingga perintah itu
LDMC dapat diaktifkan. Lihat di bawah. Ini akan membuang memori dan eksekusi
waktu.
LDMC ENPC D13..D0

st
dan
Perhatikan bahwa masalah ini akan hilang jika PC menargetkan instruksi berikutnya saat
jaringan mengeksekusi yang pertama. Untuk mencapai ini kita perlu berpikir
tentang mengaktifkan ENPC berbeda. Kami akan mengaktifkannya tidak hanya satu instruksi
mikro sebelumnya seperti yang dilakukan di atas, tetapi seluruh instruksi sebelumnya.
Karena setiap instruksi diikuti oleh instruksi berikutnya, kita dapat mengaktifkan ENPC di
instruksi mikro terakhir instruksi saat ini mengetahui bahwa PC tidak akan meningkat
dengan instruksi berikutnya, tetapi dengan instruksi berikutnya.
Singkatnya, untuk instruksi apa pun, kami mengaktifkan LDMC dan ENPC di terakhir
mikro seperti yang ditunjukkan pada tabel di bawah ini.
Instruksi Umum
LDMC ENPC D13..D0
0 0 st xxxxxxxxxxxxxxx 1 mikroinstruksi
0 0 dan xxxxxxxxxxxxxxx 2 mikroinstruksi
0 0 ... ...
0 0 xxxxxxxxxxxxxxx (N-1)th Microinstruction
1 1 xxxxxxxxxxxxxxx Instruksi Mikro ke- N
Di tepi jam berikutnya, mengaktifkan LDMC membuat instruksi tersedia dalam beban memori
program di MPC, sementara mengaktifkan ENPC menambah PC. Namun, nilai baru ini tidak akan
digunakan hingga pengambilan berikutnya
karena instruksi yang dimuat di MPC sekarang adalah instruksi yang diambil
dengan nilai PC sebelumnya.
1.3.6 Mengeksekusi instruksi pertama saat start up
Kami baru saja membahas bagaimana membuat eksekusi instruksi terus menerus, karena
menjumlahkan instruksi saat ini sudah dieksekusi. Bagian ini membahas
dengan cara mengeksekusi instruksi pertama dalam memori program ketika
sistem diatur ulang.
Ketika MPC diatur ulang, ia menargetkan lokasi memori mikroprogram nol, jadi
instruksi mikro di lokasi itu akan dieksekusi di tepi naik pertama
jam setelah reset.
Demikian pula, ketika PC direset, ia menargetkan lokasi memori mikroprogram nol,

jadi instruksi di lokasi itu siap dimuat di MPC dan kemudian
diterjemahkan dalam siklus instruksi berikutnya.
Instruksi mikro di lokasi memori mikroprogram nol seharusnya hanya atau der MPC untuk memuat
instruksi saat ini, pada saat yang sama mengaktifkan
PC untuk bertambah dan kemudian bersiap untuk mengeksekusi instruksi berikutnya (kontrol
bit D13..D0 semuanya diatur pada nol).
Perhatikan bahwa apapun yang diatur di lokasi memori mikroprogram nol sesuai dengan instruksi
NOP (No Operation). Tabel berikut menunjukkan
program mikro.
LDMC ENPC P0 P1 S0 S1
Hex Mnemonik ----- ---- -
TIDAK 00 jam 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Dari sudut pandang programmer, ini tidak melakukan apa pun kecuali meningkatkan
PC. Karena terletak di alamat MPM nol, kode mesin instruksi NOP adalah alamat itu
sendiri, 00h.
1.3.7 “Pipa instruksi”
Cara baru untuk mengelola sequencer ini memungkinkan kita untuk melakukan hal-hal berikut
secara bersamaan (dalam siklus clock yang sama):
1. ambil instruksi berikutnya 2.
dekode instruksi yang diambil pada siklus sebelumnya 3.
jalankan instruksi yang didekodekan dalam siklus sebelum yang sebelumnya
Dalam literatur, mekanisme ini disebut "pipa instruksi" dan sekarang digunakan di
banyak mikroprosesor. Secara teoritis memungkinkan untuk mengeksekusi instruksi
dalam satu siklus clock (jika instruksi terdiri dari satu instruksi mikro masing-masing).
Sebuah pengobatan menyeluruh dari subjek ini berada di luar cakupan buku ini.
Di sini, kami hanya akan menunjukkan bahwa sequencer kami memungkinkan untuk
pipa instruksi tiga tahap (Fetch-Decode-Execute). Gambar di bawah menunjukkan
pipeline yang mengeksekusi urutan instruksi8 yang masing-masing terdiri dari satu
instruksi mikro.
1.3.8 Mendefinisikan program mikro
Seperti yang telah kami sebutkan, perancang jaringan mengatur memori program mikro
dengan mikrokode untuk semua instruksi yang dapat dijalankan oleh jaringan kami.
Daftar lengkap instruksi untuk jaringan ini dan program mikro terkait dapat ditemukan
di Lampiran B.2.1).
Ingatlah bahwa ini dilakukan hanya sekali dalam fase desain prosesor.
Peran programmer adalah untuk mengatur memori program dengan urutan instruksi
yang mungkin diperlukan untuk dijalankan oleh algoritme.
Pemisahan tugas ini memungkinkan pemrogram sistem untuk mengabaikan cara kerja
internal prosesor dan berkonsentrasi pada logika program.
8
Urutan eksekusi instruksi biasanya disebut sebagai "aliran kontrol".
Untuk latihan, mari kita coba membangun program mikro dari beberapa instruksi (walaupun ini sudah dilakukan).
Demi kesederhanaan, mari kita pilih instruksi yang sudah kita ketahui karena mereka digunakan dalam contoh
pemrograman menghitung rata-rata empat operan (lihat Halaman 28, di Bagian 1.2.5). Kami menulis:
TAMBAHKAN A,OP0
TAMBAHKAN A,OP1
TAMBAHKAN A,OP2
TAMBAHKAN A,OP3
SRL A
SRL A
BERHENTI
Mari kita periksa instruksi yang digunakan dalam contoh satu per satu dan definisikan program
mikro. Kami akan menetapkan nilai untuk setiap bit kontrol berdasarkan operasi yang akan
dilakukan, seperti yang kami lakukan di Bagian 1.2.5 mulai dari Halaman 25.
Untuk instruksi ADD, kita perlu mengatur LDMC dan ENPC ke '1' untuk mengaktifkan
sequencing. Kemudian mari kita atur semua bit yang tidak digunakan ke '0'. Mari
kita juga mengatur F2F1F0 ke '000' untuk memaksa unit logika aritmatika
melakukan penjumlahan. Register accu mulator harus menyimpan hasilnya jadi
kita set S1S0 ke '11'. Operand harus diambil dari saluran 0 multiplexer jadi mari
kita atur P1P0 ke '00'. Inilah hasilnya:
LDMC ENPC P1 S0 S1 F0 F1 F2 P0
mnemonik hex -- - - -- -
ADD A,OP0 04h 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0
Perancang memuat instruksi mikro ini di lokasi memori mikroprogram 04 jam

jadi ini adalah kode instruksi yang akan digunakan programmer.
Mari kita buat mikrokode dari tiga variasi ADD lainnya dengan cara yang sangat
mirip. Kami hanya akan mengubah bit pemilihan multiplexer, seperti yang ditunjukkan
pada tabel di bawah ini. Instruksi mikro ini didefinisikan secara terus menerus dalam
memori program mikro sehingga kode mesin untuk ADD A, OP1 dan yang berikut
diurutkan sebagai 05h, 06h dan 07h.
ADD A,OP1 05h 1 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0
ADD A,OP2 06h 1 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0

ADD A,OP3 07h 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 0
Untuk instruksi SRL A, tentu saja kita set LDMC dan ENPC ke '1', lalu kita set semua bit
yang tidak terkait dengan operasi ke '0'. Namun, kita perlu memaksa register untuk
menggeser isinya ke kanan sehingga kita menetapkan S1S0 = '01'. Kita mendapatkan:
Hex Mnemonik -- - - - - -
SRL A 20j 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0
Kode mesin instruksi ini adalah 20h karena ini adalah alamat memori mikroprogram tempat perancang memuat
mikrokode ini.
Instruksi HALT, yang diperkenalkan pada bab sebelumnya, menghentikan proses. Untuk HALT, kami memuat di
MPC varian khusus dari instruksi NOP yang tidak menambah PC.
Mulai dari mikrokode NOP, kami memaksa garis ENPC ke nol, dan memberikan
MENGHENTIKAN mikrokode berikutnya, menempatkannya di alamat 01h, di mana satu-satunya baris yang
diaktifkan adalah LDMC dan semua kontrol lainnya berada di '0':
Hex Mnemonik - ----- -
HALT 01j 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Jika prosesor mengeksekusi kode mesin 01h dari HALT, kami menonaktifkan peningkatan PC pada siklus clock
berikutnya. Dalam siklus clock ini, PC telah ditambah 1 oleh mikroprogram instruksi sebelumnya. Sekarang
menargetkan kode mesin berikutnya. Karena kami tidak dapat menonaktifkan pemuatan MPC, kode mesin berikutnya
akan dimuat.
Kita dapat mengatasi masalah ini dengan memasukkan kode yang identik
setelah kode HALT pertama. Dengan cara ini, ketika kode HALT kedua
dieksekusi, itu secara definitif memblokir prosesor karena kode kedua itu terus
dimuat di MPC pada setiap siklus clock. PC tidak bertambah dan hanya reset
sistem yang dapat memulai eksekusi lagi.
Karena kita membutuhkan dua kode 01h berturut-turut untuk menghentikan prosesor kita,
kita akan mempersingkatnya dengan menunjukkan satu instruksi HALT tunggal yang sesuai
dengan sepasang kode 01h berturut-turut.
1.3.9 Menulis ulang program rata-rata empat operan
Pekerjaan yang baru saja kita lakukan untuk latihan sebenarnya adalah pekerjaan
perancang program mikro dan secara definitif selesai dalam fase desain jaringan. Di
sini kita hanya ingin memprogram jaringan untuk menghitung rata-rata dari empat nilai.
Yang perlu kita lakukan untuk mencapai ini adalah melihat tabel instruksi (lihat Lampiran
B.2.1), dan masukkan ke dalam memori program kode-kode yang menerjemahkan program
kita ke dalam bahasa mesin, seperti yang ditunjukkan di bawah ini.
Kode Mesin Kode Mnemonic

TAMBAHKAN A,OP0 04h
TAMBAHKAN A,OP1 05h
TAMBAHKAN A,OP2 06h
TAMBAHKAN A,OP3 07h
SRL A 20j
SRL A 20j
BERHENTI 01 jam 01 jam
Mari kita gunakan sesi simulasi waktu untuk melacak kemajuan eksekusi program ini
di dalam jaringan kita. Gambar di halaman sebelah menunjukkan bahwa PC
menargetkan lokasi memori program 00h pada siklus clock pertama. Lokasi ini berisi
kode 04h, kode mesin untuk ADD A,OP0 (siklus Ambil).
Pada siklus pertama (pada tepi 1), jalur pipa dimulai, seperti yang dijelaskan pada
bagian 1.3.6. Pada siklus berikutnya (pada tepi 2), kode instruksi dimuat di MPC dan
memulai siklus Decode. Dalam siklus ini instruksi mikro ADD A,OP0 mengaktifkan
semua sinyal yang diperlukan, termasuk yang memerintahkan akumulator untuk
menyimpan nilai baru.
Pada clock edge 3 hasil penambahan pada register dimuat (fase Execute). Panah
menunjukkan tiga siklus berturut-turut.
Demikian pula, dalam semua siklus berikut, kode mesin instruksi meninggalkan
memori program (PM) satu per satu sejak PC bertambah (ENPC='1') untuk setiap
siklus clock.
Perhatikan bahwa ENPC dan LDMC ditetapkan pada '1' di semua instruksi mikro yang terkait
dengan instruksi yang kami gunakan, kecuali untuk HALT di mana ENPC='0'.

Akhirnya, lokasi memori program 06h berisi yang pertama dari dua kode instruksi
HALT yang identik. PC dinaikkan sekali lagi pada tepi 8 jam dengan instruksi mikro
dari instruksi SRL A terakhir, yang sekarang dalam siklus dekode.
Setelah tepi 8, yang pertama dari dua kode instruksi HALT berada dalam siklus
dekode. ENPC diatur pada '0', sehingga PC tidak akan bertambah di tepi berikutnya.
LDMC di '1' memerintahkan kode mesin berikutnya (kode HALT kedua) untuk
dimuat di MPC. Sampai sekarang, tidak ada sinyal kontrol yang berubah dan
prosesor berhenti.
Sebagai kesimpulan, perhatikan bahwa instruksi perhitungan terakhir (SRL A
kedua) dieksekusi pada tepi 8, tepat ketika kode HALT kedua diambil. Dan saat
itulah Anda dapat melihat hasil akhir dari rata-rata 4 nilai di akumulator.
1.4 Lompatan, putaran, dan keputusan 47
1.4 Lompatan, putaran, dan keputusan
Di bagian ini, kami akan memperluas kemampuan sistem kami. Beberapa modifikasi pada
sequencer yang diprogram mikro memungkinkan untuk: a) menjalankan instruksi lucu yang
memungkinkan untuk mengubah urutan eksekusi program (atau "aliran kontrol"), b)
mengeksekusi urutan instruksi yang sama beberapa kali, dan c) membuat keputusan pada
tugas untuk dilaksanakan.
1.4.1 Instruksi loop dan lompat
Jaringan kami belum dapat mengulangi urutan instruksi yang sama beberapa kali. Juga,
seperti yang kami singgung di bab sebelumnya, ia belum memiliki alat untuk memilih urutan
mana yang tersedia untuk dieksekusi berdasarkan hasil komputasi menengah9 .
Kedua kemampuan ini merupakan dasar dari sistem komputasi modern. Tujuan dari bab ini
adalah untuk mengubah jaringan kami sehingga dapat:
- membawa urutan instruksi secara siklis. — memutuskan

urutan instruksi mana yang akan dieksekusi berdasarkan perantara
hasil komputasi.
Mendasari tindakan baru ini adalah kebutuhan untuk memvariasikan aliran kontrol program
dengan menginterupsi satu urutan dan memulai yang lain.
Perubahan pertama yang akan kita buat adalah menambahkan kemampuan jaringan kita untuk
mengulang urutan instruksi. Ingatlah bahwa sejauh ini kita hanya dapat mengeksekusi satu
urutan yang berakhir hanya dengan menghentikan prosesor.
Pertimbangkan untuk memperkenalkan instruksi yang dapat mengubah aliran eksekusi saat
ini dan membuatnya restart dari instruksi lain. Ini akan memungkinkan untuk menulis urutan
instruksi hanya sekali dan mengulangi eksekusinya secara siklis tanpa batas.
Kita telah melihat bahwa PC mengalamatkan instruksi berikutnya yang akan dieksekusi. Dengan
memvariasikan isi PC, kita dapat mengubah alur eksekusi program dan membuatnya restart
dari instruksi lain. Dalam jargon komputer, mengubah aliran eksekusi disebut sebagai melompat
ke urutan instruksi baru.
Gambar berikut menggunakan panah untuk mengidentifikasi perubahan sebagai A, B, C dan D.
Kami memperkenalkan koneksi (panah 'A' pada gambar) antara PM dan input pra-muat PC.
9
Dengan kata lain, jaringan yang diperiksa sejauh ini tidak dapat menjalankan operasi seperti
konstruksi if - then - else klasik, atau loop yang dihasilkan dari konstruksi for, atau while - do yang
umum dalam bahasa pemrograman.
Dengan perubahan baru ini, keluaran PM sekarang terhubung tidak hanya

dengan MPC tetapi juga dengan PC, membentuk semacam umpan balik. Kita
dapat mengubah konten PC dengan mengambil dari PM itu sendiri alamat yang
ingin kita lompati dan memuatnya di PC.
Perintah pra-muat PC (panah 'B') sekarang terhubung ke baris D13, output
MPM (panah 'C'). Garis kontrol ini diperkenalkan pada bab sebelumnya dengan
nama LDPC tetapi tidak digunakan (panah 'D').
Perancang instruksi mikro sekarang dapat memesan PC untuk dimuat. Seperti
yang terlihat di atas, nilai untuk memuat berasal dari PM. Kami ingin menulis
alamat untuk melompat ke lokasi segera setelah yang berisi instruksi lompat.
Untuk melakukan lompatan, kita perlu mengaktifkan LDPC, pada waktu yang tepat, untuk
perintah pemuatan alamat di PC.
Mari kita beri kode mnemonic baru JP (Jump) untuk mewakili instruksi baru.
Operandnya adalah alamat yang ingin kita lompati. Formatnya adalah sebagai berikut:
JP <alamat>
Program mikro yang terkait dengan ini dapat ditemukan pada tabel di bawah ini. Pertama
microinstruction memerintahkan alamat instruksi yang ingin kita lompat
to, yang sudah ada di output PM berkat pipeline, untuk dimuat di
PC (LDPC = '1'). Perintah kedua adalah instruksi yang telah kita lompati
beban di MPC (LDMC = '1') dan PC untuk kenaikan sehingga berikutnya
instruksi dapat diambil (ENPC = '1'), sehingga pipa dapat dimulai kembali.
Semua sinyal kontrol lainnya tetap tidak aktif.
LDMC ENPC LDPC D12..D0

0 0 1 st 0000000000000 1 mikroinstruksi
1 1 0 dan 0000000000000 2 mikroinstruksi
Instruksi membutuhkan dua siklus clock untuk dieksekusi: satu untuk mengambil instruksi yang
ingin kita lompat dari memori dan yang lain untuk mengeksekusi itu
instruksi, yaitu untuk menyelesaikan lompatan.
Di bawah ini kita melihat sebuah contoh: program kita membuat "infinite loop" di mana:
urutan yang terdiri dari instruksi kedua dan ketiga diulang secara siklis
tanpa batas waktu:
Kode Mnemonik Alamat Kode Mesin

DI DALAM
A,OP0 00h 1Ch
LOOP: TAMBAHKAN A,OP1 01 jam 05 jam
JP LOOP 02j 22 jam 01 jam
Instruksi pertama memuat nilai input OP0 dalam register akumulator.

Instruksi kedua adalah menambahkan operan OP1 ke dalamnya. Label diikuti oleh
titik dua telah ditempatkan di depan kode mnemonic untuk instruksi.
Ini membantu mengidentifikasi instruksi, atau urutan yang dimulai dengan instruksi itu. Label ini
memungkinkan kita untuk menulis instruksi lompat dengan lebih jelas dan
dengan cara yang lebih serbaguna pada baris di bawah ini. Secara lengkap, instruksi JP LOOP
berbunyi seperti perintah: "lompat ke instruksi dengan label LOOP". Itu
assembler akan mengganti argumen JP dengan alamat instruksi
diberi label sebagai LOOP, yaitu 01h.
Seperti yang ditunjukkan tabel, mnemonik sesuai dengan kode mesin 1Ch, 05h,
22 jam dan 01 jam. 01h adalah alamat untuk melompat dan sesuai dengan label
LINGKARAN. Ditempatkan di alamat 03h, tepat setelah kode JP (22h).
Diagram waktu berikut menunjukkan urutan operasi (di mana kita

telah menetapkan OP0 = 06h dan OP1 = 09h).

Panah merah menyoroti transfer alamat yang ingin kita lompati dari memori program ke
PC. Karena transfer itu, pipa berhenti untuk satu siklus. Ini terjadi pada tepi positif jam
5 dan 8, di mana LDPC tinggi. Gambar juga menunjukkan siklus Fetch, Decode, dan
Execute untuk semua instruksi.
Keluaran memori program menunjukkan kode instruksi lompat 22h antara edge 3 dan
4. Pada edge 4, kode tersebut dimuat di MPC sehingga memasuki siklus Decode. Di
antara tepi 4 dan 5, instruksi mikro lompat pertama memerintahkan PC untuk memuat
isi keluaran memori program (yaitu alamat yang akan dilompati, 01h dalam kasus ini).
Ini juga memerintahkan MPC untuk meningkat untuk menjalankan instruksi mikro kedua
dalam siklus jam berikutnya.
Pada tepi 5, PC memuat alamat baru 01h, dan antara front 5 dan 6 kita dapat membaca
kode instruksi yang ditemukan di alamat baru, ADD A,OP1, dari memori program.
Sementara itu pada siklus clock yang sama, instruksi mikro kedua memerintahkan
instruksi baru untuk dimuat di MPC dan semuanya berjalan seperti biasa. Lompatan
telah dilakukan.
1.4.2 Keputusan dan instruksi lompatan bersyarat
Kita telah melihat bahwa instruksi lompat memungkinkan kita untuk mengubah urutan
eksekusi instruksi yang diatur dalam memori serta untuk mendefinisikan loop tak terbatas.
Sekarang kami ingin memperkenalkan instruksi lompatan serupa yang memungkinkan
jaringan membuat keputusan berdasarkan hasil perhitungan sebelumnya.
Ini akan memungkinkan misalnya untuk mendefinisikan loop berbasis counter (yaitu
urutan instruksi untuk mengeksekusi beberapa kali) atau loop yang diulang sampai
kondisi tertentu tercapai.
Dalam contoh loop tak terbatas sebelumnya, kami terus menambah akumulator tanpa
memperhatikan isinya. Sekarang kita akan memuat angka (diambil dari input) di
akumulator dan menguranginya pada setiap pengulangan loop. Namun kali ini, kami
ingin berhenti ketika konten register mencapai nol, memuat ulang nomor awal dan ulangi
prosesnya. Grafik di bawah ini menunjukkan jumlah dalam akumulator dan kemajuannya
dari waktu ke waktu.
Program dalam kode mnemonic terlihat seperti ini:

MULAI: IN A,OP0
LOOP: SUB A,OP1
JP NZ, LOOP
JP MULAILAH
Kami menambahkan label di awal sehingga instruksi terakhir (JP START) membuat
semuanya berulang dari atas, menciptakan siklus tak terbatas. ADD digantikan oleh
SUB, yang mengurangi operan input OP1 (diatur ke 1) dari akumulator, dan menyimpan
kembali hasilnya di akumulator itu sendiri.
Yang baru adalah instruksi JP NZ,LOOP, yang kita sebut "lompatan bersyarat", di mana
operasi lompatan tergantung pada suatu kondisi, yang ditulis tepat sebelum label LOOP.
Dalam hal ini, kondisinya menyangkut fakta bahwa perhitungan terakhir menghasilkan
hasil bukan nol (NZ = “Tidak Nol”) pada keluaran ALU.
Dalam bahasa alami, kita dapat mengungkapkan arti dari instruksi ini sebagai berikut:
"Langsung ke instruksi berlabel LOOP jika hasil perhitungan terakhir tidak nol".
Dalam contoh kami, kami telah mendefinisikan dua loop "bersarang" (satu di dalam yang lain).
Yang terluar diberi label MULAI dan mengulang semuanya dari atas.
Yang dalam menjalankan kembali perhitungan hanya jika hasil operasi bukan nol. Pada
titik tertentu, hasilnya mencapai nol. Mengikuti kondisi ini, kita tidak ingin lompatan
dieksekusi, melainkan instruksi berikutnya dalam program.
1.4.3 Register BENDERA
Ada masalah dengan implementasi jaringan kami. Seperti yang kita lihat di bab
sebelumnya, ALU menghasilkan output sinyal ZF dan CO. ZF jika hasil operasi yang
dijalankan adalah nol (ini mengaktifkan ZF). CO, bagaimanapun, aktif setiap kali sirkuit
menghasilkan carry (atau pinjaman).
Masalahnya adalah bahwa sinyal-sinyal ini tidak lagi merujuk ke operasi aritmatika logis
terakhir yang dijalankan ketika instruksi lompatan bersyarat sedang diterjemahkan.
Oleh karena itu, mereka harus diingat saat mereka diproduksi, yaitu dalam siklus clock
ketika ALU menjalankan operasi.
Untuk mengingat nilainya, kita dapat memperkenalkan dua flip-flop. Dengan cara ini kita
dapat menggunakan nilai flag untuk mempengaruhi eksekusi instruksi berikut.
Seperti yang kita lihat pada gambar di bawah, output sinyal ALU terhubung ke dua flip-
flop E-PET. Input yang diaktifkan (E) dari flip-flop terhubung ke satu sama lain dan
terhubung ke jalur EFLG baru, yang berasal dari bit D10 dari memori program mikro.
Mikrokode akan memungkinkan penghafalan (atau kekurangannya) dari bendera. Ini juga
akan memungkinkan untuk menghafal selama siklus clock yang benar dan hanya untuk
operasi yang memerlukannya (operasi aritmatika dan logika).
Dalam sistem yang paling kompleks bisa ada lebih banyak variasi flag. Himpunan flip-flop
yang menghafal sinyal ALU biasanya dibundel dalam register yang disebut "Flag Register".
Singkatnya, penambahan register flag memungkinkan kita untuk menyimpan nilainya bahkan
setelah operasi yang menghasilkannya selesai.
1.4.4 Mengontrol kondisi lompatan
Mari kita tinjau skema jaringan kita. Pengaktifan beban PC terhubung (dengan nama LDPC)
ke jalur mikrokode D13. Ingat bahwa aktivasi LDPC menyebabkan pemuatan alamat
lompatan, yang berasal dari memori program, ke dalam PC.
Sekarang kita perlu menghasilkan garis LDPC dalam fungsi dari jenis lompatan yang diminta.
Itu harus dipaksakan oleh mikrokode dalam fungsi nilai-nilai bendera. Kami tidak hanya akan
menggunakan mikrokode baris D13 tetapi juga baris D12 dan D11. Untuk tujuan kami,
mereka telah berganti nama menjadi J2, J1 dan J0, masing-masing.
Tabel di bawah ini menunjukkan semua kemungkinan jenis lompatan. Untuk saat ini,
beberapa kombinasi tidak digunakan karena dicadangkan untuk kemungkinan perluasan di
masa mendatang.
J2 J1 J0 Operasi yang Dipilih

0 0 0 Tidak Melompat
0 0 1 Lompatan Tanpa Syarat
0 1 0 Tidak Digunakan
0 1 1 Tidak Digunakan
1 0 0 Lompat jika ZF = '1'
1 0 1 Lompat jika ZF = '0'
1 1 0 Lompat jika CO = '1'
1 1 1 Lompat jika CO = '0'
Seperti yang Anda lihat pada tabel, sesuai dengan kombinasi J2, J1 dan J0,
kita dapat memilih apakah akan melompat, tidak melompat atau mengkondisikan lompatan pada nilai
dari sebuah bendera.
Jadi, mari kita tambahkan jaringan berbasis multiplexer yang dapat menjalankan fungsi
ditentukan oleh tabel ini. Skema lengkap jaringan dapat ditemukan di
Lampiran B.3.2 dengan nama Mp8C.
Jika kombinasi yang diminta oleh J2J1J0 adalah '000', multiplexer memaksa LDPC
ke '0' (ini adalah kasus untuk semua instruksi non-lompatan lainnya). Untuk mendapatkan
lompatan tanpa syarat, garis J2J1J0 harus disetel ke '001'. Ini sama
sebagai mengaktifkan LDPC dalam hal apa pun, terlepas dari nilai flag.
Dalam empat kasus lainnya, LDPC terhubung langsung ke bendera yang diminta
(langsung atau dinegasikan) sehingga akan ada lompatan hanya jika flag memintanya. Untuk
contoh jika kita membuat J2J1J0 = '101', LDPC akan sama dengan ZF yang dinegasikan,
seperti dalam kasus instruksi “JP NZ, LOOP” di awal bagian ini. Kita
mendapatkan lompatan jika ZF tidak aktif, yaitu jika hasil operasi sebelumnya adalah
bukan nol.
Sekarang mari kita lihat flag carry, CO. Jika kita membuat J2J1J0 = '110', beban
perintah untuk PC hanya akan aktif jika benderanya aktif. Kode mnemonik
adalah "JP C,LOOP". Lompatan akan dilakukan jika perhitungan sebelumnya telah
menghasilkan carry.
Kode mnemonik untuk instruksi lompatan apa pun yang dimungkinkan di sistem kami
ditunjukkan pada tabel berikut. Kita dapat menyatakan alamat baik dalam bentuk numerik
maupun dalam bentuk simbol, dengan menggunakan label seperti pada contoh di bawah
ini. (Ini adalah tugas assembler untuk mengganti label dengan alamat asli).
Kode Mnemonik Operasi

JP <alamat> Lompat Tanpa Syarat
JP Z,<alamat> Langsung jika Nol
JP NZ,<alamat> Lompat jika Tidak Nol
JP C,<alamat> Langsung jika Membawa
JP NC,<alamat> Lompat jika Tidak Dibawa
Program mikro untuk instruksi lompat tak bersyarat adalah sebagai berikut:
LDMC ENPC J0 J1 J2 EFLG F1 F2 P0 P1 S0 S1 F0

Hex Mnemonik -- -
JP <alamat> 22j 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Pada mikroinstruksi pertama, baris J2J1J0 = '001' memerintahkan PC untuk

memuat instruksi untuk melompat. Yang kedua, LDMC memerintahkan MPC
untuk memuat instruksi yang kita lompati, sementara ENPC memaksa PC untuk
bertambah untuk mengambil instruksi berikutnya. Sinyal kontrol lainnya tidak
diperlukan sehingga dibiarkan tidak aktif.
Tabel di bawah ini menunjukkan instruksi lompatan bersyarat dan
mikroprogramnya.
LDMC ENPC J0 J1 J2 EFLG F1 F2 P0 P1 S0 S1 F0

mnemonik hex -- -
JP Z,<alamat> 24 jam 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
JP NZ,<alamat> 26j 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
JP C,<alamat> 28j 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
JP NC,<alamat> 2Ah 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Pada instruksi mikro pertama, bit J2, J1 dan J0 menunjukkan flag yang akan digunakan untuk
kondisikan lompatan. Sementara itu, ENPC = '1' memungkinkan penambahan PC dengan
satu, yang akan terjadi jika kondisi lompatan tidak tercapai.
Instruksi mikro kedua memerintahkan MPC untuk dimuat dan PC harus
bertambah sehingga selalu tetap satu instruksi di depan (agar pipa berfungsi).
Semua kontrol jalur data lainnya tetap tidak aktif di kedua instruksi mikro.
Jika bendera mengizinkan lompatan, instruksi yang kita lompati adalah

dimuat dalam register MPC. Jika tidak, jika bendera tidak mengizinkan lompatan,
instruksi yang mengikuti lompatan bersyarat akan dimuat.
Untuk benar-benar memahami logika mekanisme lompatan bersyarat, kita

harus fokus pada keadaan sequencer. Dalam siklus jam yang sama di mana yang pertama
instruksi mikro dijalankan, output memori program memasok alamat
tempat kita ingin melompat. Karena kita tidak dapat mengetahui pada saat itu apakah
jump akan dieksekusi atau tidak, kita harus mempertimbangkan kedua kemungkinan tersebut. Mari lihat
pada program uji berikut:

DI DALAM
A,OP0 00j 1Ch
LOOP: SUB A,OP1 01 jam 09 jam
JP NZ, LOOP 02j 04h 26 jam 01 jam
SELANJUTNYA: TIDAK 00h

TIDAK 05 jam 00h
... 06 jam ...
Misalkan kita membaca angka 2 dari input OP0 sedangkan OP1 diset pada 1. Ketika
SUB pertama dieksekusi, nilai akumulator berubah dari 2 menjadi 1. The
hasilnya adalah “bukan nol”, jadi lompatan dieksekusi dan masuk ke LOOP.
Mari kita gunakan diagram waktu dari sinyal yang digunakan di sini untuk menganalisis apa yang terjadi
dalam sequencer. Lihat gambar di halaman berikutnya.
Kita melihat bahwa kode mesin 26h dari JP NZ,LOOP diambil dari memori program selama siklus
clock antara edge 3 dan 4. Pada siklus berikutnya,
(antara tepi 4 dan 5) instruksi didekodekan.
Logika memperhitungkan bahwa ZF adalah '0', dan akibatnya perintah beban untuk LDPC
diaktifkan (untuk melompat) dan ENPC juga diaktifkan (untuk mengambil
instruksi berikutnya).
PC mengabaikan pengaktifan ENPC karena perintah memuat untuk LDPC memiliki

prioritas di atas aktifkan karena cara penghitung berfungsi. Lompatan
alamat (di tepi 5) tersedia pada output memori program dan dimuat
di komputer.

Dalam siklus antara tepi 5 dan 6 kode mesin instruksi tempat kita melompat
dibaca dalam memori program. Oleh karena itu, ini adalah instruksi berikutnya
yang akan didekodekan.
Ketika SUB dijalankan untuk kedua kalinya, akumulator direset ke nol (di tepi 7).
ZF='0' berarti lompatan tidak dijalankan dan LDPC tidak diaktifkan.
Meski begitu, ENPC aktif, sehingga PC bertambah di tepi 8. Kemudian instruksi
segera setelah lompatan diambil (di sini, ini NOP) dan urutan yang ditetapkan
oleh pipa (ambil, dekode, dan eksekusi) dimulai kembali.
1.4.5 Contoh: Cara menggunakan lompatan bersyarat
Pada contoh sebelumnya, pertama-tama kita memuat angka di akumulator dan

menurunkannya hingga mencapai nol dan memulai proses lagi. Sekarang kita
ingin mengubah urutan numerik yang dihasilkan mengikuti tren segitiga pada
gambar.
Program dalam kode mnemonic terlihat seperti ini:

A,OP0
DI DALAM
TURUN: SUB A,OP1

JP NZ, LDOWN
LUP: TAMBAHKAN A,OP1
CP A,OP0
JP NZ, LUP
JP LDOWN
Tiga instruksi pertama sama seperti pada contoh sebelumnya, kecuali bahwa
labelnya sekarang disebut LDOWN (singkatan dari Loop Down). Instruksi pertama
mengambil nomor yang akan kita mulai dari input OP0 dan memasukkannya ke
dalam register akumulator.
Dua instruksi berikutnya menghasilkan pengurangan progresif dari isi register
hingga mencapai nol (kami menyetel input OP1 ke 1). Ketika register menjadi nol,
instruksi JP NZ,LDOWN berhenti melompat dan kami pindah ke instruksi
berikutnya.
Pada label LUP (Loop Up), kami menemukan instruksi ADD, yang menambahkan
pembacaan konstan dari input OP1 ke akumulator, yang disetel ke 1. Kami ingin
mengulangi kenaikan ini hingga lompatan bersyarat JP NZ,LUP membawa kami ke
nilai awal lagi. Kemudian kita akan restart dengan menggunakan JP LDOWN untuk
melompat ke instruksi kedua, untuk mengurangi akumulator lagi.
Meskipun demikian, mekanisme flag tidak dapat membantu kita secara langsung karena
kedua flag yang tersedia tidak aktif ketika kita mencapai nilai OP0 (nilainya bukan nol
dan kenaikannya tidak menghasilkan carry). Apakah kita harus menambahkan
komparator magnitudo ke ALU? Seperti yang dapat kita lihat dalam kode mnemonic, kita
telah memasukkan instruksi CP (“Bandingkan”) yang dimaksudkan untuk membandingkan
akumulator dengan input OP0.
Untuk mencapai hasil yang sama sebelumnya, kami mengurangi (SUB) satu operan dari
yang lain dan mendiskusikan bagaimana mengamati flag untuk mengevaluasi apakah kedua
operan itu sama atau jika satu lebih besar dari yang lain (lihat Bagian 1.2.4.1, di Halaman 25 ).
Sekarang, kita menyimpan flag untuk digunakan nanti, jadi operasi pengurangan tampaknya
merupakan pilihan yang sempurna untuk melakukan evaluasi melalui lompatan bersyarat.
Jika kedua operan tersebut berbeda, hasil pengurangannya akan menjadi bukan
nol sehingga instruksi JP NZ,LUP akan terus melompat mundur ke instruksi ADD
yang diberi label sebagai LUP. Namun demikian, kasus kami mengharuskan
akumulator untuk menyimpan kontennya setelah perbandingan, karena setiap kali
siklus berulang, kami menambahnya satu per satu. Sayangnya, SUB mengubah
isi akumulator pada saat menyimpan hasil pengurangan.
Kita dapat memecahkan masalah ini dengan memperkenalkan CP instruksi perbandingan,
yang bekerja seperti instruksi SUB tetapi hanya memperbarui flag berdasarkan hasilnya.
Instruksi CP tidak menyimpan hasil pengurangan di akumulator sehingga isinya tetap utuh.
Mari kita bandingkan program mikro SUB, ADD dan CP.
LDMC ENPC J0 J1 J2 EFLG P1 S0 S1 F0 F1 F2 P0
mnemonik hex -- -
ADD A,OP0 04h 1 1 0 0 0 1 0 0 0 0 0 1 1 0 0 0
mnemonik hex -- -
SUB A,OP0 08h 1 1 0 0 0 1 0 0 0 0 1 1 1 0 0 0
Hex Mnemonik -- -
CP A,OP0 30h 1 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0
Seperti yang kita lihat, semua program mikro ADD, SUB dan CP mengaktifkan saluran
EFLG (serta semua instruksi aritmatika dan logika lainnya yang ditentukan untuk
jaringan ini), yang memerintahkan menghafal bendera. TAMBAHKAN dan SUB
perintahkan register untuk menyimpan hasil dari ALU (setting S1S0 = '11'),
sementara CP menghitung hasilnya tetapi tidak menyimpannya (S1S0 = '00').
Lampiran B.3.1 memiliki daftar lengkap instruksi dan program mikro

terkait dengan jaringan yang telah kami kembangkan selama ini (Mp8C), serta skema lengkapnya.
Dengan melihat daftar ini, kami dapat menerjemahkan program yang diusulkan ke dalam mesin
kode dan dapatkan yang berikut:

DI DALAM
A,OP0 00j 1Ch
TURUN: SUB A,OP1 01 jam 09 jam
JP NZ, LDOWN 02j 04h 26 jam 01 jam
LUP: TAMBAHKAN A,OP1 05 jam
CP A,OP0 05 jam 30 jam
JP NZ, LUP 06 jam 26 jam 04 jam
JP LDOWN 08h 22 jam 01 jam

1.5 Port input dan output 61
1.5 Port input dan output
Bagian ini memperkenalkan konsep dasar seputar menghubungkan proses ke perangkat

eksternal melalui penggunaan port input dan output. 10
1.5.1 Port masukan
Port input berarti koneksi antara sistem pemrosesan dan luar, yang memungkinkannya
menerima data untuk diproses. Kami telah menemukan port input sejak awal buku ini
dan kami telah menggunakannya dalam contoh untuk mendapatkan nilai operan yang
akan digunakan dalam perhitungan kami. Kami juga telah menggunakannya untuk
memperoleh konstanta, karena kurangnya metode lain yang tersedia.
Mari kita tinjau struktur yang kita gunakan sebelumnya pada gambar berikut. Multiplexer
memungkinkan kita untuk memilih port mana yang ingin kita baca, dalam batas yang
ditentukan oleh bit P1 dan P0. Port jenis ini disebut "paralel" karena memungkinkan kita
membaca seluruh kelompok bit (8 dalam kasus kita) dalam satu operasi tunggal.
Kita telah melihat bahwa informasi yang dipilih dapat disalin di akumulator dengan
mengikuti jalur yang diizinkan dalam jaringan. Untuk melakukan ini kita dapat
menggunakan instruksi IN A, <port>, yang diterjemahkan ke istilah mikrokode dalam
pengaturan baris P1 dan P0.
10
Pelabuhan dalam arti istilah maritim. Pelabuhan tempat kapal berlabuh untuk memuat dan
menurunkan kargo adalah metafora untuk data yang masuk dan hasil yang keluar.
1.5.2 Port keluaran
Dalam contoh dari bagian sebelumnya, kami selalu mengambil hasil dengan membaca
akumulator demi kesederhanaan. Namun, dalam prosesor nyata, akumulator tidak terlihat
dari luar. Bagian internal perhitungan selalu sangat terpisah dari bagian yang
menghasilkan hasil.
Oleh karena itu, perlu diperkenalkan sesuatu yang memungkinkan untuk berkomunikasi
dengan pihak luar. Inilah gunanya port output; mereka membuat hasil tersedia ke luar
melalui penggunaan register paralel. Salah satu manfaatnya adalah mereka memungkinkan
untuk menjaga agar hasil tetap terbaca secara permanen sementara seluruh jaringan
terus memproses data lainnya.
Dua port output paralel yang kami tambahkan ke sistem kami terdiri dari register yang
disinkronkan oleh jam dan dikendalikan oleh memori program mikro seperti semua
elemen jalur data lainnya. Lihat gambar di bawah ini.
Kami melihat baris EO0 dan EO1 (dalam urutan, bit mikrokode D08 dan D09), yang
memungkinkan port PORT0 dan PORT1, masing-masing, untuk memuat data dalam register.
Input register terhubung ke ALU.
Jadi, ALU memungkinkan mikrokode untuk meminta memuat di salah satu dari dua
register ini terlepas dari jumlah yang dihasilkan atau ditransfer. Di prosesor kami, kami
akan membatasi diri untuk hanya menyalin konten akumulator ke port ini. Skema jaringan
lengkap, termasuk port output tersedia di Lampiran B.4.2 dengan nama Mp8D.
Untuk mengelola port output, kami menambahkan instruksi baru:
KELUAR <port>,A
Dimana <port> mengidentifikasi port output yang dipilih oleh programmer. Instruksi ini
memuat konten akumulator ke port yang dipilih dengan melewatkannya melalui ALU.
Program mikro dua instruksi ini terdiri dari hanya satu instruksi mikro masing-masing,
di mana garis kontrol baru EO0 dan EO1 muncul. ALU diatur
hingga menyalin input A (F2F1F0='110') ke output.
ENPC LDMC J0 J1 J2 EFLG EO1 EO0 P1 S0 S1 F0 F1 F2 P0
mnemonik hex -
OUT PORT0,A 34h 1 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0
mnemonik hex -
OUT PORT1,A 35h 1 1 0 0 0 0 1 0 1 1 0 0 0 0 0 0
Nilai yang disalin ke port output yang dipilih akan tetap ada sampai yang baru
Instruksi OUT dilakukan di atasnya.
Dalam Lampiran B.4.1 Anda akan menemukan daftar instruksi dan program mikro
terkait dengan jaringan yang telah kami kembangkan selama ini.
1.5.3 Cara menggunakan port
Di bawah ini adalah contoh dasar:

LOOP: IN A,OP0
OUT PORT0,A
JP LINGKARAN
di mana nomor di port input OP0 pertama kali disalin di akumulator dan
kemudian pada gilirannya disalin di port output PORT0 tanpa diproses. Itu
instruksi lompat tanpa syarat JP LOOP berarti sepasang instruksi ini
diulang tanpa batas. Setelah diterjemahkan ke dalam bahasa mesin, kami memiliki:
LOOP: IN A,OP0 00h 1Ch
OUT PORT0,A 01 jam 34 jam
JP LOOP 02 jam 22 jam 00h
1.5.3.1 Membangkitkan bentuk gelombang segitiga periodik
Mari kembali ke contoh yang telah kita pelajari di bagian sebelumnya, di mana urutan
kenaikan/penurunan bilangan biner dihasilkan di akumulator dan diulang tanpa batas.
Seperti yang Anda lihat pada gambar berikut,
plot urutan nilai ini dari waktu ke waktu mengingat bentuk gelombang segitiga.
Dalam versi baru program ini kami ingin menggunakan port PORT1 untuk
menghasilkan nilai. Ingat apa yang kita bahas sebelumnya, bahwa akumulator
dalam sistem nyata tidak pernah dapat diakses secara langsung dari luar.
Oleh karena itu, jika kita ingin menghasilkan urutan nomor, kita harus menyalinnya,
nilai demi nilai ke port output. Daftar di bawah ini menunjukkan kode mnemonic
program yang ditulis ulang dengan instruksi OUT yang ditambahkan di mana
konten akumulator diubah.
A,OP0
DI DALAM
OUT PORT1,A
TURUN: SUB A,OP1
OUT PORT1,A
JP NZ, LDOWN
LUP: TAMBAHKAN A,OP1
OUT PORT1,A
CP A, OP0
JP NZ, LUP
JP LDOWN
Dua instruksi pertama menginisialisasi isi akumulator dengan nilai awal (baca dari
port OP0) dan kemudian salin ke port PORT1. Ini diikuti oleh loop yang mengurangi
akumulator pada setiap pengulangan. Ini dicapai dengan mengurangi angka yang
dibaca di port OP1 (ditetapkan pada 1).
Pada setiap penurunan nilai baru dihitung dan disalin ke port output.
Loop berakhir hanya ketika akumulator mencapai nol. Pada titik ini, instruksi JP
NZ, LDOWN berhenti melompat ke baris LDOWN, sehingga eksekusi dilanjutkan
dengan instruksi berikutnya.
Pada baris program ini kami menemukan loop dengan struktur yang mirip dengan
yang sebelumnya. Setiap kali ini berulang, kami menambah akumulator dan
memperbarui port output dengan nilai baru.
Namun, dalam kasus ini, kondisi akhir loop bukanlah akumulator yang mencapai
nol tetapi membandingkan (dengan instruksi CP) nilai akumulator dengan angka
akhir hitungan (yang harus sama dengan angka awal dan dibaca lagi). di port
OP0). Ketika mereka sama, loop selesai dan kita beralih ke instruksi di posisi
setelah JP NZ, LUP, bahwa
adalah lompatan tanpa syarat JP LDOWN. Program kembali dan berulang

urutan dua loop tak terhingga.
Setelah terjemahan kode mnemonic kita mendapatkan kode mesin berikut.

Sekarang, kita dapat menggunakan simulator untuk menguji fungsionalitas program.

DI DALAM
A,OP0 00j 1Ch
TURUN: SUB A,OP1 02 jam 09 jam
JP NZ, LDOWN 04j 06h 26 jam 02 jam
LUP: TAMBAHKAN A,OP1 05 jam
CP A,OP0 08h 30 jam
JP NZ, LUP 09 jam 26 jam 06 jam
JP LDOWN 0Bh 22j 02 jam
1.5.3.2 Membangkitkan bentuk gelombang trapesium periodik
Contoh ini menunjukkan kepada kita penggunaan loop lainnya: menghasilkan penundaan. Seperti di
kasus sebelumnya, kami ingin menghasilkan urutan nilai periodik, tetapi di sini:
susunannya akan terlihat trapesium. Lihat di bawah.
Seperti yang Anda lihat, ada jeda antara bagian naik dan turun
bagian, di mana kami menyimpan nilai terakhir yang dihasilkan selama durasi proporsional
dengan nilai yang dibaca pada port input OP3.
Juga, perhatikan bahwa urutan yang dihasilkan tetap di antara dua nilai,
yang dibaca pada port input OP1 dan OP2. Daftar berikut menunjukkan contoh
program yang menghasilkan urutan ini.
Kami melihat empat loop satu demi satu, ditutup dalam satu loop eksternal yang
mengulangi seluruh urutan tanpa batas. Berbeda dengan contoh sebelumnya, di sini keduanya
loop yang menambah nilai (LOOPUP) dan menguranginya (LOOPDN) gunakan
instruksi CP untuk mengevaluasi kondisi akhir loop.
MULAILAH: A,OP1
DI DALAM
OUT PORT1,A
LOOPUP: TAMBAHKAN, OP0
OUT PORT1,A
CP A,OP2
JP NZ, LOOPUP
A,OP3
DI DALAM
PAUSEHI: SUB A,OP0

JP NZ, PAUSEHI
A,OP2
DI DALAM
LOOPDN: SUB A,OP0

OUT PORT1,A
CP A,OP1
JP NZ, LOOPDN
A,OP3
DI DALAM
PAUSELO: SUB A,OP0

JP NZ, PAUSELO
JP MULAILAH
Jeda, diperoleh dengan loop penundaan, dimasukkan di antara dua loop. Kita
akan mengeksplorasi konsep loop delay secara rinci lebih lanjut. Untuk saat ini, mari kita lihat ke dalam
contoh kita pada loop yang mengulang dari label PAUSEHI.
Instruksi IN A,OP3 memuat nilai OP3 di akumulator sebelum memasuki loop pertama. Setiap
kali loop berulang, isi akumulator
berkurang satu sampai mencapai nol. Sangat mudah untuk memverifikasi bahwa dua instruksi
pengulangan itu dieksekusi dalam 3 siklus clock. Loop diulang OP3 kali jadi
waktu eksekusinya sebanding dengan angka ini (3 x OP3).
Perhatikan bahwa setelah loop penundaan ini dijalankan, konten akumulator sebelumnya
hilang. Ini berarti ketika kita bergerak maju, kita harus memuat ulang nilai-nilai dari
port input untuk melanjutkan pembuatan output. Setelah assembler menerjemahkan
program, kami mendapatkan kode mesin berikut:

MULAILAH: A,OP1
DI DALAM 00h 1Dh
LOOPUP: TAMBAHKAN, OP0 02 jam 04 jam
OUT PORT1,A 03h 35 jam
CP A,OP2 04h 32 jam
JP NZ, LOOPUP 05j 26 jam 02 jam
A,OP3 07h
DI DALAM 1Fh
PAUSEHI: SUB A,OP0 08h 08h
JP NZ, PAUSEHI 09h 26 jam 08h
(lanjutan)
DI DALAM
A,OP2 0Bh 1Eh
LOOPDN: SUB A,OP0 0Ch 08h
OUT PORT1,A 0Dh 35j
CP A,OP1 0Eh 31h
JP NZ, LOOPDN 0Fh 26j 0Ch
DI DALAM
A,OP3 11 jam 1Fh
PAUSELO: SUB A,OP0 12 jam 08h
JP NZ, PAUSELO 13 jam 26 jam 12 jam
JP MULAILAH 15j 22 jam 00h
1.5.3.3 Menghasilkan sinyal dengan teknik PWM
“Pulse Width Modulation” (PWM) adalah teknik yang sangat umum digunakan untuk
menghasilkan tegangan menengah yang dapat ditentukan pada saluran. Suksesi periode tetap, variabel
pulsa panjang dihasilkan pada saluran. Tegangan rata-rata yang dihasilkan tergantung
pada rasio antara durasi level tinggi dan periode.
Dalam contoh ini, kami menggunakan sistem kami untuk menghasilkan dua sinyal PWM, yang
nilai rata-rata sebanding dengan jumlah yang ditetapkan dalam input.
Sinyal PWM diambil dari bit di posisi 0 port PORT0, dan
nilai rata-rata sebanding dengan nilai yang terbaca pada port input OP1. Yang lain
Sinyal PWM dibangkitkan pada bit 0 dari PORT1 dan bergantung pada input OP2.
Gambar di bawah menunjukkan prinsip operasi. Program secara siklis meningkatkan jumlah
dalam akumulator dari nol hingga maksimum yang dapat diwakili
nilai (255) menghasilkan semacam tangga.
Pada awal tangga, bit 0 di kedua port diatur ke '1'. Pada setiap kenaikan,
program membandingkan nomor baru dengan satu set pada yang sesuai
memasukkan. Ketika mereka sama, bit 0 di port yang sesuai menjadi nol. Sebagai
hasilnya, kami mendapatkan sinyal pulsa 2 level pada bit 0 di kedua port. Durasinya
sebanding dengan jumlah yang disetel pada input yang sesuai (sesuai spesifikasi).
Daftar berikut menunjukkan kode mnemonic untuk program PWM

generator. Ingat bahwa port OP0 dan OP3 digunakan untuk menjaga konstanta 0
dan 1 tersedia, masing-masing.
Loop utama program dimulai dan berulang pada instruksi pertama, diberi label sebagai
MULAILAH. Pada awal urutan, bit 0 dari port PORT0 dan PORT1
keduanya dibawa tinggi, sedangkan akumulator dibawa ke nol.
Pada garis LOOP, nilai akumulator bertambah. di baris
TEST1, TEST2 dan TEST3 yang nilainya dibandingkan dengan OP1, OP2 dan nol,
masing -masing11 .
Jika perbandingan pertama menghasilkan hasil positif, bit 0 dari PORT0 diatur ke nol.
Demikian pula, bit 0 dari PORT1 diatur ke nol jika perbandingan kedua membutuhkannya,
sedangkan perbandingan terakhir memeriksa apakah jumlah akumulator telah kembali ke nol.
Jika sudah, kita mulai lagi dari atas dan membawa bit 0 dari kedua port tinggi lagi.
MULAI: IN A,OP3
OUT PORT0,A
OUT PORT1,A
DI DALAM
A,OP0
LOOP: TAMBAHKAN A,OP3
UJI1: CP A,OP1
JP NZ, TEST2
DI DALAM
A,OP0
OUT PORT0,A
DI DALAM
A,OP1
UJI2: CP A,OP2
JP NZ, TEST3
DI DALAM
A,OP0
OUT PORT1,A
DI DALAM
A,OP2
UJI3: CP A,OP0
JP NZ, LOOP
JP MULAILAH
11
Perhatikan betapa miripnya urutan evaluasi ini dengan konstruk kasus-switch
ditemukan dalam banyak bahasa pemrograman.
Keterbatasan arsitektur ini didasarkan pada satu register saja, akumulator, sehingga pada setiap
perbandingan positif kita perlu menghapus akumulator
hanya untuk menulis nol di port output.
Jika tidak ada koreksi yang dilakukan, operasi ini akan kehilangan memori nomornya
kita berada di tangga. Untungnya, yang perlu kita lakukan dalam kasus kita adalah ini:
ambil nilainya (bahwa perbandingan yang ditemukan sama dengan angka yang ada di
akumulator) dari port input yang sesuai dan muat ulang.
Akhirnya kami merakit program dan mendapatkan kode mesin sebagai berikut:

MULAI: IN A,OP3 00h 1Fh
DI DALAM
A,OP0 03 jam 1Ch
LOOP: TAMBAHKAN A,OP3 04 jam 07 jam
UJI1: CP A,OP1 05 jam 31 jam
JP NZ, TEST2 06h 26j 0Bh

DI DALAM
A,OP0 08h 1Ch
DI DALAM
A,OP1 0Ah 1Dh
UJI2: CP A,OP2 0Bh 32j
JP NZ, TEST3 0Ch 26j 11 jam
DI DALAM
A,OP0 0Eh 1Ch
OUT PORT1,A 0Fh 35h

DI DALAM
A,OP2 10j 1Eh
UJI3: CP A,OP0 11 jam 30 jam
JP NZ, LOOP 12j 26 jam 04 jam
JP MULAI 14 jam 22 jam 00h

1.6 Konstanta, variabel, dan memori baca/tulis

Di bagian ini, kami akan menyelesaikan desain prosesor kami untuk tujuan pendidikan
dengan menambahkan dukungan untuk mengelola konstanta dan bank memori RAM
kecil untuk mengelola variabel.
1.6.1 Konstanta
Istilah "konstanta" berarti angka atau nilai yang digunakan program untuk
perhitungannya, yang ditentukan saat program ditulis dan tetap tidak dapat diubah
selama eksekusi program. Kami telah menggunakan konstanta di bagian sebelumnya.
Kami mengambilnya dari port input karena kami tidak memiliki cara lain untuk
memberikan nilai-nilai ini ke program kami.
Penggunaan port untuk tujuan ini cukup terbatas. Ini karena kami ingin menggunakan
port untuk memperoleh angka dari luar untuk diproses dan karena cukup sering kami
membutuhkan sangat banyak konstanta.
Akan berguna untuk mengingat konstanta di dalam program itu sendiri dan dapat
memuatnya di akumulator. Untuk melakukan itu, kami akan menambahkan instruksi
baru:
LD A,<const>
di mana LD adalah singkatan untuk Load, dan operan <const> adalah konstanta 8-bit
generik untuk disalin di akumulator. Misalnya, untuk memuat 01h konstan dalam
register, kami menulis:
LD A,01j
Tapi di mana kita harus menghafal konstanta ini? Seperti yang kita lakukan untuk
instruksi lompat (lihat gambar di bawah), akan lebih mudah untuk menempatkan
operan instruksi di lokasi memori segera setelah kode mesinnya. Dengan cara ini,
kami memanfaatkan kesempatan untuk meningkatkan PC untuk menargetkan
konstanta mengikuti instruksi.
1.6 Konstanta, variabel, dan memori baca/tulis 71
Dengan instruksi lompat, kami menambahkan koneksi antara output memori program
dan input pra-muat PC. Panah hijau menunjukkan jalur alamat lompatan.
Dengan konstanta, kita perlu membawa output memori program ke akumulator, tetapi
kita tidak bisa melakukannya secara langsung karena akumulator terhubung ke output
ALU.
Solusi pertama yang terlintas dalam pikiran adalah menambahkan multiplexer untuk
memilih tempat mengambil nilai untuk dimuat di akumulator. Ini ditunjukkan pada gambar
di bawah di mana panah menyorot dua jalur.
Di bawah kendali Select Line, kita dapat memilih untuk mengarahkan output ALU
(seperti sebelumnya) atau output memori program ke akumulator. Jelas, garis seleksi
harus berasal dari mikrokode sehingga instruksi mikro dapat mengontrolnya.
Pilihan sederhana ini dari sudut pandang jalur tidak sesuai dengan apa yang kami
tambahkan ke prosesor kami di bagian ini. Ini akan memaksa kita untuk menambahkan
sedikit ke mikrokode tetapi satu-satunya baris yang tersedia (D0) akan segera digunakan
untuk hal-hal lain.
Menambahkan bit lain akan membutuhkan memori program mikro yang lebih besar.
Meskipun secara teknis ini layak, mari kita ingat ruang lingkup pendidikan dari jaringan
yang kita bangun. Kami ingin membatasi kompleksitas jaringan.
Ini berarti kita harus berkompromi dan menghilangkan sesuatu untuk memberi ruang
bagi koneksi baru. Mari kita manfaatkan jalur data prosesor yang ada dan mengorbankan
port input (OP3). Ini tidak ideal tetapi jika kita menganggap bahwa kita selalu
menggunakan setidaknya satu port untuk membaca konstanta pada contoh sebelumnya,
ini bukanlah pengorbanan yang tidak masuk akal, mengingat bahwa, sebagai gantinya,
kita dapat menempatkan banyak konstanta dalam memori program. .
Gambar berikut menunjukkan tidak ada port OP3. Sebagai gantinya, input
memori program telah terhubung ke input multiplexer. Panah menunjukkan jalur
yang mengikuti konstanta sebelum dimuat di akumulator.
Di bawah ini, kita melihat mikroprogram instruksi LD A,<const>, yang terdiri dari
dua instruksi mikro. Yang pertama ditempatkan di alamat memori mikroprogram
3Dh jadi, seperti yang telah kita pelajari, nomor ini adalah kode mesin instruksi.
Hex Mnemonik -
LD A,<const> 3Dh 0 1 0 0 0 0 0 0 1 1 1 1 1 1 1 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Untuk mengaktifkan jalur ini, F2F1F0 harus diatur pada '111' pada instruksi
mikro pertama sehingga operan B disalin pada output ALU. Juga, P1P0 harus
di '11' untuk memilih saluran multiplexer 3. Terakhir, kita harus memaksa nomor
dalam register untuk memuat dengan S1S0 = '11'.
Ketika sinyal-sinyal ini aktif, PC menargetkan lokasi kode mesin berikutnya,
yang berisi konstanta yang akan dimuat di akumulator (di tepi naik jam
berikutnya). LDMC diatur pada '0', sehingga instruksi mikro kedua dapat dibaca.
ENPC = '1' sehingga PC dibawa ke depan untuk mengambil instruksi berikutnya
pada siklus clock berikutnya.
Instruksi mikro kedua memaksa PC untuk memuat di MPC, membawanya ke
depan untuk menargetkan instruksi berikutnya.
1.6.2 Instruksi pengalamatan langsung
Istilah "pengalamatan" mengacu pada mode yang digunakan untuk mengambil data untuk diproses.
Kategori instruksi ini menggunakan pengalamatan "segera" untuk mengambil nomor
yang ditemukan segera setelah kode mesin instruksi.
Setelah kami mengubah koneksi ke input multiplexer I3, kami dipaksa untuk meninjau
semua instruksi yang menggunakan input itu. Sejauh ini, tidak satu pun dari instruksi
ini yang melibatkan pembacaan konstanta dari program memori. Misalnya, jika kita
mencoba mengeksekusi ADD A,OP3 sekarang, itu akan menambahkan isi A dengan
kode mesin dari instruksi berikutnya dalam memori program. Ini tidak menarik minat
kami. Sebagai gantinya, mari tambahkan instruksi:
TAMBAHKAN A,<const>
Pada contoh di bawah ini, programmer meminta untuk menambahkan konstan 27h
ke accu mulator. Konstanta ditempatkan langsung setelah kode mesin.
mnemonik Kode Mesin

TAMBAHKAN A,27j 40h 27 jam
Instruksi ini memiliki kode mesin 40h, yang dialokasikan dalam MPM pada alamat
tersebut. Mikroprogram di bawah ini menunjukkan bahwa instruksi mikro pertama
memerintahkan (F2F1F0 = '000' dan P1,P0 = '11') jumlah isi akumulator dengan nilai
dari memori mikroprogram, alias konstanta yang mengikuti kode mesin.
Ingat bahwa pipa sequencing membuat PC selalu menargetkan lokasi memori

berikutnya setelah instruksi dieksekusi.
ENPC LDMC J0 J1 J2 EFLG EO1 EO0 F1 F2 P0 P1 S0 S1 F0

mnemonik hex -
TAMBAHKAN A,<const> 40j 0 1 0 0 0 1 0 0 0 0 0 1 1 1 1 0

+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Setelah penjumlahan, register flag (EFLG = '1') diperbarui. Juga, PC dipaksa untuk
menambah (ENPC = '1') untuk menjaga pipa tetap aktif, dan hasil penjumlahan
(S1,S0 = '11') disimpan di akumulator. Instruksi mikro kedua hanya memerintahkan
LDMPC = '1' dan ENPC = '1' sehingga instruksi berikutnya dapat dieksekusi.
Mari kita terapkan mode pengalamatan langsung untuk mendefinisikan instruksi SUB, AND,
OR dan CP juga. Kita mendapatkan:
ENPC LDMC J0 J1 J2 EFLG EO1 EO0 F1 F2 P0 P1 S0 S1 F0

mnemonik hex -
SUB A,<const> 42j 0 1 0 0 0 1 0 0 0 0 1 1 1 1 1 0

+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
AND A,<const> 44h 0 1 0 0 0 1 0 0 0 1 0 1 1 1 1 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
ATAU A,<const> 46h 0 1 0 0 0 1 0 0 0 1 1 1 1 1 1 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
CP A,<const> 4Ah 0 1 0 0 0 1 0 0 0 0 1 0 0 1 1 0
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Berkat instruksi alamat langsung, kita tidak lagi harus mendedikasikan port input
untuk akuisisi konstanta. Perhatikan contoh di Bagian 1.5.3.1 di mana kita
membutuhkan konstanta 01 jam pada port input OP1 untuk dapat mengeksekusi
peningkatan dan penurunan konten akumulator.
Sekarang setelah kita memiliki instruksi alamat langsung, mari kita tinjau kembali
contoh sebelumnya dan substitusikan setiap kenaikan (ADD A,OP1) dengan ADD
A,01h dan setiap penurunan (SUB A,OP1) dengan SUB A,01h. Ini membebaskan
kita dari kendala membutuhkan konstanta pada port input.
1.6.3 Variabel
Istilah "variabel" mengacu pada wadah yang mempertahankan isinya (dalam

kasus kami, kode biner yang dapat mewakili angka, karakter ASCII, dll.). Konsep
ini mencerminkan register generik. Saat prosesor bekerja, program mengubah
konten variabel, misalnya untuk mengingat hasil antara operasi, seperti yang
telah kita lihat dengan akumulator.
Namun, hanya memiliki satu register yang tersedia tidak cukup untuk sebagian
besar program yang akan kami tulis. Ambil contoh perhitungan ekspresi logika
bitwise seperti ini:
(OP0 · OP1) + (OP0 + OP1)

dimana kita harus terlebih dahulu melakukan perhitungan suku pertama,
menghafalnya di suatu tempat, melakukan perhitungan suku kedua dan terakhir
menghitung jumlah logis dari kedua hasil tersebut.
Kita bisa menambahkan satu set register seperti akumulator ke prosesor. Banyak
prosesor komersial memiliki sejumlah register di dalamnya. Namun, pilihan kami
bergantung pada penggunaan memori baca/tulis dengan ukuran yang sebanding
dengan jaringan lainnya, yang memungkinkannya untuk dibaca dan ditulis oleh
unit kalkulasi prosesor.
1.6.4 Memori baca/tulis (RAM)
Istilah "memori baca tulis" mengacu pada sistem yang dapat menghafal angka secara
terorganisir. Untuk alasan historis, jenis memori ini disebut RAM (Random Access Memory.
Lihat Lampiran A.2 untuk lebih jelasnya).
Pada prinsipnya, kita dapat membayangkan RAM sebagai satu set register paralel yang
sama, yang masing-masing dapat dimuat (ditulis) dengan sebuah nomor dan kemudian
dibaca kembali ketika kita ingin mengambil nomor tersebut. Masing-masing register ini
dapat dianggap sebagai manifestasi fisik dari suatu variabel, dapat berisi kode biner.
RAM dapat berisi sejumlah besar register yang mulai sekarang akan kita panggil lokasi
memori (atau sel). Jumlah lokasi dapat berkisar dari beberapa hingga ratusan dalam
komponen kecil dan ada sistem yang dapat mengingat beberapa miliar lokasi.
Kecuali untuk kasus tertentu, RAM memungkinkan kita untuk

menulis atau membaca satu lokasi pada satu waktu. Setiap
sel diidentifikasi dengan nomor yang disebut alamat (seperti
dengan ROM).
Gambar di sebelah kiri menunjukkan representasi

sederhana dari koneksi RAM "statis" utama. Lihat
Lampiran A.2.
Bagian dalam memori ditampilkan dalam bentuk
yang diidealkan, sebagai tabel. Setiap blok tabel
diidentifikasi dengan alamatnya.
Setiap lokasi mempertahankan nomor yang tertulis di
dalamnya atau nilai tak tentu jika belum ada yang
tertulis di dalamnya.
Untuk mengingat angka dalam RAM, pertama-tama kita harus memutuskan lokasi mana
yang akan dipilih di antara semua kemungkinan. Untuk melakukan ini, kita harus
menyediakan RAM dengan alamat lokasi yang kita inginkan pada baris Alamat. Kemudian
kita harus mengirimkan nomor tersebut ke input DataIn RAM dan kemudian
memerintahkannya untuk ditulis (di sini perintah Write generik diwakili).
Ketika kita ingin membaca ulang nomor di lokasi yang ditulis sebelumnya, kita harus
memberikan alamatnya ke memori dan kemudian mengambil konten dari output DataOut.
1.6.5 RAM instruksi baca/tulis
Sekarang mari kita tulis instruksi yang kita perlukan untuk menggunakan RAM. Mereka terlihat seperti ini:
LD (<alamat>),A
LD A,(<alamat>)
Seperti sebelumnya, LD adalah singkatan dari Load, dan operand <address> adalah alamat 8-
bit yang digunakan untuk mengakses memori. LD (<address>),A menyalin konten akumulator
dan menulisnya di lokasi memori yang ditentukan dalam tanda kurung. LD A,(<address>)
membaca konten lokasi memori dalam tanda kurung dan menyalinnya di akumulator.
Pada contoh di bawah ini, kita memuat konstanta 3Fh di akumulator dan kemudian
menuliskannya di alamat memori 45h:
LD A,3Fh
LD (45 jam),A
Kemudian setelah menggunakan akumulator untuk perhitungan lain, kita dapat mengambil
nilai yang disimpan di memori dengan menulis:
LD A, (45 jam)
Sekarang mari kita mengadopsi proses yang sama untuk beberapa kasus yang telah kita lihat
sebelumnya, mengenai di mana untuk mengingat operan dan alamat untuk mengirim ke RAM.
Seperti sebelumnya, kami mengandalkan fakta bahwa PC bertambah ketika instruksi di-
decode. Jadi kami menunjukkan alamat sel memori RAM yang ingin kami baca atau tulis,
segera setelah kode mesin.
1.6.6 RAM dan prosesor
Kami menambahkan RAM ke prosesor kami sehingga

sebagian hasil perhitungan kami dapat dihafalkan sementara
di dalamnya. Untuk melakukan ini, kita harus mengelola
berbagai jalur data dan sinyal kontrol yang diperlukan.
Kami akan menggunakan komponen dari simulator li brary,
sebuah RAM dengan 256 lokasi pada masing-masing 8 bit.
Lihat gambar di sebelah kanan. Ini adalah RAM baca/tulis
yang sinkron.
Untuk menulis, pertama-tama kita perkenalkan alamat sel pada baris Alamat, dan nomor yang
akan ditulis di input DataIn. Jika baris Write Enable (WE) aktif, nomor tersebut akan diingat di
tepi naik berikutnya dari jam CK. Untuk membaca, pertama-tama kita merutekan lokasi memori,
kemudian kontennya tersedia di output pada tepi aktif jam berikutnya. Jelasnya, untuk
menjalankan fungsi baca/tulis, jalur CS (Pilihan Chip) harus diaktifkan.
Gambar berikut menunjukkan jalur penulisan. Di prosesor kami, kami harus mengambil
kembali nomor yang akan ditulis dari output ALU (panah kuning) untuk menghindari perubahan
jalur yang ada.
Kami tidak memerlukan perubahan khusus untuk alamat (panah merah) karena kami telah
memutuskan untuk mengambilnya dari memori program seperti yang disebutkan di atas.
Seperti halnya lompatan dan konstanta, itu akan berada di lokasi setelah kode mesin.
Gambar tersebut juga menyoroti jalur pengaktifan tulis WE yang telah kami sambungkan
ke jalur mikrokode D0.
Berkat koneksi yang telah kita atur sejauh ini, kita sekarang dapat menentukan program
mikro untuk instruksi tulis di RAM.
Instruksi ini dikodekan sebagai 38h, kami menempatkan mikroprogram di alamat MPM ini.
Instruksi mikro pertama (lihat tabel berikut) menetapkan F2F1F0 pada '110' sehingga
akumulator disalin pada output ALU dan kemudian memerintahkan penulisan dengan
mengaktifkan WE.
ENPC LDMC J0 J1 J2 EFLG EO1 EO0 F1 F2 P0 P1 S0 S1 F0 KAMI

mnemonik hex
LD (<alamat>), A 38j 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 +1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
Ketika sinyal-sinyal ini aktif, PC menargetkan lokasi yang menyimpan alamat, yang
digunakan oleh memori saat menulis (di tepi naik jam berikutnya). Di sini LDMC = '0' untuk
membaca instruksi mikro kedua, dan ENPC = '1' untuk memaksa PC naik, untuk mengambil
instruksi berikutnya.
Seperti dalam semua kasus sebelumnya yang telah kita pelajari, instruksi mikro kedua
memaksa instruksi berikutnya untuk dimuat di MPC untuk membawa PC maju satu
kenaikan untuk bersiap mengambil instruksi berikutnya dan menjaga jalur pipa tetap aktif.
Pada gambar di bawah, panah menunjukkan jalur data yang sedang dibaca.
Agar nomor dalam output RAM dimuat di akumulator, perlu mengikuti jalur khusus.
Demi konsistensi dengan sirkuit sebelumnya, mari batasi kompleksitas jaringan dan
gunakan multiplexer yang sudah kita miliki daripada menambahkan yang baru dan
mengorbankan port input lain (OP2). Setelah kita menetapkan jalur baca, maka kita
dapat menentukan program mikro untuk instruksi tulis di RAM. Itu ditempatkan di
alamat 3Ah, jadi ini adalah kode mesinnya. Tabel berikut menunjukkan program
mikro.

mnemonik hex
LD A, (<alamat>) 3Ah 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 +1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
00
Instruksi mikro pertama hanya memerintahkan PC untuk meningkatkan satu
kenaikan untuk menjaga mekanisme pipa tetap berjalan. Instruksi ini dikirimkan ke
jalur data pada siklus clock yang sama dengan alamat lokasi yang akan dibaca yang
tersedia untuk RAM. Ini karena PC menargetkan lokasi yang berisi operand instruksi.
Melalui pembacaan sinkron, RAM membuat nomor tersedia setelah tepi aktif jam.
Instruksi mikro kedua menetapkan F2F1F0 = '111' untuk membiarkan operan B

melewati ALU, dan 'P1P0 = 10' sehingga multiplexer menyalin konten lokasi RAM.
Nomor dari RAM kemudian dimuat di akumulator di tepi naik jam karena sinyal S1
dan S0 keduanya disetel
di '1'. Instruksi mikro ini mengaktifkan jalur LDMC dan ENPC untuk menangani pemuatan
instruksi berikutnya di MPC dan membawa PC maju satu kenaikan seperti pada kasus
sebelumnya.
1.6.7 Instruksi dengan pengalamatan langsung
Instruksi yang diperkenalkan di sini memanfaatkan mode "pengalamatan langsung" untuk

membaca dan menulis angka dalam memori. Pengalamatan langsung berarti secara
eksplisit menunjukkan lokasi memori yang berisi operan dengan menempatkan alamat
segera setelah kode mesin instruksi.
Modifikasi terakhir telah mengubah sifat koneksi input multiplekser I2. Sekarang kita
perlu memikirkan kembali semua instruksi yang menangani input itu, seperti yang harus
kita lakukan untuk input I3.
Saat ini, tidak ada instruksi yang bekerja pada input multiplexer I2 yang mengalamatkan
memori RAM melalui alamat yang diambil dari memori program. Jika kami mencoba
menjalankan ADD A,OP2, kami akan menambahkan konten di lokasi ROM yang
ditargetkan oleh instruksi berikutnya ke nilai di akumulator. Ini tidak masuk akal.
Sebagai gantinya, mari kita perkenalkan instruksi ADD A,(address) yang kode mesinnya
adalah 4Ch. Instruksi ini menentukan alamat lokasi memori RAM yang ingin kita akses
segera setelah kode mesinnya. Dengan cara ini, programmer dapat memutuskan dari sel
memori mana operand kedua akan diambil.
Tabel berikut menunjukkan mikroprogram instruksi.

mnemonik hex
TAMBAHKAN A,(<alamat>) 4Ch 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 +1 1 1 0 0 0 1 0 0 0 0 0 1
1100
Seperti yang dapat kita lihat, instruksi mikro pertama hanya memerintahkan PC untuk
bertambah sehingga saluran pipa tetap aktif.
Di tepi naik berikutnya dari jam, register di dalam RAM mengingat alamat dari memori
program, yaitu yang ingin kita akses. (Ingat bahwa karena pipeline, PC selalu menargetkan
sel memori tepat setelah sel dengan instruksi dieksekusi). Setelah waktu propagasi
memori, isi dari sel memori yang dialamatkan akan tersedia pada output RAM.
Jadi, dengan instruksi mikro kedua, yang perlu kita lakukan adalah menyiapkan jalur data
untuk mendapatkan jumlah konten akumulator dan output RAM saat ini.
Yang perlu kita lakukan untuk mendapatkan hasil ini adalah memilih output RAM (P1P0
= '10'), meminta ALU untuk mengeksekusi penjumlahan (F2F1F0 = '000') dan mengatur
S1S0 = '11' untuk dihafal. Jalur LDMC dan ENPC diaktifkan agar instruksi selanjutnya
dapat dieksekusi.
Alasan serupa diterapkan untuk mengatur instruksi SUB, AND, OR, CP, IN dan OUT
dengan pengalamatan langsung, memberi kita:
ENPCLDMC J0 J1 J2 EO0 EO1 EFLG P1 S0 S1 F0 F1 F2 KAMI P0

mnemonik hex
SUB A,(<alamat>) 4Eh 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 1 0 0 0 0 1 1 1 1 0 0
DAN A,(<alamat>) 50 jam 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 1 0 0 0 1 0 1 1 1 0 0 52j 0 1 0 0 0 0 0 0 0
ATAU A,(<alamat>) 000000
+1 1 1 0 0 0 1 0 0 0 1 1 1 1 1 0 0
DI (<alamat>),OP0 56j 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 1
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
DI (<alamat>),OP1 58 jam 0 1 0 0 0 0 0 0 1 1 1 0 0 0 1 1
+1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
CP A,(<alamat>) 5Ah 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 1 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0
OUT PORT0,(<address>) 5Ch 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 +1 1 1 0 0 0 0 0 1 1 1 1 0 0 1 0
0
OUT PORT1,(<address>) 5Eh 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 +1 1 1 0 0 0 0 1 0 1 1 1 0 0 1 0
0
Lampiran B.5.1 memiliki daftar instruksi dan program mikro untuk versi final Mp8E dari
prosesor untuk dikonsultasikan. Lampiran B.5.2 memiliki skema lengkapnya.
1.6.8 Penggunaan jaringan Mp8E: contoh
Berikut ini adalah contoh pemrograman untuk jaringan Mp8E, yang menggunakan memori
RAM dan konstanta langsung.
1.6.8.1 Menghitung ekspresi logika
Kami ingin menulis program yang menghitung ekspresi logika yang muncul di awal Bagian
1.6.3, dan memberikan hasilnya pada output PORT0:
PORT0 = (OP0 · OP1) + (OP0 + OP1)
Seperti disebutkan sebelumnya, ekspresi ini tidak dapat dihitung dengan menggunakan satu-
satunya akumulator yang kita miliki. Bahkan jika kita mencoba menyederhanakan dengan
menggunakan teorema aljabar Boolean, kita masih perlu menggunakan variabel sementara
untuk mengingat setidaknya satu hasil kalkulasi antara.
Oleh karena itu, kami akan mendedikasikan lokasi RAM 00h untuk tugas ini. Berikut ini adalah
kode mnemonic dan kode mesin yang sesuai:

DI DALAM
A,OP0 00j 1Ch
DAN A,OP1 (00j),A 01j 0Dh

LD 02 jam 38 jam 00h
DI DALAM
A,OP0 04j 1Ch
ATAU A,OP1 05 jam 11 jam
TIDAK A 06 jam 14 jam
ATAU A,(00j) 07 jam 52 jam 00h
BERHENTI 09 jam 01 jam 01 jam
Seperti yang Anda lihat, setelah eksekusi bitwise AND di antara keduanya
operand, hasil parsial disimpan dalam RAM. Kemudian operasi kedua
dieksekusi (bitwise OR, dinegasikan) dan nilai yang diperoleh ditempatkan di OR
bersama dengan RAM, memberi kita hasil akhir.
1.6.8.2 Perhitungan ekspresi matematika
Ekspresi berikut telah ditetapkan untuk menghitung:
OP1
PORT0 = OP0/2
Perhatikan bahwa membagi angka dengan kekuatan dua berarti mengeksekusi angka
pergeseran kanan yang sama dengan eksponen pangkat 2, memasukkan nol
di kiri. Juga, OP1 harus diatur ke nilai yang lebih kecil dari atau sama dengan 8 (untuk
nilai yang lebih besar, hasilnya dipaksa menjadi nol, berapa pun nilai OP0 mungkin).
Berikut ini adalah salah satu solusi yang mungkin:
DI DALAM
A,OP0
LD (00j),A
DI DALAM
A,OP1
LD (01j),A
ATAU A,00j
LOOP: JP Z, KELUAR
LD A,(00j)
SRL A
(lanjutan)
LD (00j),A
LD A,(01j)
SUB A,01j (01j),A
LD
JP LINGKARAN
KELUAR: LD A,(00j)
OUT PORT0,A
BERHENTI
Pertama, nilai dari dua port input diperoleh oleh program dan disimpan dalam dua
variabel. Kami memuat OP0, dividen, dalam variabel pertama.
Kemudian, variabel ini akan berisi sebagian (dan juga hasil akhir) dari perhitungan. Nilai
port OP1 (eksponen pembagi) dimuat dalam variabel kedua, tetapi akan dikurangi untuk
tetap menghitung jumlah pergeseran kanan yang diperlukan untuk mendapatkan
hasilnya.
Sebelum masuk dalam loop yang dimulai dengan label LOOP, jumlah shift yang
dibutuhkan (yang masih di A) harus diperiksa. Instruksi OR digunakan untuk memastikan
angka ini bukan nol (mengeksekusi OR dengan nol tidak mengubah nilai A, tetapi
memperbarui flag).
Jika jumlah shift yang akan dieksekusi adalah nol, tidak ada pembagian untuk dieksekusi
dan jadi kami melompat ke EXIT. Di sana, kami memperbarui port output dengan nilai
awal dividen dan kemudian menempatkan CPU dalam status HALT.
Jika tidak, kami membagi dividen menjadi dua dengan menggesernya satu posisi ke
kanan (sisa pembagian hilang). Variabel yang berisi dividen diambil dari memori dan
dibawa ke akumulator di mana isinya digeser ke kanan. Kemudian, nilai baru diperbarui
di memori.
Kemudian, variabel yang memuat jumlah shift diturunkan satu. Proses untuk
mencapainya adalah sebagai berikut: prosesor membaca konten variabel dari lokasi
memori, mengurangi konstanta 1 dan memperbarui lokasi yang sama dengan nilai baru.
Nilai ini sama dengan jumlah shift yang masih harus dijalankan. Pengurangan telah
memperbarui bendera nol. Ini akan memungkinkan kita untuk melihat apakah angka itu
memang nol.
Lompatan tanpa syarat membawa kita kembali ke label LOOP di mana loop berulang
jika jumlah shift belum mencapai nol. Jika sudah, kita lompat ke EXIT dimana nilai akhir
perhitungan dibawa ke port output PORT0 dan kemudian prosesor berhenti.
Pindah ke kode mesin, kami mendapatkan hasil berikut:


DI DALAM
A,OP0 00h 1Ch
LD (00j),A 01 jam 38 jam 00h
DI DALAM
A,OP1 03 jam 1Dh
LD (01j),A 04 jam 38 jam 01 jam
ATAU A,00j 06 jam 46 jam 00h

LOOP: JP Z, KELUAR 08h 24 jam 17 jam
LD A,(00j) 0Ah 3Ah 00h

SRL A 0Ch 20j
LD (00j),A 0Dh 38h 00h
LD A,(01j) 0Fh 3Ah 01h
SUB A,01j (01j),A 11 jam 42 jam 01 jam
LD 13 jam 38 jam 01 jam
JP LINGKARAN 15j 22 jam 08h

KELUAR: LD A,(00j) 17h 3Ah 00h
BERHENTI 1Ah 01h 01 jam
1.6.8.3 Membangkitkan sampel gelombang sinusoidal
Contoh ini akan menunjukkan program yang dapat menghasilkan sampel jenis apa pun
gelombang, termasuk gelombang bentuk sinusoidal pada port PORT0.
Hanya dengan melihat gambar di atas, kita dapat mengetahui bagaimana sampel sinusoidal
dihitung, perkiraan bilangan bulat 8-bit dari bentuk gelombang yang ideal.
Ada 16 nilai dalam interval +127..-127 (ditampilkan dalam heksadesimal

dalam gambar).
Jika kita memiliki sampel yang mewakili seluruh periode bentuk gelombang, kita dapat menghafal
konstanta dalam program dan kemudian mentransfernya ke port output PORT0.
Di bawah ini adalah contoh bagaimana program harus mencari bentuk gelombang apa pun:
MULAI: LD A, Contoh1
OUT PORT0,A
LD A, Contoh2
OUT PORT0,A
. .
. .
LD A, SampelN
OUT PORT0,A
JP MULAILAH
Untuk bentuk gelombang sinusoidal pada gambar sebelumnya, kita mendapatkan program berikut:
(bersama dengan kode mesin yang sesuai):

MULAI: LD A,00j 00j 3Dh 00h
LD A,31j 03j 3Dh 31 jam
LD A,5Ah 06h 3Dh 5Ah

LD A, 75j 09 jam 3Dh 75 jam
OUT PORT0,A 0Bh 34h

LD A, 7Fh 0Ch 3Dh 7Fh
OUT PORT0,A 0Eh 34j
LD A, 75j 0Fh 3Dh 75 jam
LD A, 5Ah 12j 3Dh 5Ah

LD A, 31j 15j 3Dh 31 jam
LD A, 00j 18 jam 3Dh 00h

OUT PORT0,A 1Ah 34j
LD A, CFh 1Bh 3Dh CFh
OUT PORT0,A 1Dh 34h
LD A, A6h 1Eh 3Dh A6h
OUT PORT0,A 20j 34 jam
(lanjutan)

LD A, 8B 21j 3Dh 8Bh
LD A, 81j 24 jam 3Dh 81j

LD A, 8B 27j 3Dh 8Bh

OUT PORT0,A 29j 34 jam
LD A, A6h 2Ah 3Dh A6h

OUT PORT0,A 2ch 34j
LD A, CFh 2Dh 3Dh CFh
OUT PORT0,A 2Fh 34 jam
JP MULAILAH 30 jam 22 jam 00h
Sampel telah dirancang untuk divisualisasikan secara ideal oleh “Digital To Ana log
Converter” (DAC)12. Simulator Perbuatan menawarkan beberapa jenis virtual
Komponen DAC yang secara grafis dapat memvisualisasikan bentuk gelombang analog yang
dihasilkan.
1.6.9 Pertimbangan terakhir pada prosesor yang dikembangkan di sini
Situs web simulator Deeds memiliki skema rangkaian semua jaringan yang kami
pernah belajar di sini. Kita dapat menggunakannya untuk menguji semua program yang telah kita kembangkan. Kita
juga dapat memperluas wawasan kami dan merancang sistem baru atau berbasis ekspansi
pada prosesor yang telah kami rancang sejauh ini.
Misalnya, beberapa latihan di akhir bab ini meminta Anda untuk merancang
instruksi baru. Faktanya, prosesor yang kami rancang di sini dapat mengeksekusi lebih banyak
instruksi yang kompleks daripada yang disajikan sejauh ini.
Di antara jenis prosesor yang diperiksa di awal bab, kami

prosesor jelas terinspirasi oleh arsitektur Harvard karena memisahkan
memori program mengakses dari memori RAM. Kita bisa
melanjutkan proses perluasan kemampuan prosesor, menjadikannya selamanya
lebih kuat hingga menjadi mikroprosesor modern.
Namun demikian, melanjutkan dengan pendekatan dari bab ini akan membuat
jaringan yang semakin kompleks, mengalihkan kita dari salah satu tujuan buku ini:
mempersiapkan pembaca untuk secara efisien memprogram prosesor apa pun dari fungsinya
spesifikasi. Inilah sebabnya mengapa penulis percaya bahwa pengobatan topik ini
harus menyimpulkan di sini.
12
Konverter Digital Ke Analog adalah rangkaian elektronika yang dapat mengubah suatu urutan
angka ("sinyal digital") menjadi "sinyal analog", yang nilainya proporsional
ke sinyal digital di input.
Pada bab berikutnya, kita akan membuang perspektif mikroprosesor

Merancang dan menganalisis arsitektur mikroprosesor 8-bit lengkap, yang diilhami oleh
prosesor yang benar-benar ada dan didukung oleh instrumen pengembangan yang
lengkap. Kali ini kita akan mengambil sudut pandang seseorang yang
ingin menggunakan mikroprosesor sebagai komponen untuk merancang sistem elektronik.
Kami tidak akan lagi memperhatikan detail menit tentang bagaimana prosesor
fungsi di interiornya.
Kita akan belajar membuat komputer mikro kecil di sekitarnya (Bab 2) dan
untuk memprogramnya dalam bahasa rakitan (dari Bab 3 seterusnya). Akhirnya, kami akan
memperluas perangkat keras sistem dengan bereksperimen dengan beberapa teknik
mikroprosesor "dalam antarmuka" dengan berbagai jenis perangkat.
1.7 Latihan 87
1.7 Latihan
Halaman konten digital buku di situs simulator Deeds memiliki garis besar skema,
diagram dan/atau program yang harus diselesaikan untuk setiap latihan. Halaman
web yang sama juga memiliki file untuk solusi, sehingga siswa dapat memeriksa
pekerjaan mereka.
1.7.1 Jaringan komputasi khusus
1. Rancang jaringan kombinasional yang dapat mengalikan input 6-bit yang tidak ditandatangani
dikalikan 3.
2. Diberikan dua (6-bit unsigned) bilangan bulat A dan B, rancang kerja jaringan
kombinasional yang dapat menghitung ekspresi ((A + B)/2) + 5. Hasilnya juga
harus bilangan bulat 6-bit. Ini berarti setiap bagian pecahan harus dipotong dari
nomor tersebut.
3. Diberikan (8-bit unsigned) bilangan bulat A, B dan C, rancanglah kerja netto

kombinasional yang dapat menghitung ekspresi (A/2+B/4+C/8). Hasilnya juga
harus berupa bilangan bulat 8-bit. Ini berarti setiap bagian pecahan harus dipotong
dari nomor tersebut.
4. Tentukan bagan ASM dari sequencer jalur data pada Halaman 14, yang
memungkinkan untuk menghitung ekspresi berikut. a) 3 · (OP0) + 2 · (OP3) b) 3/2
· (OP1) + 3 · (OP2)
5. Program memori ROM jaringan pada halaman 18, sehingga dapat menghitung
ekspresi berikut. a) 3 · (OP0) + 2 · (OP3) b) 3/2 · (OP1) + 3 · (OP2)
6. Tambahkan parity flag P ke ALU pada Halaman 20. Seharusnya dihitung menurut
logika: P = '1' jika hasilnya memiliki jumlah bit ganjil di '1', P = '0' jika angka itu
genap .
7. Menggunakan ALU sebagai referensi, rancang komponen kombinasional dengan

dua input: ZF dan CO, dan tiga output: A=B, A>B dan A<B. Komponen harus
mengevaluasi flag yang disediakan oleh ALU dan menentukan apakah A=B, A>B
atau A<B.
1.7.2 Jaringan komputasi yang dapat diprogram
1. Program memori ROM jaringan Mp8A pada Halaman 22 dan Lampiran B pada
Halaman 587, sehingga mampu menghitung ekspresi yang ditunjukkan.
Kami menyarankan penalaran terlebih dahulu dalam kode mnemonik dan

menggunakan tabel dalam Lampiran B pada Halaman 585. Bagian pecahan dalam
perhitungan dapat dipotong.
a) BUKAN [(OP2) DAN (OP3) ATAU (OP1)] b)

3/2 · (OP2) + (OP1) c) [(OP0) + 2 · (OP1)
(OP2) + 3/2 · (OP3)]/4
2. Program jaringan Mp8C (lihat Bagian 1.3.2 dan Lampiran B.3) sehingga akumulator
mengasumsikan urutan waktu yang ditunjukkan dalam gambar.
Jika Anda perlu menggunakan konstanta, kami sarankan untuk mendedikasikan port input
yang tidak digunakan untuk mendapatkannya. Misalnya, jika Anda perlu menaikkan nilai
akumulator, Anda dapat mengasumsikan bahwa Anda memiliki konstanta 1 yang tersedia
di port input OP1.
a) Buat urutan berikut di akumulator.
Catatan: Anda dapat dengan bebas memilih durasi nilai dan interval antara dua
urutan; perhatikan hubungan antara nilai-nilai pada gambar (dengan mengabaikan
sisanya, 7 = 14 : 2, 3 = 7 : 2, 1 = 3 : 2...).
b) Buat urutan berikut di akumulator.
Catatan: Anda dapat dengan bebas memilih durasi nilai.

1.7 Latihan 89
3. Program jaringan Mp8D (lihat Bagian 1.5 dan Lampiran B.4) sehingga port PORT0
mengasumsikan urutan waktu yang ditunjukkan pada gambar.
a) Buatlah barisan berikut:
Catatan: Anda dapat dengan bebas memilih durasi nilai dan interval waktu
antara dua urutan. Juga, port input dapat menyediakan konstanta yang
diperlukan.
Hubungan antara nilai-nilai pada gambar, yang menghadap ke sisa ders,
adalah sebagai berikut: 7 = (14 : 2), 3 = (7 : 2), 1 = (3 : 2)...
b) Buatlah barisan berikut:
Catatan: asumsikan OP0, OP2 dan OP3 berbeda dari nol. Jika Anda perlu
mendapatkan konstan 1, itu dapat diatur pada port OP1.
4. Tulis program untuk jaringan Mp8E (lihat Lampiran B.5 di

Halaman 596) yang bertindak sebagai pengatur waktu yang menghitung waktu yang telah berlalu dari reset.
Setelah nilai pada port OP0 dibaca, program harus mengurangi
isi akumulator sampai mencapai nol. Saat hitungan berakhir, kita
harus memasuki loop tak terbatas di mana semua LED terhubung ke port output
PORT0 dan PORT1 berulang kali dinyalakan dan dimatikan hingga sistem
diatur ulang.

Halaman 596) yang dapat menghitung EXOR bitwise antara lokasi memori
01h dan 02h, dan hafalkan hasilnya dalam 00h. Ingatlah bahwa ALU
tidak memiliki fungsi EXOR tetapi fungsi ini dapat dipecah
menjadi operasi AND dan OR. Untuk menguji solusi Anda, kami sarankan untuk memasukkan
segmen kode berikut.
Kode Mesin Alamat Komentar Mnemonic

LD A,55j ;01010101b 00h 3Dh 55h
LD (01j),A 38j 01j 02 jam
LD A,AAh ;10101010b 04h 3Dh AAh

LD (02j),A 38j 02j 06 jam
Hasil yang diharapkan: RAM(00h) = FFh.

Halaman 596) yang dapat menambahkan dua bilangan bulat 16-bit. Variabel yang mengandung
tambahan akan disimpan dalam memori RAM pada lokasi 02 jam dan
04 jam Hasilnya harus diingat pada lokasi 00h. Setiap carry yang dihasilkan di add harus
dilaporkan dengan menulis FFh di memori RAM
lokasi 06h. Jika tidak ada carry, nilai yang disimpan di lokasi 06h seharusnya
menjadi 00h. Untuk menguji solusi Anda, kami sarankan untuk memasukkan segmen berikut:
dari kode.
Komentar Mnemonik Alamat Kode Mesin

LD A,FFh ;angka pertama 00h 3Dh FFh
LD (02j),A 02j 38h 02h
LD A,FFh 04j 3Dh FFh
LD (03j),A 06h 38h 03h
LD A,01j ;angka kedua 08h 3Dh 01h
LD (04j),A 0Ah 38j 04h
LD A,00j 0Ch 3Dh 00j
LD (05j),A 0Eh 38h 05 jam
Hasil yang diharapkan: RAM(00h) = 00h, RAM(01h) = 00h, RAM(06h) = FFh.

Halaman 596) yang dapat meniru fungsi dari syn-set 8-bit pra-settable
1.7 Latihan 91
penghitung atas/bawah kronus. Port keluaran PORT0 mewakili keadaan

konter; kita bisa membaca nilai hitungan saat ini disana.
Pada port input OP0 kita menemukan input CK, EN, UP dan LD. Ketika EN adalah
tinggi, ini memungkinkan penghitung. Ketika EN rendah, status penghitung adalah
dipertahankan dan input lainnya diabaikan.
Ketika UP diset pada '1', penghitung memerintahkan untuk menghitung (+1), atau
sebaliknya menghitung mundur (-1). Ketika LD diatur pada '1', itu memerintahkan nilai
pada port input OP1 untuk memuat dalam keadaan penghitung.
Input hanya boleh dievaluasi di tepi positif jam CK.
Prioritas perintah adalah sebagai berikut: EN, LD, UP. tabel berikut
mewakili koneksi port OP0.
7654 3 2 1 0
nc nc nc nc CK LD UP EN
1.7.3 Pemrograman mikro instruksi baru
Dalam latihan di bawah ini, Anda akan diminta untuk mengubah memori program mikro
jaringan Mp8E (lihat Bagian 1.6 dan Lampiran B.5 di Halaman 596) dengan
tujuan untuk menambahkan instruksi baru.
1. Kode mnemonic di bawah ini merupakan instruksi yang memungkinkan

untuk memuat <const> konstan secara langsung di memori RAM di <address>
ditunjukkan.
LD (<alamat>), <const>
Gunakan alamat memori 60h untuk menentukan program mikro yang terkait dengan itu
petunjuk. Dalam memori program, kode mesin instruksi (60h)
diikuti oleh konstanta dan kemudian dengan alamat lokasi RAM di mana
kami ingin menghafal konstanta.
Selama proses pemuatan, nilai sebelumnya di akumulator ditulis oleh konstanta.
Untuk menguji solusi Anda, kami sarankan menjalankan
program berikut.
mnemonik Alamat Kode mesin

LD (02j),01j 00h 60 jam 01 jam 02 jam
Hasil yang diharapkan: RAM(02h) = 01h.
2. Kode mnemonik berikut mewakili instruksi yang membandingkan

isi sel memori RAM <address> dengan nilai
konstan <konst>.
CP (<alamat>), <const>
Tentukan program mikro yang terkait dengan instruksi itu pada memori iklan 63h.
Dalam memori program, kode mesin instruksi (63h) adalah
diikuti oleh konstanta kemudian dengan alamat lokasi yang memegang nilai
untuk membandingkan dengan konstanta itu.
Selama proses perbandingan, nilai sebelumnya pada akumulator adalah
ditimpa oleh konstanta. Untuk menguji solusi Anda, kami sarankan untuk menjalankan
program berikut.

LD A,01j 00 jam 3Dh 01h
CP (02j),01j 04 jam 63 jam 01 jam 02 jam
Hasil yang diharapkan: ZF aktif.
3. Kode mnemonic berikut merupakan instruksi yang membandingkan

konten sel memori RAM yang ditunjukkan oleh <address1> pertama dengan
isi sel memori RAM ditunjukkan oleh <address2> kedua.
CP (<alamat1>),(<alamat2>)
Tentukan program mikro yang terkait dengan instruksi itu di memori ad dress 66h.
Dalam memori program, kode mesin untuk instruksi (66h)
diikuti oleh <address1> pertama dan kemudian oleh <address2> kedua.
Sebelum menjalankan perbandingan, perlu memuat konten
Lokasi RAM (ditunjuk oleh alamat pertama) di akumulator. Untuk mengetes
solusi Anda, kami sarankan menjalankan program berikut.

CP (02j),(03j) 08 jam 66 jam 02 jam 03 jam
BERHENTI 0Bh 01 jam 01 jam
Hasil yang diharapkan: ZF aktif.
4. Kode mnemonic berikut mewakili instruksi yang menambahkan

konten sel memori RAM yang ditunjukkan oleh <address1> pertama dengan
isi sel memori RAM yang ditunjuk oleh <address2> kedua,
menyimpan hasilnya di akumulator.
TAMBAHKAN (<alamat1>),(<alamat2>)
1.7 Latihan 93
Tentukan program mikro yang terkait dengan instruksi itu di alamat memori
69 jam. Dalam memori program, kode mesin untuk instruksi (69h) adalah
diikuti oleh <address1> pertama dan kemudian <address2> kedua. Kita
sarankan menggunakan program berikut untuk menguji solusi Anda.

LD A,01j 00h 3Dh 01h
LD A,FFh 04 jam 3Dh FFh
TAMBAHKAN (02j),(03j) 08h 69j 02h 03h
BERHENTI 0Bh 01 jam 01 jam
Hasil yang diharapkan: A = 00h, ZF = 1, CO = 1.
5. Kode mnemonic berikut mewakili instruksi yang menambahkan isi sel memori RAM yang
ditunjukkan oleh <address1> pertama dengan
isi sel memori RAM yang ditunjukkan oleh <address2> kedua.
Kemudian menyimpan hasilnya di lokasi RAM yang ditunjukkan oleh yang ketiga
<alamat3>.
TAMBAHKAN (<alamat1>),(<alamat2>),(<alamat3>)
Tentukan program mikro yang terkait dengan instruksi itu di memori ad dress 6Ch. Dalam
memori program, kode mesin instruksi (6Ch) adalah:
diikuti oleh <address1>, <address2> dan <address3> satu demi satu.
Dalam proses tambah, nilai sebelumnya di akumulator ditimpa.
Kami menyarankan menggunakan program berikut untuk menguji solusi Anda.

LD A,FFh 04 jam 3Dh FFh
TAMBAHKAN (02j),(03j),(04j) 08h 6Ch 02h 03h 04h
BERHENTI 0Ch 01 jam 01 jam
Hasil yang diharapkan: RAM(04h) = 00h, ZF = 1, CO = 1.
6. Mengikuti kriteria yang sama seperti pada latihan sebelumnya, tentukan:

program mikro yang terkait dengan instruksi yang tercantum dalam tabel berikut:
dan dialokasikan pada alamat yang ditunjukkan.
mnemonik Alamat
SUB (<alamat1>),(<alamat2>),(<alamat3>) 71j

DAN (<alamat1>),(<alamat2>),(<alamat3>) 76j
ATAU (<alamat1>),(<alamat2>),(<alamat3>) 7Bh
Kami menyarankan untuk menguji solusi Anda dengan program pengujian berikut.

SUB (02j),(03j),(04j) 08h 71j 02h 03h 04h

Hasil yang diharapkan: RAM(04h) = FFh, CO = 1.

LD A,FFh 00h 3Dh FFh
LD A,55j 04 jam 3Dh 55j
DAN (02j),(03j),(04j) 08h 76 jam 02 jam 03 jam 04 jam

LD A,55j 04 jam 3Dh 55j
ATAU (02j),(03j),(04j) 08h 7Bh 02h 03h 04h

7. Kode mnemonik berikut mewakili instruksi yang bergeser ke kanan:

konten lokasi memori <address> dan menyisipkan nol di
kiri.
SRL (<alamat>)
Tentukan program mikro yang terkait dengan instruksi tersebut pada memori ad
dress 80h. Dalam memori program, kode mesin instruksi (80h)
diikuti oleh <alamat>. Hanya akumulator yang dapat menggeser ke kanan
konten sehingga nilai sebelumnya akan ditimpa. Kami menyarankan menggunakan
program berikut untuk menguji solusi Anda.

SRL (02j) 04 jam 80j 02h
Hasil yang diharapkan: RAM(02h) = 00h, ZF = 1.

1.7 Latihan 95
8. Kode mnemonic berikut mewakili instruksi yang menggeser ke kiri

konten lokasi memori yang ditunjukkan oleh <address> dan menyisipkan nol
di sebelah kanan.
SLL (<alamat>)
Tentukan program mikro yang terkait dengan instruksi itu di memori ad dress 85h.
Dalam memori program, kode mesin instruksi (85h) adalah:
diikuti oleh <alamat>. Hanya akumulator yang dapat menggeser kontennya ke kiri
jadi nilai sebelumnya akan ditimpa. Kami menyarankan menggunakan yang berikut ini:
program untuk menguji solusi Anda.

LD A,80j 00h 3Dh 80j
SLL (02j) 04 jam 85j 02h
Hasil yang diharapkan: RAM(02h) = 00h, ZF = 1.

1.8 Solusi
1.8.1 Jaringan komputasi khusus
1.
Mengalikan dengan tiga sama dengan
menjumlahkan bilangan yang sama sebanyak
tiga kali. Dalam basis sepuluh, bilangan 6-bit
tertinggi yang dapat diekspresikan adalah 26 1 =
63. Jadi, jumlah bit terendah yang diperlukan
untuk menyatakan hasilnya adalah dlog2 (63 · 3)e = 8.
2.
Setelah menambahkan A dan B, kita

geser ke kanan hasilnya satu bit dan kita
tambahkan ke konstanta 5.
1.8 Solusi 97
3.
Mari kita menggeser operan
A, B dan C sebelumnya
menambahkan mereka. Pergeseran
diperlukan untuk membagi
mereka dengan jumlah
ditugaskan.
4. a) Menghitung ekspresi 3 · (OP0) + 2 · (OP3).
Dalam keadaan (a), OP0 ditambahkan ke konten akumulator

(nol). Dengan kata lain, OP0 diimpor ke
akumulator.
Di negara bagian (b) dan (c), OP0 ditambahkan lagi ke konten

akumulator, menghasilkan 3 · (OP0).
Di negara bagian (d) dan (e), OP3 ditambahkan dua kali ke

konten akumulator, memberi kita perhitungan
ekspresi yang diminta.
Akhirnya dalam keadaan (f), jaringan dihentikan. Untuk melakukan

perhitungan baru, jaringan harus direset.
b) Perhitungan ekspresi 3/2 · (OP1) + 3 · (OP2).
Dalam keadaan (a), OP1 ditambahkan ke konten

akumulator (nol). Dengan kata lain, OP1 diimpor ke
akumulator.
Di negara bagian (b) dan (c) OP1 ditambahkan lagi ke

konten akumulator, menghasilkan 3 · (OP1).
Dalam keadaan (d) akumulator diperintahkan untuk bergeser ke kanan,

memberi kami 3/2 ·(OP1). Ingat bahwa operasi shift
menyisipkan nol di sebelah kiri.
Pada keadaan (e), (f) dan (g) OP2 ditambahkan tiga kali ke
isi akumulator, memberi kita perhitungan ekspresi yang
diminta.
Dalam keadaan (h) jaringan dihentikan. Untuk mengeksekusi yang baru

perhitungan, jaringan harus direset.
5. a) Perhitungan ekspresi 3 · (OP0) + 2 · (OP3).

Isi Alamat
Di alamat 00h, OP0 ditambahkan ke konten
00j 0000.0011 akumulator (nol). Dengan kata lain OP0
01h 0000.0011 diimpor ke akumulator. Selanjutnya
02 jam 0000.0011 dua lokasi, OP0 ditambahkan lagi ke isi akumulator,
03 jam 1100.0011 memberi kita 3 · (OP0).
04 jam 1100.0011 Di lokasi 03h dan 04h, OP3 ditambahkan dua kali
05 jam 00100000 ke konten akumulator, memberi kami
perhitungan ekspresi itu
panggilan untuk. Akhirnya, jaringan dihentikan di
lokasi ROM terakhir. Untuk menjalankan
perhitungan baru, jaringan harus direset.
b) Menghitung ekspresi 3/2 · (OP1) + 3 · (OP2).

Pada alamat 00h, OP1 ditambahkan ke konten akumulator, yang
memiliki nilai 00h setelah reset (lihat tabel berikut). Di alamat
01h dan 02h, OP1 ditambahkan lagi ke konten akumulator,
memberi kami 3 · (OP1).
1.8 Solusi 99
Isi Alamat Pada jam 03 akumulator diperintahkan ke kanan

00 jam 0100.0011 shift, memberi kita 3/2 · (OP1). Ingat itu
01 jam 0100.0011 operasi shift menyisipkan nol di sebelah kiri.
02 jam 0100.0011 Dari alamat 04h ke 06h, OP2 ditambahkan ke
03 jam 0000.0001 isi akumulator tiga kali, memberi kita perhitungan
04 jam 1000.0011 ekspresi bahwa
dipanggil untuk. Di lokasi 07h jaringan
05 jam 1000.0011
dihentikan. Untuk menjalankan perhitungan baru, kita
06 jam 1000.0011
harus mengatur ulang jaringan.
07 jam 00100000
6. Fungsi logika EXOR disebut juga “fungsi ganjil” karena

menghasilkan 1 hanya jika jumlah 1 pada input ganjil.
Didapatkan : P = F7 F6 F5 F4 F3 F2 F1 F0 . _ _ _
7. Dengan menganalisis tabel Bendera di bawah ini, (juga tersedia di Halaman 21), kita dapat
dapatkan jaringan yang terlihat di sebelah kanan.
Bendera
Hasil CO ZF
A=B0 1
A>B00
A<B10
1.8.2 Jaringan komputasi yang dapat diprogram
1. Berikut ini adalah solusi yang dinyatakan dalam kode mnemonik dan
kode mesin.
a) Menghitung ekspresi: NOT [(OP2) AND (OP3) OR (OP1)]

DI DALAM
A,OP2 00h 9Fh
DAN A,OP3 01h CBh

ATAU A,OP1 02h 4Fh
BUKAN 03j 13 jam
BERHENTI 04 jam 20j
b) Menghitung ekspresi: 3/2 · (OP2) + (OP1)

DI DALAM
A,OP2 00h 9Fh
TAMBAHKAN A,OP2 01h 83 jam
SRL A 03 jam 01 jam
BERHENTI 05 jam 20j

1.8 Solusi 101
c) Menghitung ekspresi: 1/4·[(OP0)+2·(OP1)ÿ(OP2)+3/2·(OP3)]

DI DALAM
A,OP3 00h DFh
TAMBAHKAN A,OP3 01j C3h
TAMBAHKAN A,OP3 02h C3h
SRL A 03h 01 jam
SUB A,OP2 04h 87 jam
SRL A 08h 01 jam
SRL A 09 jam 01 jam
BERHENTI 0Ah 20j
kode mesin.
a) Di sini, kami menganggap kami memiliki 0Eh konstan yang tersedia di port input OP0.
Instruksi NOP tidak mengambil tindakan tetapi menambahkan penundaan, dan kita dapat menambahkan
lebih dari satu. Ini adalah cara untuk mengatur periode gelombang
dihasilkan.
Label mnemonik Alamat Kode mesin
MULAI: DI A,OP0 00h 1Ch

SHIFT: SRL A 01 jam 20j
JP NZ, SHIFT 02j 26 jam 01 jam
TIDAK 04 jam 00h

b) Asumsikan bahwa kita memiliki 01h konstan yang tersedia di port input OP1.
DI A,OP0 00h 1Ch
PERIKSA: CP A,OP2 01 jam 32 jam
JP Z,PERIKSA 02h 24 jam 07 jam
termasuk: TAMBAHKAN A,OP1 04h 05 jam
JP CHECKH 05 jam 22 jam 01 jam
PERIKSA: CP A,OP0 07 jam 30 jam
JP Z,PERIKSA 08h 24 jam 01 jam
DES: SUB A,OP1 0Ah 09h

JP PERIKSA 0Bh 22 jam 07 jam
kode mesin.
a) Asumsikan kita memiliki konstanta 01h yang tersedia pada port input OP1 dan konstanta
0Eh pada port input OP0.

MULAI: IN A,OP0 00j 1Ch
LOOP: OUT PORT0,A 01h 02h 34 jam
SRL A 20j
TAMBAHKAN A,OP1 04 jam 05 jam
TAMBAHKAN A,OP1 07 jam 05 jam
JP NZ,LOOP 08h 26 jam 01 jam
JP MULAI 0Ah 22j 00h
b) Asumsikan kita memiliki 01h konstan yang tersedia di port input OP1, dan itu
kita tidak akan pernah memiliki nol di port input OP0, OP2 atau OP3.
MULAI: DI A,OPO 00h 1Ch
DI DALAM
A,OP3 02 jam 1Fh
PAUSE1: SUB A,OP1 03 jam 09 jam
JP NZ, PAUSE1 04j 26 jam 03 jam
DI DALAM
A,OP0 06 jam 1Ch
DES: SUB A,OP1 07 jam 09 jam
JP NZ, DES 09 jam 26 jam 07 jam
DI DALAM
A,OP2 0Bh 1Eh
PAUSE2: SUB A,OP1 0Ch 09h
JP NZ,PAUSE2 0Dh 26j 0Ch

termasuk: TAMBAHKAN A,OP1 05h 0Fh
CP A, OP0 10j 30 jam
JP NZ, INC 12 jam 26j 0Fh

1.8 Solusi 103
4. Kode mnemonic ada di sebelah kiri dan kode mesin ada di

Baik.
Label mnemonik Komentar Addr. Kode mesin
DI A,OP0 00j 1Ch
DES: SUB A,01j ;menunda 01 jam 42 jam 01 jam
JP NZ, DECR 03h 26h 01h
LAMPU: LD A,FFh ;LED hidup/mati 05j 3Dh FFh

OUT PORT0,A 0Bh 34h
OUT PORT1,A 0Ch 35h

LAMPU JP 0Dh 22j 05h
5. Karena ALU jaringan MP8E tidak dapat menghitung EXOR bitwise, ia memiliki
melakukannya dengan cara alternatif.
Operator EXOR dapat dinyatakan dalam AND dan OR, yang
dapat langsung dihitung oleh ALU di jaringan ini:
(A B) = A · B + A · B
Untuk menghitung ekspresi ini kita harus menggunakan variabel 8-bit untuk menghafal
hasil dari salah satu dari dua operasi AND (mari kita pesan lokasi RAM 00h
untuk tujuan). Hasil dari sisa AND dapat disimpan langsung di
akumulator, yang akan digunakan untuk menghitung OR dengan sebelumnya
hasil antara. Ini akan memberikan hasil yang diinginkan. Ingat itu
operan A dan B sebelumnya dihafal oleh program uji di
Lokasi RAM 01h dan 02h seperti yang disarankan dalam latihan:
Label Komentar Mnemonik Alamat Kode mesin
LD A,55j ;program uji 00j 3Dh 55h
LD A,Aah 04j 3Dh Aah
Hasil akhir disimpan di lokasi 00h.

Program dimulai dengan menghitung hasil antara pertama A · B,
membaca operan A dari memori RAM, meniadakannya dan menghitung
AND dengan operand B. Hasil dari urutan operasi disimpan
di lokasi 00h untuk memungkinkan menghitung perantara kedua
hasil.
LD A,(01j) ;solusi 08h 3Ah 01h

TIDAK A 0Ah 14 jam
AND A,(02h) ;(bukan A) dan B 0Bh 50j 02h
LD (00j),A ;hasil parsial dalam 00j 0Dh 38h 00h
Dengan mengikuti urutan operasi yang sama, kami menghitung yang kedua
antara hasil A · B, yang kemudian akan di-OR-kan dengan hasil sebelumnya
satu.
LD A,(02j) 0Fh 3Ah 02h

AND A,(01h) ;A dan (bukan B) 12 jam 50 jam 01 jam
ATAU A,(00j);ATAU antara dua istilah 14h 52h 00h
Akhirnya, hasil total ekspresi dihafal di lokasi memori

00h seperti yang diperintahkan dalam teks. Program diakhiri dengan memasukkan prosesor ke dalam
keadaan HALT.
LD (00h),A ;menghasilkan RAM 16h 38h 00h
kode mesin. Ini didahului oleh instruksi yang disarankan dalam teks.
Label Mnemonik Komentar Addr. Kode mesin
LD A,FFh ;program percobaan 00j 3Dh FFh
LD A,FFh 04j 3Dh FFh
LD (03j),A ;FFFFh angka pertama 06h 38h 03h

LD (04j),A 0Ah 38j 04h
LD A,00j ;0001j angka kedua 0Ch 3Dh 00h

LD (05j),A 0Eh 38j 05h
LD A,00j ;membawa variabel = 0 10j 3Dh 00h
LD A,(02j) 14 jam 3Ah 02 jam
TAMBAHKAN A,(04j) ;tambahkan byte 16j 4Ch 04h
LD (00j),A rendah, ;simpan hasil 18 jam 38 jam 00 jam
LD A,(03j) 1Ah 3Ah 03h
JP NC,NEXTB ;jika dibawa, tambah 1Ch 2Ah 2Ah
TAMBAHKAN A,01j ;byte berikutnya 1Eh 40j 01h
JP NC,NEXTB ;jika dibawa, simpan 20 jam 2Ah 2Ah

(lanjutan)
1.8 Solusi 105
LD (01j),A ;menghasilkan (01j) 22 jam 38 jam 01 jam
LD A,FFh ;mengatur variabel pembawa 24jam 3Dh FFh

LD A,(01j) ;A= hasil sebelumnya 28h 3Ah 01h

BERIKUTNYA: TAMBAHKAN A,(05 jam); tambahkan byte tinggi 2Ah 4Ch 05h
LD (01j),A ;hasil simpan 2Ch 38j 01j
JP NC, END 2Eh 2Ah 34j
LD A,FFh ;jika dibawa, 30 jam 3Dh FFh
LD (06j),A ;membawa variabel = 1 32j 38h 06h

AKHIR: BERHENTI 34j 01h 01h
7. Untuk solusi ini, kami memutuskan untuk menggunakan dua variabel: satu untuk menyimpan status
penghitung dan yang lainnya untuk menyimpan input yang kita baca. Setelah inisialisasi
status pencacah menjadi nol, masukan CK dievaluasi. Jika tidak
nol, kami melakukan evaluasi lagi dan menunggu nilainya menjadi satu.
Label Mnemonik Komentar Addr. Kode Mesin
RESET: LD A,00j 00j 3Dh 00h
LD (01j),A ; inisialisasi status 02j 38h 01h

MULAI: DI A,OP0 ;baca perintah 05j 1Ch
DAN A,00001000b ;cek CK 06h 44h 08h
JP NZ,MULAI ;menunggu CK = 0 08h 26h 05h
Setelah keluar dari loop, nilai CK adalah nol. Pada titik ini, kita memasuki
loop baru, dan tunggu nilainya menjadi satu. Kami meninggalkan loop hanya di
tepi naik CK.
CHECK1: DI A,OP0 0Ah 1Ch
LD (00j),A; hemat dalam 00j 0Bh 38h 00h
DAN A,00001000b ;cek CK 0Dh 44j 08h
JP Z,CHECK1 ;menunggu CK = 1 0Fh 24h 0Ah
Sekarang perintah dapat dievaluasi. Pertama mereka disimpan dalam variabel mereka
pada alamat memori RAM 00h, maka bit perintah dievaluasi satu
per satu sesuai dengan spesifikasi prioritas, melalui bitwise AND
masker.
Pertama, kami memeriksa apakah aktifkan diaktifkan, dan jika tidak, kami kembali untuk menunggu
untuk tepi naik CK berikutnya.
LD A,(00j) ;memuat ulang perintah 11h 3Ah 00h
DAN A,00000001b ;periksa nilai EN 13 jam 44 jam 01 jam
JP Z, MULAI 15 jam 24 jam 05 jam
Kemudian kami memeriksa input beban LD. Jika aktif, kita lompat ke LOAD
label, jika tidak, kita lanjutkan.
LD A,(00j) ;periksa nilai LD 17h 3Ah 00h
DAN A,00000100b 19 jam 44 jam 04 jam
JP NZ, LOAD 1Bh 26j 2Dh
Kami kemudian mengevaluasi input UP. Jika aktif, status penghitung

kenaikan; jika tidak, itu berkurang.
Dalam kedua kasus, kami melompat ke label UPDATE di mana status dan
keluaran diperbarui.
LD A,(00j) ;periksa nilai NAIK 1Dh 3Ah 00h
DAN 1.000.00010b 1Fh 44j 02h
LD A,(01j) ;dapatkan nilai status 21h 3Ah 01h
JP NZ, UP 23 jam 26 jam 29 jam
DN: SUB A,01j ;kurangi 25 jam 42 jam 01 jam
PEMBARUAN JP 27j 22h 2Eh
ATAS: TAMBAHKAN A,01j ;menaikkannya 29j 40h 01h
PEMBARUAN JP 2Bh 22h 2Eh
Jika penghitung telah diperintahkan untuk memuat, port OP1 diperoleh dan kami
terus perbarui status dan outputnya sehingga kita bisa mulai lagi
dari label MULAI.
LOAD: DI A,OP1 ;baca OP1 2Dh 1Dh
PEMBARUAN: LD (01j),A ;simpan dan salin 2Eh 38h 01h
OUT PORT0,A ;ke port 30 jam 34 jam
JP MULAI 31 jam 22 jam 05 jam

1.8 Solusi 107
1.8.3 Pemrograman mikro instruksi baru
1. Instruksi:
mnemonik Kode Mesin

LD (<alamat>),<const> 60j <const> <address>
Program mikronya:
ENPC LDMC J1 J2 J0 EFLG EO1 EO0 P1 S0 S1 F0 F1 F2 P0 Catatan KAMI
hex
60 jam 0 1 0 0 0 0 0 0 1 1 1 1 1 1 1 0 (a) +1 0 1 0 0 0 0 0 0 1 1 0 0
0 0 0 1 (b) +2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (c)
Catatan:
a) Konstanta berasal dari memori program (PC selalu menunjuk ke lokasi di

depan salah satu instruksi yang sedang dieksekusi). Ini berarti bahwa
jalur diatur untuk memuat konstanta dalam akumulator (P1P0 = '11'
untuk memilih memori program sebagai input B dari ALU; F2F1F0 = '111'
untuk menyalin input B dari ALU ke output; S1S0 = '11' untuk menyimpan
output ALU di akumulator). Juga, PC diperintahkan untuk bertambah.
b) Alamat lokasi di mana konstanta harus disimpan berasal dari memori

program. Jadi, jalur untuk memuat konten akumulator dalam sel memori
RAM yang ditunjukkan oleh memori program ditentukan (F2F1F0 = '110'
untuk menyalin input A dari ALU ke output; WE = '1' untuk mengurutkan
nomor di masukan RAM yang akan disimpan).
PC diperintahkan untuk naik untuk menunjuk ke instruksi berikutnya
untuk dieksekusi. Pada sisi positif jam berikutnya, memori RAM membaca
alamat dan nomor input ditulis di lokasi yang diinginkan.
c) PC diperintahkan untuk menambah dan MPC untuk memuat sehingga

instruksi berikutnya dapat dieksekusi.
2. Instruksi:
mnemonik Kode Mesin
CP (<alamat>),<const> 63h <const> <address>
Program mikronya:
hex
63h 0 1 0 0 0 0 0 0 1 1 1 1 1 1 1 0 (a) +1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
(b) +2 1 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 (c)
Catatan:
a) Konstanta berasal dari memori program (PC selalu menunjuk ke lokasi di

depan salah satu instruksi yang sedang dieksekusi). Ini berarti bahwa jalur
diatur untuk memuat konstanta dalam akumulator (P1P0 = '11' untuk
memilih memori program sebagai input B dari ALU; F2F1F0 = '111' untuk
menyalin input B dari ALU ke output; S1S0 = '11' untuk menyimpan output
ALU di akumulator). Juga, PC diperintahkan untuk bertambah.
b) Sekarang, alamat yang akan diakuisisi oleh RAM (yang sinkron) pada tepi
jam positif berikutnya berasal dari memori program. Hanya PC yang
diperintahkan untuk melakukan increment untuk menjaga pipeline tetap
aktif.
c) Sekarang alamat telah dibaca oleh RAM, jalur untuk membandingkan nilai
keluaran RAM dengan isi akumulator ditetapkan (P1P0 = '10' untuk memilih
memori RAM sebagai input B dari ALU; F2F1F0 = ' 001 untuk mengeksekusi
pengurangan AB; EFLAG = '1' untuk menyimpan flag baru).
Perhatikan bahwa hasil pengurangan tidak disimpan di akumulator. Satu-

satunya tujuan instruksi CP adalah mengubah flag untuk membandingkan
nilai dan melihat hubungan apa yang ada di antara mereka.
Juga, PC diperintahkan untuk menambah agar saluran pipa tetap aktif dan
MPC memuat untuk menjalankan instruksi berikutnya.
1.8 Solusi 109
3. Instruksi:
mnemonik Kode Mesin

CP (<address1>),(<address2>) 66j <addr.1> <addr.2>
Program mikronya:
hex
66j 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (a) +1 0 1 0 0 0 0 0 0 1 1 1 1 1 1
0 0 (b) +2 1 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 (c)
Catatan:
a) Alamat pertama berasal dari mikroprogram (PC selalu menunjuk ke lokasi

di depan salah satu instruksi yang sedang dieksekusi karena mekanisme
pipa), dan dibaca oleh memori RAM pada tepi positif berikutnya dari
jam . Kemudian, PC bertambah.
b) Sekarang, isi alamat pertama berasal dari memori RAM, yang berarti
bahwa jalur-jalur diatur untuk memuat konstanta di akumulator (P1P0 =
'10' untuk memilih keluaran memori RAM sebagai masukan ALU B;
F2F1F0 = '111' untuk menyalin input B dari ALU ke output; S1S0 = '11'
untuk memperbarui konten akumulator dengan nilai output ALU). PC
ditambahkan untuk mempertahankan pipa.
c) Sekarang, konten alamat kedua, yang dibaca pada tepi positif jam
sebelumnya, berasal dari memori RAM, jadi jalur untuk membandingkan
nilai keluaran RAM dengan konten akumulator diatur (P1P0 = ' 10' untuk
memilih keluaran memori RAM sebagai masukan ALU B; F2F1F0 = '001'
untuk mengurangi konten akumulator dari keluaran RAM; EFLG = '1'
untuk menyimpan tanda yang dihasilkan oleh pengurangan itu, satu-
satunya hasil yang menarik) . PC ditambahkan untuk memelihara pipa
dan MPC diperintahkan untuk memuat untuk menjalankan instruksi
berikutnya.
4. Instruksi:
mnemonik Kode Mesin

TAMBAHKAN (<address1>),(<address2>) 69j <addr.1> <addr.2>
Program mikronya:
hex
69 jam 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 0 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0
+2 1 1 0 0 0 1 0 0 0 0 0 1 1 1 0 0 (a)
Catatan:
a) Alasan di balik latihan ini mirip dengan yang sebelumnya, kecuali bahwa
instruksi mikro terakhir menyiapkan jalur untuk menambahkan nilai dari
RAM ke konten akumulator.
Kali ini hasil penambahan disimpan di akumulator (P1P0 = '10' untuk
memilih output memori RAM sebagai input ALU B; F2F1F0 = '000'
untuk menambahkan konten akumulator ke output RAM; EFLG = '1 '
untuk menyimpan flag yang dihasilkan oleh penambahan; S1S0 = '11'
untuk menyimpan hasilnya di akumulator).
5. Instruksi:
mnemonik Kode Mesin

TAMBAHKAN (<adr1>),(<adr2>),(<adr3>) 6Ch <adr1> <adr2> <adr3>
Program mikronya:
hex
6Ch 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (a) +1 0 1 0 0 0 0 0 0 1 1 1 1 1
100
+2 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 (b) +3 0 1 0 0 0 0 0 0 1 1 0 0 0
0 0 1 (c) +4 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (d)
1.8 Solusi 111
Catatan:
a) Instruksi mikro pertama dan kedua mengikuti penalaran yang sama

seperti pada dua latihan terakhir. Instruksi mikro pertama menambah
PC, menunggu <adr1> dibaca oleh memori program. Yang kedua
memuat nilai yang ditunjukkan oleh <adr1> di akumulator dan menambah
PC.
b) Alamat ketiga berasal dari memori program, tetapi alamat iklan terakhir
yang dibaca oleh RAM adalah yang kedua, jadi jalur untuk menambahkan
kontennya ke akumulator telah ditetapkan. Hasilnya disimpan di
akumulator (P1P0 = '10' untuk memilih output memori RAM sebagai
input ALU B; F2F1F0 = '000' untuk menambahkan konten akumulator
ke output RAM; S1S0 = '11' untuk menyimpan hasilnya penambahan
akumulator).
c) Sekarang hasilnya sudah siap di akumulator, jalur diatur untuk

membawanya ke lokasi memori yang ditunjukkan oleh alamat ketiga,
yang terakhir dibaca oleh RAM (F2F1F0 = '110' untuk menyalin nilai
akumulator ke output ALU; WE = '1' untuk menyimpan output ALU di
sel memori yang ditunjuk oleh alamat ketiga). PC ditambahkan untuk
mempertahankan pipa.
d) PC ditambahkan untuk menjaga pipa tetap aktif dan MPC adalah

diperintahkan untuk memuat untuk menjalankan instruksi berikutnya.
6. Instruksi:
mnemonik Kode Mesin

SUB (<adr1>),(<adr2>),(<adr3>) 71j <adr1> <adr2> <adr3>
Program mikronya:
hex
71j 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 0 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0
+2 0 0 0 0 0 1 0 0 0 0 1 1 1 1 0 0 (a) +3 0 1 0 0 0 0 0 0 1 1 0 0 0
001
+4 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Intruksi:
mnemonik Kode Mesin

DAN (<adr1>),(<adr2>),(<adr3>) 76j <adr1> <adr2> <adr3>
Program mikronya:
DAN (<alamat1>),(<alamat2>),(<alamat3>)
hex
76j 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 0 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0
+2 0 0 0 0 0 1 0 0 0 1 0 1 1 1 0 0 (a)
+3 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1
+4 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Intruksi:
mnemonik Kode Mesin

ATAU (<adr1>),(<adr2>),(<adr3>) 7Bh <adr1> <adr2> <adr3>
Program mikronya:
hex
7Bh 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 0 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0
+2 0 0 0 0 0 1 0 0 0 1 1 1 1 1 0 0 (a)
+3 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1
+4 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Catatan (untuk ketiga program

mikro): a) Alasan di balik latihan ini mirip dengan alasan sebelumnya.
Ketiga mikroprogram adalah identik, kecuali untuk instruksi mikro
ketiga yang mengeksekusi operasi yang diperlukan (pengurangan
jika F2F1F0 = '001', bitwise AND jika F2F1F0 = '010' atau bitwise
OR jika F2F1F0 = '011').
1.8 Solusi 113
7. Instruksi:
mnemonik Kode Mesin

SRL (<alamat>) 80j <alamat>
Program mikronya:

hex
80 jam 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (a) +1 0 0 0 0 0 0 0 0 1 1 1 1
1 1 0 0 (b) +2 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 (c) +3 0 1 0 0 0 1 0 0
1 1 0 0 0 0 0 1 (d) +4 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 (e)
Catatan:
a) Memori RAM membaca alamat keluaran memori program di tepi jam

berikutnya. Kita harus membiarkan satu siklus berlalu tanpa mengambil
tindakan. Karena hasilnya harus disimpan pada alamat yang sama, yang
berasal dari memori program, PC tidak diperintahkan untuk melakukan
increment sehingga alamat yang sama dikirim ke RAM.
b) Jalur diatur untuk menyimpan output RAM di akumulator (P1P0 = '10'

untuk memilih RAM sebagai input ALU B; F2F1F0 = '111' untuk menyalin
input B dalam output ALU; S1S0 = '11' untuk menyimpan keluaran ALU
di akumulator).
c) Ini memerintahkan akumulator untuk menggeser ke kanan (S1S0 = '01').
d) Jalur diatur untuk memuat konten akumulator di lokasi RAM yang

ditunjukkan oleh alamat keluaran memori program (F2F1F0 = '110' untuk
menyalin konten akumulator ke keluaran ALU; EFLG = '1' untuk
memperbarui register flag; WE = '1' untuk menyimpan output ALU di
lokasi memori RAM yang ditunjukkan oleh <address>).
Register flag diaktifkan untuk mengevaluasi akumulator dan PC
diperintahkan untuk naik, untuk menunjuk ke instruksi berikutnya.
e) MPC diperintahkan untuk memuat instruksi berikutnya dan PC dinaikkan

untuk menjaga pipa tetap aktif.
8. Instruksi:
mnemonik Kode Mesin

SLL (<alamat>) 85j <alamat>
Program mikronya:
hex
85j 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0
+2 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 (a) +3 0 1 0 0 0 1 0 0 1 1 0 0 0
001
+4 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Catatan:
a) Di sini, alasan yang sama diterapkan seperti pada latihan sebelumnya,

kecuali bahwa instruksi mikro ketiga memerintahkan shift kiri (S1S0 = '10').

Introduction To Microprocessor-Based Systems Design - Removed

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Introduction To Microprocessor-Based Systems Design - Removed

Diunggah oleh

Hak Cipta:

Format Tersedia

Machine Translated by Google

Kata Pengantar Prof. Donatella Sciuto .......................... VII

Kata Pengantar Penulis ................................................... XI

Isi Digital Buku. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XVII

1 Pengantar jaringan komputasi yang dapat diprogram. . . . . . . .

1.3.3 Sequencer yang diprogram mikro dan komputasinya

Pengantar jaringan komputasi yang dapat

1.1 Pengantar umum untuk mikroprosesor

© Penulis, di bawah lisensi eksklusif untuk Springer Nature Switzerland AG 1

2 1 Pengantar jaringan komputasi yang dapat diprogram

1.1.1 Sejarah singkat mikroprosesor

Produksi mikroprosesor dimungkinkan saat ini karena pengembangan teknologi

1.1 Pengantar umum untuk mikroprosesor 3

1.1.2 Jenis mikrokomputer

Mikroprosesor dan mikrokomputer tidaklah sama. Sederhananya, prosesor mikro, juga

1.1.3 Mikrokomputer dan sistem

• memperoleh data eksternal

4 1 Pengantar jaringan komputasi yang dapat diprogram

Sebuah kontrol mikrokomputer, bagaimanapun, memiliki banyak keuntungan;

1.1.4 Struktur dasar komputer generik

1.1 Pengantar umum untuk mikroprosesor 5

6 1 Pengantar jaringan komputasi yang dapat diprogram

Sebuah mesin Von Neumann didasarkan pada kriteria dasar berikut:

— hanya ada satu unit pemrosesan (CPU) — hanya

1.1.5 Koneksi bus umum

1.1 Pengantar umum untuk mikroprosesor 7

Jenis sambungan ini digunakan terutama karena ekonomis dan modular.

8 1 Pengantar jaringan komputasi yang dapat diprogram

1.2 Desain jaringan komputasi yang dapat diprogram 9

1.2 Desain jaringan komputasi yang dapat diprogram

1.2.1 Spesifikasi desain: jaringan komputasi khusus

Mari kita bayangkan kita telah diminta untuk

1.2.1.1 Solusi kombinasi

Bayangkan rangkaian kombinasional murni yang menghitung rata-rata dengan terlebih

10 1 Pengantar jaringan komputasi yang dapat diprogram

1.2 Desain jaringan komputasi yang dapat diprogram 11

1.2.1.2 Solusi berurutan

12 1 Pengantar jaringan komputasi yang dapat diprogram

1.2 Desain jaringan komputasi yang dapat diprogram 13

0 0 Konten tidak berubah

14 1 Pengantar jaringan komputasi yang dapat diprogram

1.2 Desain jaringan komputasi yang dapat diprogram 15

1.2.1.3 Algoritma sequencer

Bagan Algorithmic State Machine (ASM) di sebelah kanan

Dalam keadaan (b) register diperintahkan (S1='1', S0='1')

Pada state (d), kita mempertahankan S1='1' dan S0='1',

Simulasi diagram waktu memungkinkan kita untuk memeriksa evolusi sinyal

16 1 Pengantar jaringan komputasi yang dapat diprogram

1.2.2 Penghitung dan sequencer berbasis memori ROM

1.2 Desain jaringan komputasi yang dapat diprogram 17

18 1 Pengantar jaringan komputasi yang dapat diprogram

1.2 Desain jaringan komputasi yang dapat diprogram 19

dan mengirimkan konten dari lokasi kedua, yang seharusnya berisi

Dengan mengikuti pendekatan ini, kami menyelesaikan pemrograman memori

Isi ROM FSM

0000001 01 jam 0 1 0 000 1 1

1.2.3 Memperluas kemungkinan komputasi

ini. Gambar di bawah ini menunjukkan hasil kami.

20 1 Pengantar jaringan komputasi yang dapat diprogram

1.2 Desain jaringan komputasi yang dapat diprogram 21

Dalam skema, kami menemukan komponen pelengkap di seberang penambah.

Kita dapat melakukan ini dengan menilai nilai bendera Bendera

setelah operasi. Lihat tabel di sebelah kanan. jika Hasil CO ZF