Mikrokontroller Raspberry Pi
DAFTAR ISI
Pengaplikasian
Mikrokontroller Raspberry Pi
- Merangkai dan menguji output pada mikrokontroller Raspberry Pi
- Merangkai dan menguji input pada mikrokontroller Raspberry Pi
- Merangkai dan menguji I/O pada mikrokontroller Raspberry Pi
- Raspberry Pi
- LED
- Seven Segment
- Buzzer
- LCD
- Jumper
- Motor stepper
- Sensor LM35
- Keypad
- Sensor Ultrasonic
- Dot matrix
A. Mikrokontroler Raspberry Pi
Raspberry Pi adalah komputer papan tunggal berbasis ARM cortex yang bekerja dengan daya rendah. Dengan kecepatan pemrosesan dan memori, Raspberry Pi dapat digunakan untuk menjalankan fungsi yang berbeda pada satu waktu, seperti PC biasa, dan karenanya disebut Mini Computer.Karena memiliki prosesor ARMv7, Raspberry Pi dapat menjalankan berbagai macam distribusi ARM GNU / Linux serta Microsoft Windows 10. Arsitektur ARM sangat berpengaruh pada elektronik modern.
Ada berbagai jenis papan Raspberry Pi di pasaran saat ini, dengan Raspberry Pi 2 Model B menjadi yang paling populer. Raspberry Pi 3 Model B juga telah diluncurkan; hampir mirip dengan RPi 2, dengan beberapa fitur advance seperti on board Wi-Fi dan konektivitas Bluetooth, CPU yang lebih kuat, dll.Raspbeery Pi memiliki empat port USB 2.0. Port ini dapat dihubungkan ke perangkat USB, seperti mouse dan keyboard.
MIkrokontroller Raspberry Pi
Kita akan membahas sedikit tentang Raspberry Pi GPIO
Ada 40 pin keluaran GPIO di Raspberry Pi 2. Tapi dari 40, hanya 26 pin GPIO (GPIO2 sampai GPIO27) yang bisa diprogram, lihat gambar di bawah ini. Beberapa pin ini melakukan beberapa fungsi khusus.
Fitur Raspberry Pi
B. LED
LED adalah suaatu semikonduktor yang memancarkan cahaya, LED mempunyai kecenderungan polarisasi. LED mempunyai kutub positif dan negatif (p-n) dan hanya akan menyala bila diberikan arus maju. Ini dikarenakan LED terbuat dari bahan semikonduktor yang hanya akan mengizinkan arus listrik mengalir ke satu arah dan tidak ke arah sebaliknya. Bila LED diberikan arus terbalik, hanya akan ada sedikit arus yang melewati LED. Ini menyebabkan LED tidak akan mengeluarkan emisi cahaya.
C. SEVENT SEGMENT
Layar tujuh segmen ini seringkali digunakan pada jam digital, meteran elektronik, dan perangkat elektronik lainnya yang menampilkan informasi numerik. Layar tujuh segmen ini terdiri dari 7 buah LED yang membentuk angka 8 dan 1 LED untuk titik/DP. Angka yang ditampilkan di seven segmen ini dari 0-9. Cara kerja dari seven segmen disesuaikan dengan LED. LED merupakan komponen diode yang dapat memancarkan cahaya. kondisi dalam keadaan ON jika sisi anode mendapatkan sumber positif dari Vcc dan katode mendapatkan sumber negatif dari ground.
D. BUZZER
Buzzer adalah sebuah komponen elektronika yang berfungsi untuk mengubah getaran listrik menjadi getaran suara. Pada dasarnya prinsip kerja buzzer hampir sama dengan loud speaker, jadi buzzer juga terdiri dari kumparan yang terpasang pada diafragma dan kemudian kumparan tersebut dialiri arus sehingga menjadi elektromagnet, kumparan tadi akan tertarik ke dalam atau keluar, tergantung dari arah arus dan polaritas magnetnya, karena kumparan dipasang pada diafragma maka setiap gerakan kumparan akan menggerakkan diafragma secara bolak-balik sehingga membuat udara bergetar yang akan menghasilkan suara. Buzzer biasa digunakan sebagai indikator bahwa proses telah selesai atau terjadi suatu kesalahan pada sebuah alat (alarm)
E. LCD
berikut penjelasan kakinya yaitu:
F. JUMPER
Sebagai konektor antar modul satu dengan modul lainnya
G. MOTOR STEPPER
(Motor stepper )mengubah pulsa-pulsa listrik yang diberikan menjadi gerakan-gerakan diskrit rotor yang disebut langkah (steps). Nilai rating dari suatu motor stepper diberikan dalam langkah per putaran (steps per revolution). Motor stepper umumnya mempunyai kecepatan dan [torsi] yang rendah.
Motor stepper bekerja berdasarkan pulsa-pulsa yang diberikan pada lilitan fasenya dalam urut-urutan yang tepat. Selain itu, pulsa-pulsa itu harus juga menyediakan arus yang cukup besar pada lilitan fase tersebut. Karena itu untuk pengoperasian motor stepper pertama-tama harus mendesain suatu sequencer logic untuk menentukan urutan pencatuan lilitan fase motor dan kemudian menggunkan suatu penggerak (driver) untuk menyediakan arus yang dibutuhkan oleh lilitan fase
H. SENSOR LM35
Sensor suhu IC LM 35 merupkan chip IC produksi Natioanal Semiconductor yang berfungsi untuk mengetahui temperature suatu objek atau ruangan dalam bentuk besaran elektrik, atau dapat juga di definisikan sebagai komponen elektronika yang berfungsi untuk mengubah perubahan temperature yang diterima dalam perubahan besaran elektrik.
I. KEYPAD
Penyusun tombol pada keypad dapat dibuat dari bermacam-macam bahan/komponen, seperti switch metal, switch karbon, dan resistif/kapasitif (touch panel). Penggunaan bahan tersebut disesuaikan dengan kebutuhan akan sensifitas, aksi penekanan, dan kebutuhan akan suatu tombol khusus. Bahan switch metal pada keypad digunakan untuk kebutuhan keypad atau tombol-tombol dengan arus yang besar. Keypad dengan bahan carbon dipakai untuk kebutuhan tombol-tombol dengan arus kecil. Biasanya itu digunakan untuk alat-alat digital yang hanya memilikitegangan 0 dan 5v. Penerapan bahan banyak kita jumpai seperti pada keypad remot tv, remot ac, joy stick, serta masih banyak lainnya.
J. SENSOR ULTRASONIC
Sensor ultrasonik PING terdiri dari tiga bagian utama yaitu :
- Transmitter Gelombang Ultrasonik
- Receiver Gelombang Ultrasonik
- Rangkaian kontrol
Transmitter berfungsi sebagai pemancar gelombang ultrasonik. Gelombang yang dipancarkan memiliki frekuensi 40KHz. Gelombang ini akan dipancarakan dengan kecepatan 344.424m/detik atau 29.034uS per centimeter. Jika didepan terdapat halangan atau objek maka gelombang tersebut akan memantul. Pantulan gelombang akan dideteksi oleh receiver. Rangkaian kontrol akan mendeteksi pantulan gelombang dan menghitung lama waktu saat gelombang dipancarkan dan gelombang terdeteksi pantulannya. Lama waktu pemantulan gelombang ini akan dikonversi menjadi sinyal digital dalam bentuk pulsa. Sinyal inilah yang nantinya diolah oleh mikrokontroler atau mikroprosesor sehingga didapat nilai jarak antara objek dan sensor. Nilai jarak dapat diperoleh melalui rumus berikut ini :
Jarak (cm) = Lama Waktu Pantul (uS) / 29.034 / 2
Rumus jarak didapat dari pembagian lama waktu pantul dengan kecepatan gelombang ultrasonik dan dibagi 2 karena pada saat pemantulan terjadi dua kali jarak tempuh antara sensor dengan objek. Yaitu pada saat gelombang dipancarkan dari transmitter ke objek dan pada saat gelombang memantul ke receiver ultrasonik.
K. DOT MATRIX
Dot matrix adalah susunan titik-titik dua dimensi yang digunakan untuk menampilkan karakter-karakter, simbol atau gambar. Dahulu dot matrix digunakan pada printer-printer tua dan banyak perangkat tampilan digital. Pada printer, titik-titik tersebut adalah daerah yang diredupkan. Sedangkan pada display, titik-titik tersebut adalah daerah yang bercahaya. Sebagaimana pada LED atau CRT display cara kerjanya titik-titik yang sebelumnya mati, bercahaya sesuai sesuai obyek yang diinginkan./div>
Dot matrix banyak digunakan untuk menampilkan informasi pada mesin-mesin, jam, indikator keberangkatan kereta api dan perangkat lainnya yang membutuhkan display sederhana untuk resolusi yang terbatas. Display ini terdiri dari LED yang tersusun secara matrix berbentuk segi empat (bentuk selain segi empat juga ada) sehingga dengan menyalakan/mematikan lampu yang diinginkan, teks atau grafik yang dapat ditampilkan. Pengendali dot matrix mengkonversi instruksi dari decoder ke dalam sinyal elektris yang dapat menyalakan atau mematikan lampu sehingga tampilan yang diinginkan dapat terjadi.
4. Percobaan
[kembali]
4.1 Led dan Switch
[kembali]
Rangkaian
flowchart
Pengaplikasian
Kodingan di python
import RPi.GPIO as IO # memanggil file header(library) untuk GPIO dari RPI3
import time # memanggil waktu untuk delay pada program
IO.setmode (IO.BOARD) # memprogram GPIO dengan nomor pin pada papan RPI3, GPIO21 disebut pin40
IO.setup(40,IO.OUT) # menginisialisasi pin40 sebagai output
IO.output(40,1) # perintah menghidupkan LED (dengan membuat tegangan aktif HIGH)
time.sleep(1) # delay sebesar 1 detik
IO.cleanup() # perintah mematikan LED (dengan membuat tegangan aktif LOW)
time.sleep(1) #delay sebesar 1 detik
import time # memanggil waktu untuk delay pada program
IO.setmode (IO.BOARD) # memprogram GPIO dengan nomor pin pada papan RPI3, GPIO21 disebut pin40
IO.setup(40,IO.OUT) # menginisialisasi pin40 sebagai output
IO.output(40,1) # perintah menghidupkan LED (dengan membuat tegangan aktif HIGH)
time.sleep(1) # delay sebesar 1 detik
IO.cleanup() # perintah mematikan LED (dengan membuat tegangan aktif LOW)
time.sleep(1) #delay sebesar 1 detik
Kodingan di python
Video Percobaan
4.2. Seven Segment
[kembali]
Rangkaian Dalam Seven Segment
Rangkaian Skematic
Flowchart
Foto Pengaplikasian
Kodingan Pengaplikasian
import RPi.GPIO as IO # memanggil header GPIO pada PI
import time # deklarasi waktu delay
DISPLAY = [0xFC,0x0C,0xD2,0x9E,0x2E,0xB5,0xF5,0x1C,0xFE,0xBE] #memunculkan ouput pin dengan bilangan hexsa dari 0-9
IO.setwarnings(False) # tidak memunculkan peringatan yang lain selain pada display
IO.setmode (IO.BCM) # memprogram GPIO dengan pin BCM
IO.setup(13,IO.OUT) # inisialisasi pin 13 sebagai output
IO.setup(6,IO.OUT) # inisialisasi pin 6 sebagai output
IO.setup(16,IO.OUT) # inisialisasi pin 16 sebagai output
IO.setup(20,IO.OUT) # inisialisasi pin 20 sebagai output
IO.setup(21,IO.OUT) # inisialisasi pin 21 sebagai output
IO.setup(19,IO.OUT) # inisialisasi pin 19 sebagai output
IO.setup(26,IO.OUT) # inisialisasi pin 26 sebagai output
def PORT(pin): # memberi kondisi level pada setiap pin
if(pin&0x02 == 0x02): # jika bit 1 dari 8 bit
IO.output(26,1) # jika pin bernila 1 maka PIN26 HIGH
else:
IO.output(26,0) # jika pin bernila 0 maka PIN26 LOW
if(pin&0x04 == 0x04): # jika bit 2 dari 8 bit
IO.output(19,1) # jika pin bernila 1 maka PIN19 HIGH
else:
IO.output(19,0) # jika pin bernila 0 maka PIN19 LOW
if(pin&0x08 == 0x08): # jika bit 3 dari 8 bit
IO.output(21,1) # jika pin bernila 1 maka PIN21 HIGH
else:
IO.output(21,0) # jika pin bernila 0 maka PIN21 LOW
if(pin&0x10 == 0x10): # jika bit 4 dari 8 bit
IO.output(20,1) # jika pin bernila 1 maka PIN20 HIGH
else:
IO.output(20,0) # jika pin bernila 0 maka PIN20 LOW
if(pin&0x20 == 0x20): # jika bit 5 dari 8 bit
IO.output(16,1) # jika pin bernila 1 maka PIN16 HIGH
else:
IO.output(16,0) # jika pin bernila 0 maka PIN16 LOW
if(pin&0x40 == 0x40): # jika bit 6 dari 8 bit
IO.output(6,1) # jika pin bernila 1 maka PIN6 HIGH
else:
IO.output(6,0) # jika pin bernila 0 maka PIN6 LOW
if(pin&0x80 == 0x80): # jika bit 7 dari 8 bit
IO.output(13,1) # jika pin bernila 1 maka PIN13 HIGH
else:
IO.output(13,0) # jika pin bernila 0 maka PIN13 LOW
while 1:
for x in range(10): #mengeksekusi perulangan dengan range 10 yaitu dari 0-9
pin = DISPLAY[x] #memberi kondisi level pin dengan nilai yang telah dideklarasikan pada display
PORT(pin): #menampilkan digit
time.sleep(1) #delay 1 detik
import time # deklarasi waktu delay
DISPLAY = [0xFC,0x0C,0xD2,0x9E,0x2E,0xB5,0xF5,0x1C,0xFE,0xBE] #memunculkan ouput pin dengan bilangan hexsa dari 0-9
IO.setwarnings(False) # tidak memunculkan peringatan yang lain selain pada display
IO.setmode (IO.BCM) # memprogram GPIO dengan pin BCM
IO.setup(13,IO.OUT) # inisialisasi pin 13 sebagai output
IO.setup(6,IO.OUT) # inisialisasi pin 6 sebagai output
IO.setup(16,IO.OUT) # inisialisasi pin 16 sebagai output
IO.setup(20,IO.OUT) # inisialisasi pin 20 sebagai output
IO.setup(21,IO.OUT) # inisialisasi pin 21 sebagai output
IO.setup(19,IO.OUT) # inisialisasi pin 19 sebagai output
IO.setup(26,IO.OUT) # inisialisasi pin 26 sebagai output
def PORT(pin): # memberi kondisi level pada setiap pin
if(pin&0x02 == 0x02): # jika bit 1 dari 8 bit
IO.output(26,1) # jika pin bernila 1 maka PIN26 HIGH
else:
IO.output(26,0) # jika pin bernila 0 maka PIN26 LOW
if(pin&0x04 == 0x04): # jika bit 2 dari 8 bit
IO.output(19,1) # jika pin bernila 1 maka PIN19 HIGH
else:
IO.output(19,0) # jika pin bernila 0 maka PIN19 LOW
if(pin&0x08 == 0x08): # jika bit 3 dari 8 bit
IO.output(21,1) # jika pin bernila 1 maka PIN21 HIGH
else:
IO.output(21,0) # jika pin bernila 0 maka PIN21 LOW
if(pin&0x10 == 0x10): # jika bit 4 dari 8 bit
IO.output(20,1) # jika pin bernila 1 maka PIN20 HIGH
else:
IO.output(20,0) # jika pin bernila 0 maka PIN20 LOW
if(pin&0x20 == 0x20): # jika bit 5 dari 8 bit
IO.output(16,1) # jika pin bernila 1 maka PIN16 HIGH
else:
IO.output(16,0) # jika pin bernila 0 maka PIN16 LOW
if(pin&0x40 == 0x40): # jika bit 6 dari 8 bit
IO.output(6,1) # jika pin bernila 1 maka PIN6 HIGH
else:
IO.output(6,0) # jika pin bernila 0 maka PIN6 LOW
if(pin&0x80 == 0x80): # jika bit 7 dari 8 bit
IO.output(13,1) # jika pin bernila 1 maka PIN13 HIGH
else:
IO.output(13,0) # jika pin bernila 0 maka PIN13 LOW
while 1:
for x in range(10): #mengeksekusi perulangan dengan range 10 yaitu dari 0-9
pin = DISPLAY[x] #memberi kondisi level pin dengan nilai yang telah dideklarasikan pada display
PORT(pin): #menampilkan digit
time.sleep(1) #delay 1 detik
Video Pengaplikasian
4.3. LCD
[kembali]
Foto Pengaplikasian
Foto Skematic
Flowchart
Kodingan Program
import RPi.GPIO as IO # memangil library GPIO pada RPI3
import time # deklarasi waktu delay
import sys #deklarasi library lcd
IO.setwarnings(False) # tidak menampilkan keluaran yang tidak diinginkan
IO.setmode (IO.BCM) # memprogram GPIO dengan pin BCM
IO.setup(6,IO.OUT) # inisialisasi GPIO Pin 6 sebagai output
IO.setup(22,IO.OUT) # inisialisasi GPIO Pin 22 sebagai output
IO.setup(21,IO.OUT) # inisialisasi GPIO Pin 21 sebagai output
IO.setup(20,IO.OUT) # inisialisasi GPIO Pin 20 sebagai output
IO.setup(16,IO.OUT) # inisialisasi GPIO Pin 16 sebagai output
IO.setup(12,IO.OUT) # inisialisasi GPIO Pin 12 sebagai output
IO.setup(25,IO.OUT) # inisialisasi GPIO Pin 25 sebagai output
IO.setup(24,IO.OUT) # inisialisasi GPIO Pin 24 sebagai output
IO.setup(23,IO.OUT) # inisialisasi GPIO Pin 23 sebagai output
IO.setup(18,IO.OUT) # inisialisasi GPIO Pin 18 sebagai output
def send_a_command (command): # mengeksekusi perulangan ketika deklarasi "sead_a_command" dipanggil
pin=command #pin samadengan command
PORT(pin): # memanggil PORT untuk memberikan nilai ke data port
IO.output(6,0) # menginputi 0 pada RS untuk memberitahu LCD(pin 6) bahwa command akan dikirim
IO.output(22,1) # memberitahu LCD untuk menerima command/data pada port dengan memberi nilai pin 22 high
time.sleep(0.05) #delay 50ms
IO.output(22,0) # memberi nilai LOW pada pin 22 untuk mengirimkan sinyal ke LCD bahwa data telah dikirim.
pin=0 #pin samadengan 0
PORT(pin): # memberi perintah ke port memberhentikan transmisi data
def send_a_character (character): # mengeksekusi perulangan ketika deklarasi "send_a_character" dipanggil
pin=character #pin samadengan character
PORT(pin): # memanggil PORT untuk memberikan nilai ke data port
IO.output(6,1) # menginputi 1 pada RS untuk memberitahu LCD(pin 6) bahwa command akan dikirim
IO.output(22,1) # memberitahu LCD untuk menerima command/data pada port dengan memberi nilai pin 22 high
time.sleep(0.05) #delay 50ms
IO.output(22,0) # memberi nilai LOW pada pin 22 untuk mengirimkan sinyal ke LCD bahwa data telah dikirim.
pin=0 #pin samadengan 0
PORT(pin): # memberi perintah ke port memberhentikan transmisi data
def PORT(pin): # mengeksekusi pin dengan memberi nilai pada port
if(pin&0x01 == 0x01): # jika bit 0 dari 8 bit
IO.output(21,1) # jika pin bernila 1 maka PIN21 HIGH
else:
IO.output(21,0) # jika pin bernila 0 maka PIN21 LOW
if(pin&0x02 == 0x02): # jika bit 1 dari 8 bit
IO.output(20,1) # jika pin bernila 1 maka PIN20 HIGH
else:
IO.output(20,0) # jika pin bernila 0 maka PIN20 LOW
if(pin&0x04 == 0x04): # jika bit 2 dari 8 bit
IO.output(16,1) # jika pin bernila 1 maka PIN16 HIGH
else:
IO.output(16,0) # jika pin bernila 0 maka PIN16 LOW
if(pin&0x08 == 0x08): # jika bit 3 dari 8 bit
IO.output(12,1) # jika pin bernila 1 maka PIN12 HIGH
else:
IO.output(12,0) # jika pin bernila 0 maka PIN12 LOW
if(pin&0x10 == 0x10): # jika bit 4 dari 8 bit
IO.output(25,1) # jika pin bernila 1 maka PIN25 HIGH
else:
IO.output(25,0) # jika pin bernila 0 maka PIN25 LOW
if(pin&0x20 == 0x20): # jika bit 5 dari 8 bit
IO.output(24,1) # jika pin bernila 1 maka PIN24 HIGH
else:
IO.output(24,0) # jika pin bernila 0 maka PIN24 LOW
if(pin&0x40 == 0x40): # jika bit 6 dari 8 bit
IO.output(23,1) # jika pin bernila 1 maka PIN23 HIGH
else:
IO.output(23,0) # jika pin bernila 0 maka PIN23 LOW
if(pin&0x80 == 0x80): # jika bit 7 dari 8 bit
IO.output(18,1) # jika pin bernila 1 maka PIN18 HIGH
else:
IO.output(18,0) # jika pin bernila 0 maka PIN18 LOW
while 1:
send_a_command(0x01): # sending 'all clear' command
send_a_command(0x38): # 16*2 line LCD
send_a_command(0x0E): # screen and cursor ON
send_a_character(0x43): # ASCII code for 'C'
send_a_character(0x49): # ASCII code for 'I'
send_a_character(0x52): # ASCII code for 'R'
send_a_character(0x43): # ASCII code for 'C'
send_a_character(0x55): # ASCII code for 'U'
send_a_character(0x49): # ASCII code for 'I'
send_a_character(0x54): # ASCII code for 'T'
# ASCII codes for "DIGEST"
send_a_character(0x44): # ASCII code for 'D'
send_a_character(0x49): # ASCII code for 'I'
send_a_character(0x47): # ASCII code for 'G'
send_a_character(0x45): # ASCII code for 'E'
send_a_character(0x53): # ASCII code for 'S'
send_a_character(0x54): # ASCII code for 'T'
time.sleep(1)
import time # deklarasi waktu delay
import sys #deklarasi library lcd
IO.setwarnings(False) # tidak menampilkan keluaran yang tidak diinginkan
IO.setmode (IO.BCM) # memprogram GPIO dengan pin BCM
IO.setup(6,IO.OUT) # inisialisasi GPIO Pin 6 sebagai output
IO.setup(22,IO.OUT) # inisialisasi GPIO Pin 22 sebagai output
IO.setup(21,IO.OUT) # inisialisasi GPIO Pin 21 sebagai output
IO.setup(20,IO.OUT) # inisialisasi GPIO Pin 20 sebagai output
IO.setup(16,IO.OUT) # inisialisasi GPIO Pin 16 sebagai output
IO.setup(12,IO.OUT) # inisialisasi GPIO Pin 12 sebagai output
IO.setup(25,IO.OUT) # inisialisasi GPIO Pin 25 sebagai output
IO.setup(24,IO.OUT) # inisialisasi GPIO Pin 24 sebagai output
IO.setup(23,IO.OUT) # inisialisasi GPIO Pin 23 sebagai output
IO.setup(18,IO.OUT) # inisialisasi GPIO Pin 18 sebagai output
def send_a_command (command): # mengeksekusi perulangan ketika deklarasi "sead_a_command" dipanggil
pin=command #pin samadengan command
PORT(pin): # memanggil PORT untuk memberikan nilai ke data port
IO.output(6,0) # menginputi 0 pada RS untuk memberitahu LCD(pin 6) bahwa command akan dikirim
IO.output(22,1) # memberitahu LCD untuk menerima command/data pada port dengan memberi nilai pin 22 high
time.sleep(0.05) #delay 50ms
IO.output(22,0) # memberi nilai LOW pada pin 22 untuk mengirimkan sinyal ke LCD bahwa data telah dikirim.
pin=0 #pin samadengan 0
PORT(pin): # memberi perintah ke port memberhentikan transmisi data
def send_a_character (character): # mengeksekusi perulangan ketika deklarasi "send_a_character" dipanggil
pin=character #pin samadengan character
PORT(pin): # memanggil PORT untuk memberikan nilai ke data port
IO.output(6,1) # menginputi 1 pada RS untuk memberitahu LCD(pin 6) bahwa command akan dikirim
IO.output(22,1) # memberitahu LCD untuk menerima command/data pada port dengan memberi nilai pin 22 high
time.sleep(0.05) #delay 50ms
IO.output(22,0) # memberi nilai LOW pada pin 22 untuk mengirimkan sinyal ke LCD bahwa data telah dikirim.
pin=0 #pin samadengan 0
PORT(pin): # memberi perintah ke port memberhentikan transmisi data
def PORT(pin): # mengeksekusi pin dengan memberi nilai pada port
if(pin&0x01 == 0x01): # jika bit 0 dari 8 bit
IO.output(21,1) # jika pin bernila 1 maka PIN21 HIGH
else:
IO.output(21,0) # jika pin bernila 0 maka PIN21 LOW
if(pin&0x02 == 0x02): # jika bit 1 dari 8 bit
IO.output(20,1) # jika pin bernila 1 maka PIN20 HIGH
else:
IO.output(20,0) # jika pin bernila 0 maka PIN20 LOW
if(pin&0x04 == 0x04): # jika bit 2 dari 8 bit
IO.output(16,1) # jika pin bernila 1 maka PIN16 HIGH
else:
IO.output(16,0) # jika pin bernila 0 maka PIN16 LOW
if(pin&0x08 == 0x08): # jika bit 3 dari 8 bit
IO.output(12,1) # jika pin bernila 1 maka PIN12 HIGH
else:
IO.output(12,0) # jika pin bernila 0 maka PIN12 LOW
if(pin&0x10 == 0x10): # jika bit 4 dari 8 bit
IO.output(25,1) # jika pin bernila 1 maka PIN25 HIGH
else:
IO.output(25,0) # jika pin bernila 0 maka PIN25 LOW
if(pin&0x20 == 0x20): # jika bit 5 dari 8 bit
IO.output(24,1) # jika pin bernila 1 maka PIN24 HIGH
else:
IO.output(24,0) # jika pin bernila 0 maka PIN24 LOW
if(pin&0x40 == 0x40): # jika bit 6 dari 8 bit
IO.output(23,1) # jika pin bernila 1 maka PIN23 HIGH
else:
IO.output(23,0) # jika pin bernila 0 maka PIN23 LOW
if(pin&0x80 == 0x80): # jika bit 7 dari 8 bit
IO.output(18,1) # jika pin bernila 1 maka PIN18 HIGH
else:
IO.output(18,0) # jika pin bernila 0 maka PIN18 LOW
while 1:
send_a_command(0x01): # sending 'all clear' command
send_a_command(0x38): # 16*2 line LCD
send_a_command(0x0E): # screen and cursor ON
send_a_character(0x43): # ASCII code for 'C'
send_a_character(0x49): # ASCII code for 'I'
send_a_character(0x52): # ASCII code for 'R'
send_a_character(0x43): # ASCII code for 'C'
send_a_character(0x55): # ASCII code for 'U'
send_a_character(0x49): # ASCII code for 'I'
send_a_character(0x54): # ASCII code for 'T'
# ASCII codes for "DIGEST"
send_a_character(0x44): # ASCII code for 'D'
send_a_character(0x49): # ASCII code for 'I'
send_a_character(0x47): # ASCII code for 'G'
send_a_character(0x45): # ASCII code for 'E'
send_a_character(0x53): # ASCII code for 'S'
send_a_character(0x54): # ASCII code for 'T'
time.sleep(1)
Video Pengaplikasian
4.4. Dot matrik
[kembali]
Kodingan Program
Foto Pengaplikasian
Gambar Dot Matrik
Rangkaian Dalam Led Matrik
Rangkaian Skematik
Flowchart
Kodingan Program
import RPi.GPIO as IO #memanggil library GPIO pada RPI3
import time #dekalrasi waktu delay
IO.setwarnings(False) #jangan tmpilkan peringatan apapun
x=1 #deklarasi variabel x dengan nilai samadengan 1
y=1 #deklarasi variabel y dengan nilai samadengan 1
IO.setmode (IO.BCM) #memprogram input output dengan pin BCM
IO.setup(12,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(22,IO.OUT) #inisialisasi GPIO22 sebagai output
IO.setup(27,IO.OUT) #inisialisasi GPIO27 sebagai output
IO.setup(25,IO.OUT) #inisialisasi GPIO25 sebagai output
IO.setup(17,IO.OUT) #inisialisasi GPIO17 sebagai output
IO.setup(24,IO.OUT) #inisialisasi GPIO24 sebagai output
IO.setup(23,IO.OUT) #inisialisasi GPIO23 sebagai output
IO.setup(18,IO.OUT) #inisialisasi GPIO18 sebagai output
IO.setup(21,IO.OUT) #inisialisasi GPIO21 sebagai output
IO.setup(20,IO.OUT) #inisialisasi GPIO20 sebagai output
IO.setup(26,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(16,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(19,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(13,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(6,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(5,IO.OUT) #inisialisasi GPIO12 sebagai output
PORTVALUE = [128,64,32,16,8,4,2,1]
#nilai dari pin dibeberapa port
A=[0,0b01111111,0b11111111,0b11001100,0b11001100,0b11001100,0b11111111,0b01111111]
B =[0,0b00111100,0b01111110,0b11011011,0b11011011,0b11011011,0b11111111,0b11111111]
C= [0,0b11000011,0b11000011,0b11000011,0b11000011,0b11100111,0b01111110,0b00111100]
D=[0,0b01111110,0b10111101,0b11000011,0b11000011,0b11000011,0b11111111,0b11111111]
E=[0,0b11011011,0b11011011,0b11011011,0b11011011,0b11011011,0b11111111,0b11111111]
F=[0,0b11011000,0b11011000,0b11011000,0b11011000,0b11011000,0b11111111,0b11111111]
G=[0b00011111,0b11011111,0b11011000,0b11011011,0b11011011,0b11011011,0b11111111,0b11111111]
H=[0,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000,0b11111111,0b11111111]
I=[0b11000011,0b11000011,0b11000011,0b11111111,0b11111111,0b11000011,0b11000011,0b11000011]
J=[0b11000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11000011,0b11001111,0b11001111]
K=[0,0b11000011,0b11100111,0b01111110,0b00111100,0b00011000,0b11111111,0b11111111]
L=[0b00000011,0b00000011,0b00000011,0b00000011,0b00000011,0b00000011,0b11111111,0b11111111]
M=[0b11111111,0b11111111,0b01100000,0b01110000,0b01110000,0b01100000,0b11111111,0b11111111]
N=[0b11111111,0b11111111,0b00011100,0b00111000,0b01110000,0b11100000,0b11111111,0b11111111]
O=[0b01111110,0b11111111,0b11000011,0b11000011,0b11000011,0b11000011,0b11111111,0b01111110]
P=[0,0b01110000,0b11111000,0b11001100,0b11001100,0b11001100,0b11111111,0b11111111]
Q=[0b01111110,0b11111111,0b11001111,0b11011111,0b11011011,0b11000011,0b11111111,0b01111110]
R=[0b01111001,0b11111011,0b11011111,0b11011110,0b11011100,0b11011000,0b11111111,0b11111111]
S=[0b11001110,0b11011111,0b11011011,0b11011011,0b11011011,0b11011011,0b11111011,0b01110011]
T=[0b11000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11000000,0b11000000,0b11000000]
U=[0b11111110,0b11111111,0b00000011,0b00000011,0b00000011,0b00000011,0b11111111,0b11111110]
V=[0b11100000,0b11111100,0b00011110,0b00000011,0b00000011,0b00011110,0b11111100,0b11100000]
W=[0b11111110,0b11111111,0b00000011,0b11111111,0b11111111,0b00000011,0b11111111,0b11111110]
X=[0b01000010,0b11100111,0b01111110,0b00111100,0b00111100,0b01111110,0b11100111,0b01000010]
Y=[0b01000000,0b11100000,0b01110000,0b00111111,0b00111111,0b01110000,0b11100000,0b01000000]
Z=[0b11000011,0b11100011,0b11110011,0b11111011,0b11011111,0b11001111,0b11000111,0b11000011]
def PORT(pin): #assigning GPIO state by taking "pin" value
if(pin&0x01 == 0x01):
IO.output(21,0) #if bit0 of 8bit "pin" is true pull PIN21 low
else:
IO.output(21,1) #if bit0 of 8bit "pin" is false pull PIN21 high
if(pin&0x02 == 0x02):
IO.output(20,0) #if bit1 of 8bit "pin" is true pull PIN20 low
else:
IO.output(20,1) #if bit1 of 8bit "pin" is false pull PIN20 high
if(pin&0x04 == 0x04):
IO.output(26,0) #if bit2 of 8bit "pin" is true pull PIN26 low
else:
IO.output(26,1) #if bit2 of 8bit "pin" is false pull PIN26 high
if(pin&0x08 == 0x08):
IO.output(16,0) #if bit3 of 8bit "pin" is true pull PIN16 low
else:
IO.output(16,1) #if bit3 of 8bit "pin" is false pull PIN16 high
if(pin&0x10 == 0x10):
IO.output(19,0) #if bit4 of 8bit "pin" is true pull PIN19 low
else:
IO.output(19,1) #if bit4 of 8bit "pin" is false pull PIN19 high
if(pin&0x20 == 0x20):
IO.output(13,0) #if bit5 of 8bit "pin" is true pull PIN13 low
else:
IO.output(13,1) #if bit5 of 8bit "pin" is false pull PIN13 high
if(pin&0x40 == 0x40):
IO.output(6,0) #if bit6 of 8bit "pin" is true pull PIN6 low
else:
IO.output(6,1) #if bit6 of 8bit "pin" is false pull PIN6 high
if(pin&0x80 == 0x80):
IO.output(5,0) #if bit7 of 8bit "pin" is true pull PIN5 low
else:
IO.output(5,1) #if bit7 of 8bit "pin" is false pull PIN5 high
def PORTP(pinp): #assigning GPIO logic for positive terminals by taking "pinp" value
if(pinp&0x01 == 0x01):
IO.output(12,1) #if bit0 of 8bit "pinp" is true pull PIN12 high
else:
IO.output(12,0) #if bit0 of 8bit "pinp" is false pull PIN12 low
if(pinp&0x02 == 0x02):
IO.output(22,1) #if bit1 of 8bit "pinp" is true pull PIN22 high
else:
IO.output(22,0) #if bit1 of 8bit "pinp" is false pull PIN22 low
if(pinp&0x04 == 0x04):
IO.output(27,1) #if bit2 of 8bit "pinp" is true pull PIN27 high
else:
IO.output(27,0) #if bit2 of 8bit "pinp" is false pull PIN27 low
if(pinp&0x08 == 0x08):
IO.output(25,1) #if bit3 of 8bit "pinp" is true pull PIN25 high
else:
IO.output(25,0) #if bit3 of 8bit "pinp" is false pull PIN25 low
if(pinp&0x10 == 0x10):
IO.output(17,1) #if bit4 of 8bit "pinp" is true pull PIN17 high
else:
IO.output(17,0) #if bit4 of 8bit "pinp" is false pull PIN17 low
if(pinp&0x20 == 0x20):
IO.output(24,1) #if bit5 of 8bit "pinp" is true pull PIN24 high
else:
IO.output(24,0) #if bit5 of 8bit "pinp" is false pull PIN24 low
if(pinp&0x40 == 0x40):
IO.output(23,1) #if bit6 of 8bit "pinp" is true pull PIN23 high
else:
IO.output(23,0) #if bit6 of 8bit "pinp" is false pull PIN23 low
if(pinp&0x80 == 0x80):
IO.output(18,1) #if bit7 of 8bit "pinp" is true pull PIN18 high
else:
IO.output(18,0) #if bit7 of 8bit "pinp" is false pull PIN18 low
while 1:
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= C[x] #assigning character "C" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "C"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= I[x] #assigning character "I" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "I"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= R[x] #assigning character "R" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "R"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= C[x] #assigning character "C" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "C"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= U[x] #assigning character "U" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "U"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= I[x] #assigning character "I" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "I"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= T[x] #assigning character "T" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "T"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= D[x] #assigning character "D" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "D"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= I[x] #assigning character "I" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "I"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= G[x] #assigning character "G" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "G"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= E[x] #assigning character "E" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "E"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= S[x] #assigning character "S" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "S"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= T[x] #assigning character "T" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "T"
time.sleep(0.0005) #wait for 0.5msec
pinp= 0
PORTP(pinp):
time.sleep(1)
import time #dekalrasi waktu delay
IO.setwarnings(False) #jangan tmpilkan peringatan apapun
x=1 #deklarasi variabel x dengan nilai samadengan 1
y=1 #deklarasi variabel y dengan nilai samadengan 1
IO.setmode (IO.BCM) #memprogram input output dengan pin BCM
IO.setup(12,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(22,IO.OUT) #inisialisasi GPIO22 sebagai output
IO.setup(27,IO.OUT) #inisialisasi GPIO27 sebagai output
IO.setup(25,IO.OUT) #inisialisasi GPIO25 sebagai output
IO.setup(17,IO.OUT) #inisialisasi GPIO17 sebagai output
IO.setup(24,IO.OUT) #inisialisasi GPIO24 sebagai output
IO.setup(23,IO.OUT) #inisialisasi GPIO23 sebagai output
IO.setup(18,IO.OUT) #inisialisasi GPIO18 sebagai output
IO.setup(21,IO.OUT) #inisialisasi GPIO21 sebagai output
IO.setup(20,IO.OUT) #inisialisasi GPIO20 sebagai output
IO.setup(26,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(16,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(19,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(13,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(6,IO.OUT) #inisialisasi GPIO12 sebagai output
IO.setup(5,IO.OUT) #inisialisasi GPIO12 sebagai output
PORTVALUE = [128,64,32,16,8,4,2,1]
#nilai dari pin dibeberapa port
A=[0,0b01111111,0b11111111,0b11001100,0b11001100,0b11001100,0b11111111,0b01111111]
B =[0,0b00111100,0b01111110,0b11011011,0b11011011,0b11011011,0b11111111,0b11111111]
C= [0,0b11000011,0b11000011,0b11000011,0b11000011,0b11100111,0b01111110,0b00111100]
D=[0,0b01111110,0b10111101,0b11000011,0b11000011,0b11000011,0b11111111,0b11111111]
E=[0,0b11011011,0b11011011,0b11011011,0b11011011,0b11011011,0b11111111,0b11111111]
F=[0,0b11011000,0b11011000,0b11011000,0b11011000,0b11011000,0b11111111,0b11111111]
G=[0b00011111,0b11011111,0b11011000,0b11011011,0b11011011,0b11011011,0b11111111,0b11111111]
H=[0,0b11111111,0b11111111,0b00011000,0b00011000,0b00011000,0b11111111,0b11111111]
I=[0b11000011,0b11000011,0b11000011,0b11111111,0b11111111,0b11000011,0b11000011,0b11000011]
J=[0b11000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11000011,0b11001111,0b11001111]
K=[0,0b11000011,0b11100111,0b01111110,0b00111100,0b00011000,0b11111111,0b11111111]
L=[0b00000011,0b00000011,0b00000011,0b00000011,0b00000011,0b00000011,0b11111111,0b11111111]
M=[0b11111111,0b11111111,0b01100000,0b01110000,0b01110000,0b01100000,0b11111111,0b11111111]
N=[0b11111111,0b11111111,0b00011100,0b00111000,0b01110000,0b11100000,0b11111111,0b11111111]
O=[0b01111110,0b11111111,0b11000011,0b11000011,0b11000011,0b11000011,0b11111111,0b01111110]
P=[0,0b01110000,0b11111000,0b11001100,0b11001100,0b11001100,0b11111111,0b11111111]
Q=[0b01111110,0b11111111,0b11001111,0b11011111,0b11011011,0b11000011,0b11111111,0b01111110]
R=[0b01111001,0b11111011,0b11011111,0b11011110,0b11011100,0b11011000,0b11111111,0b11111111]
S=[0b11001110,0b11011111,0b11011011,0b11011011,0b11011011,0b11011011,0b11111011,0b01110011]
T=[0b11000000,0b11000000,0b11000000,0b11111111,0b11111111,0b11000000,0b11000000,0b11000000]
U=[0b11111110,0b11111111,0b00000011,0b00000011,0b00000011,0b00000011,0b11111111,0b11111110]
V=[0b11100000,0b11111100,0b00011110,0b00000011,0b00000011,0b00011110,0b11111100,0b11100000]
W=[0b11111110,0b11111111,0b00000011,0b11111111,0b11111111,0b00000011,0b11111111,0b11111110]
X=[0b01000010,0b11100111,0b01111110,0b00111100,0b00111100,0b01111110,0b11100111,0b01000010]
Y=[0b01000000,0b11100000,0b01110000,0b00111111,0b00111111,0b01110000,0b11100000,0b01000000]
Z=[0b11000011,0b11100011,0b11110011,0b11111011,0b11011111,0b11001111,0b11000111,0b11000011]
def PORT(pin): #assigning GPIO state by taking "pin" value
if(pin&0x01 == 0x01):
IO.output(21,0) #if bit0 of 8bit "pin" is true pull PIN21 low
else:
IO.output(21,1) #if bit0 of 8bit "pin" is false pull PIN21 high
if(pin&0x02 == 0x02):
IO.output(20,0) #if bit1 of 8bit "pin" is true pull PIN20 low
else:
IO.output(20,1) #if bit1 of 8bit "pin" is false pull PIN20 high
if(pin&0x04 == 0x04):
IO.output(26,0) #if bit2 of 8bit "pin" is true pull PIN26 low
else:
IO.output(26,1) #if bit2 of 8bit "pin" is false pull PIN26 high
if(pin&0x08 == 0x08):
IO.output(16,0) #if bit3 of 8bit "pin" is true pull PIN16 low
else:
IO.output(16,1) #if bit3 of 8bit "pin" is false pull PIN16 high
if(pin&0x10 == 0x10):
IO.output(19,0) #if bit4 of 8bit "pin" is true pull PIN19 low
else:
IO.output(19,1) #if bit4 of 8bit "pin" is false pull PIN19 high
if(pin&0x20 == 0x20):
IO.output(13,0) #if bit5 of 8bit "pin" is true pull PIN13 low
else:
IO.output(13,1) #if bit5 of 8bit "pin" is false pull PIN13 high
if(pin&0x40 == 0x40):
IO.output(6,0) #if bit6 of 8bit "pin" is true pull PIN6 low
else:
IO.output(6,1) #if bit6 of 8bit "pin" is false pull PIN6 high
if(pin&0x80 == 0x80):
IO.output(5,0) #if bit7 of 8bit "pin" is true pull PIN5 low
else:
IO.output(5,1) #if bit7 of 8bit "pin" is false pull PIN5 high
def PORTP(pinp): #assigning GPIO logic for positive terminals by taking "pinp" value
if(pinp&0x01 == 0x01):
IO.output(12,1) #if bit0 of 8bit "pinp" is true pull PIN12 high
else:
IO.output(12,0) #if bit0 of 8bit "pinp" is false pull PIN12 low
if(pinp&0x02 == 0x02):
IO.output(22,1) #if bit1 of 8bit "pinp" is true pull PIN22 high
else:
IO.output(22,0) #if bit1 of 8bit "pinp" is false pull PIN22 low
if(pinp&0x04 == 0x04):
IO.output(27,1) #if bit2 of 8bit "pinp" is true pull PIN27 high
else:
IO.output(27,0) #if bit2 of 8bit "pinp" is false pull PIN27 low
if(pinp&0x08 == 0x08):
IO.output(25,1) #if bit3 of 8bit "pinp" is true pull PIN25 high
else:
IO.output(25,0) #if bit3 of 8bit "pinp" is false pull PIN25 low
if(pinp&0x10 == 0x10):
IO.output(17,1) #if bit4 of 8bit "pinp" is true pull PIN17 high
else:
IO.output(17,0) #if bit4 of 8bit "pinp" is false pull PIN17 low
if(pinp&0x20 == 0x20):
IO.output(24,1) #if bit5 of 8bit "pinp" is true pull PIN24 high
else:
IO.output(24,0) #if bit5 of 8bit "pinp" is false pull PIN24 low
if(pinp&0x40 == 0x40):
IO.output(23,1) #if bit6 of 8bit "pinp" is true pull PIN23 high
else:
IO.output(23,0) #if bit6 of 8bit "pinp" is false pull PIN23 low
if(pinp&0x80 == 0x80):
IO.output(18,1) #if bit7 of 8bit "pinp" is true pull PIN18 high
else:
IO.output(18,0) #if bit7 of 8bit "pinp" is false pull PIN18 low
while 1:
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= C[x] #assigning character "C" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "C"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= I[x] #assigning character "I" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "I"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= R[x] #assigning character "R" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "R"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= C[x] #assigning character "C" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "C"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= U[x] #assigning character "U" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "U"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= I[x] #assigning character "I" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "I"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= T[x] #assigning character "T" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "T"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= D[x] #assigning character "D" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "D"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= I[x] #assigning character "I" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "I"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= G[x] #assigning character "G" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "G"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= E[x] #assigning character "E" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "E"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= S[x] #assigning character "S" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "S"
time.sleep(0.0005) #wait for 0.5msec
for y in range (100): #looping 100 kali
for x in range (8): #eksekusi loop 8 kali incrementing nilai x dari 0 ke 7
pin = PORTVALUE[x] #memberi nilai pada "pin" untuk digit yang lain
PORT(pin): #mapping appropriate GPIO
pinp= T[x] #assigning character "T" value to "pinp"
PORTP(pinp): #turning the GPIO to show character "T"
time.sleep(0.0005) #wait for 0.5msec
pinp= 0
PORTP(pinp):
time.sleep(1)
Kodingan Pengaplikasian
Video Pengaplikasian
4.5. Motor DC
[kembali]
Foto Pengaplikasian
Rangkaian
Flowchart
Kodingan
import RPi.GPIO as IO #memanggil library GPIO?s pada PI
import time # deklarasi waktu delay
IO.setwarnings(False) #menset agar tidak mengeluarkan perintah yang dilarang
x=0 #deklarasi nilai duty cycle dengan tipe interger
IO.setmode (IO.BCM) #memprogram pin GPIO pada BCM
IO.setup(13,IO.OUT) # inisialisasi GPIO13 sebagai output.
IO.setup(19,IO.IN) #inisialisasiGPIO19 sebagai input.
IO.setup(26,IO.IN) # inisialisasi GPIO26 sebagai input.
p = IO.PWM(13,100) #GPIO13 sebagai PWM output, dengan 100Hz frequency
p.start(0) #menghasilkan PWM sinyal dengan 0% duty cycle
while 1: #berulang selama RPI hidup
p.ChangeDutyCycle(x) #mengubah nilai duty cycle
if(IO.input(26) == False): #jika tombol 2 atau yang sebelah kana ditekan
if(x<50): #jika nilai duty cicle kecil dari 50Hz
x=x+1 #menaikan nilai x satu persatu sampai x<50
time.sleep(0.2) #sleep for 200ms
if(IO.input(19) == False): #jika tombol 1 atau kiri ditekan
if(x>0): #jika nilai duty cycle besar dari 0
x=x-1 #maka nilai duty cicle akan mengecil satu persatu smpai x>0
time.sleep(0.2) #sleep for 200ms
import time # deklarasi waktu delay
IO.setwarnings(False) #menset agar tidak mengeluarkan perintah yang dilarang
x=0 #deklarasi nilai duty cycle dengan tipe interger
IO.setmode (IO.BCM) #memprogram pin GPIO pada BCM
IO.setup(13,IO.OUT) # inisialisasi GPIO13 sebagai output.
IO.setup(19,IO.IN) #inisialisasiGPIO19 sebagai input.
IO.setup(26,IO.IN) # inisialisasi GPIO26 sebagai input.
p = IO.PWM(13,100) #GPIO13 sebagai PWM output, dengan 100Hz frequency
p.start(0) #menghasilkan PWM sinyal dengan 0% duty cycle
while 1: #berulang selama RPI hidup
p.ChangeDutyCycle(x) #mengubah nilai duty cycle
if(IO.input(26) == False): #jika tombol 2 atau yang sebelah kana ditekan
if(x<50): #jika nilai duty cicle kecil dari 50Hz
x=x+1 #menaikan nilai x satu persatu sampai x<50
time.sleep(0.2) #sleep for 200ms
if(IO.input(19) == False): #jika tombol 1 atau kiri ditekan
if(x>0): #jika nilai duty cycle besar dari 0
x=x-1 #maka nilai duty cicle akan mengecil satu persatu smpai x>0
time.sleep(0.2) #sleep for 200ms
Video Pengaplikasian
4.6. ADC
[kembali]
Foto Pengaplikasian
Rangkaian ADC
Rangkaian Skematik
Flowchart
Kodingan Program
import RPi.GPIO as IO # memanggil library dari GPIO pada RPI3
import time # deklarasi waktu delay
IO.setwarnings(False) # tidak menampilkan perintah yang tidak diperintahkan
x=1 # deklarasi variabel x dengan nilai sama dengan 1
b0 =0 # integers for storing 8 bits
b1 =0
b2 =0
b3 =0
b4 =0
b5 =0
b6 =0
b7 =0
IO.setmode (IO.BCM) #memprogram GPIO dengan pin BCM
IO.setup(4,IO.IN) # inisialisai GPIO Pin4 sebagai input
IO.setup(17,IO.IN) # inisialisai GPIO Pin17 sebagai input
IO.setup(27,IO.IN) # inisialisai GPIO Pin27 sebagai input
IO.setup(22,IO.IN) # inisialisai GPIO Pin22 sebagai input
IO.setup(5,IO.IN) # inisialisai GPIO Pin5 sebagai input
IO.setup(6,IO.IN) # inisialisai GPIO Pin6 sebagai input
IO.setup(13,IO.IN) # inisialisai GPIO Pin13 sebagai input
IO.setup(19,IO.IN) # inisialisai GPIO Pin19 sebagai input
while 1: # looping
if (IO.input(19) == True): #jika pin 19 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(19) == True): #jika pin 19 bernilai HIGH
b7=1 # jika pin19 bernilai HIGH bit7 bernilai bernar
if (IO.input(13) == True): #jika pin 13 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(13) == True): #jika pin 13 bernilai HIGH
b6=1 # jika pin13 bernilai HIGH bit6 bernilai bernar
if (IO.input(6) == True): #jika pin 6 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(6) == True): #jika pin 6 bernilai HIGH
b5=1 # jika pin 6 bernilai HIGH bit5 bernilai bernar
if (IO.input(5) == True): #jika pin 5 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(5) == True): #jika pin 5 bernilai HIGH
b4=1 # jika pin 5 bernilai HIGH bit4 bernilai bernar
if (IO.input(22) == True): #jika pin 22 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(22) == True): #jika pin 22 bernilai HIGH
b3=1 # jika pin 22 bernilai HIGH bit3 bernilai bernar
if (IO.input(27) == True): #jika pin 27 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(27) == True): #jika pin 27 bernilai HIGH
b2=1 # jika pin 27 bernilai HIGH bit2 bernilai bernar
if (IO.input(17) == True): #jika pin 17 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(17) == True): #jika pin 17 bernilai HIGH
b1=1 # jika pin 17 bernilai HIGH bit1 bernilai bernar
if (IO.input(4) == True): #jika pin 4 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(4) == True): #jika pin 4 bernilai HIGH
b0=1 # jika pin 4 bernilai HIGH bit0 bernilai bernar
x = (1*b0)+(2*b1)
x = x+(4*b2)+(8*b3)
x = x+(16*b4)+(32*b5)
x = x+(64*b6)+(128*b7) # mengatur ulang bit values from LSB to MSB
print ( x) # print the ADC value
b0=b1=b2=b3=b4=b5=b6=b7=0 # reset values
time.sleep(0.01) # delay 10ms
IO.setwarnings(False) # tidak menampilkan perintah yang tidak diperintahkan
x=1 # deklarasi variabel x dengan nilai sama dengan 1
b0 =0 # integers for storing 8 bits
b1 =0
b2 =0
b3 =0
b4 =0
b5 =0
b6 =0
b7 =0
IO.setmode (IO.BCM) #memprogram GPIO dengan pin BCM
IO.setup(4,IO.IN) # inisialisai GPIO Pin4 sebagai input
IO.setup(17,IO.IN) # inisialisai GPIO Pin17 sebagai input
IO.setup(27,IO.IN) # inisialisai GPIO Pin27 sebagai input
IO.setup(22,IO.IN) # inisialisai GPIO Pin22 sebagai input
IO.setup(5,IO.IN) # inisialisai GPIO Pin5 sebagai input
IO.setup(6,IO.IN) # inisialisai GPIO Pin6 sebagai input
IO.setup(13,IO.IN) # inisialisai GPIO Pin13 sebagai input
IO.setup(19,IO.IN) # inisialisai GPIO Pin19 sebagai input
while 1: # looping
if (IO.input(19) == True): #jika pin 19 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(19) == True): #jika pin 19 bernilai HIGH
b7=1 # jika pin19 bernilai HIGH bit7 bernilai bernar
if (IO.input(13) == True): #jika pin 13 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(13) == True): #jika pin 13 bernilai HIGH
b6=1 # jika pin13 bernilai HIGH bit6 bernilai bernar
if (IO.input(6) == True): #jika pin 6 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(6) == True): #jika pin 6 bernilai HIGH
b5=1 # jika pin 6 bernilai HIGH bit5 bernilai bernar
if (IO.input(5) == True): #jika pin 5 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(5) == True): #jika pin 5 bernilai HIGH
b4=1 # jika pin 5 bernilai HIGH bit4 bernilai bernar
if (IO.input(22) == True): #jika pin 22 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(22) == True): #jika pin 22 bernilai HIGH
b3=1 # jika pin 22 bernilai HIGH bit3 bernilai bernar
if (IO.input(27) == True): #jika pin 27 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(27) == True): #jika pin 27 bernilai HIGH
b2=1 # jika pin 27 bernilai HIGH bit2 bernilai bernar
if (IO.input(17) == True): #jika pin 17 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(17) == True): #jika pin 17 bernilai HIGH
b1=1 # jika pin 17 bernilai HIGH bit1 bernilai bernar
if (IO.input(4) == True): #jika pin 4 bernilai HIGH
time.sleep(0.001) #delay 1ms
if (IO.input(4) == True): #jika pin 4 bernilai HIGH
b0=1 # jika pin 4 bernilai HIGH bit0 bernilai bernar
x = (1*b0)+(2*b1)
x = x+(4*b2)+(8*b3)
x = x+(16*b4)+(32*b5)
x = x+(64*b6)+(128*b7) # mengatur ulang bit values from LSB to MSB
print ( x) # print the ADC value
b0=b1=b2=b3=b4=b5=b6=b7=0 # reset values
time.sleep(0.01) # delay 10ms
Video Pengaplikasian
4.7. DAC
[kembali]
Foto Pengaplikasian
Foto Rangkaian
Flowchart
Kodingan Program
Video Pengaplikasian
4.8. Sensor
[kembali]
Foto Pengaplikasian
Rangkaian Skematik
Flowchart
Kodingan
import RPi.GPIO as IO #menginput library GPIO pada RPI
import time #import waktu delay
IO.setwarnings(False) #jangan ada menimbulkan perintah yang tidak diinginkan
IO.setmode(IO.BCM) #menset pin dengan BCM
IO.setup(2,IO.OUT) #GPIO 2 -> Red LED as output
IO.setup(3,IO.OUT) #GPIO 3 -> Green LED as output
IO.setup(14,IO.IN) #GPIO 14 -> IR sensor as input
while 1:
if(IO.input(14)==True): #object is far away
IO.output(2,True) #Red led ON
IO.output(3,False) # Green led OFF
if(IO.input(14)==False): #object is near
IO.output(3,True) #Green led ON
IO.output(2,False) # Red led OFF
import time #import waktu delay
IO.setwarnings(False) #jangan ada menimbulkan perintah yang tidak diinginkan
IO.setmode(IO.BCM) #menset pin dengan BCM
IO.setup(2,IO.OUT) #GPIO 2 -> Red LED as output
IO.setup(3,IO.OUT) #GPIO 3 -> Green LED as output
IO.setup(14,IO.IN) #GPIO 14 -> IR sensor as input
while 1:
if(IO.input(14)==True): #object is far away
IO.output(2,True) #Red led ON
IO.output(3,False) # Green led OFF
if(IO.input(14)==False): #object is near
IO.output(3,True) #Green led ON
IO.output(2,False) # Red led OFF
Video Pengaplikasian
4.9. Button
[kembali]
Foto Pengaplikasian
Rangkaian Pengaplikasian
Rangkaian Skematik
Flowchart
Kodingan
import RPi.GPIO as IO #memanggil library GPIO pada RPI3
import time # memanggil waktu delay
IO.setwarnings(False) #tidak menampilkan perintah yang tidak diinginkan
IO.setmode (IO.BCM) #memprogram GPIO dengan pin BCM
IO.setup(19,IO.OUT) # inisialisasi GPIO19 sebagai output.
IO.setup(26,IO.IN) #inisialisasiGPIO26 sebagai input
while 1: #looping
if(IO.input(26) == False): #jika GPIO26 menjadi low
IO.output(19,True) # maka LED hidup(membuat tegangan level menjadi HIGH)
time.sleep(0.11) #delay 100m second
IO.output(19,False) # maka LED mati(membuat tegangan level GPIO19 low)
time.sleep(1) #delay100m second
import time # memanggil waktu delay
IO.setwarnings(False) #tidak menampilkan perintah yang tidak diinginkan
IO.setmode (IO.BCM) #memprogram GPIO dengan pin BCM
IO.setup(19,IO.OUT) # inisialisasi GPIO19 sebagai output.
IO.setup(26,IO.IN) #inisialisasiGPIO26 sebagai input
while 1: #looping
if(IO.input(26) == False): #jika GPIO26 menjadi low
IO.output(19,True) # maka LED hidup(membuat tegangan level menjadi HIGH)
time.sleep(0.11) #delay 100m second
IO.output(19,False) # maka LED mati(membuat tegangan level GPIO19 low)
time.sleep(1) #delay100m second
Video Pengaplikasian
Kodingan
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 23 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 17 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #GPIO 24 dipasang sebagai input, ditarik ke bawah, terhubung ke 3V3 pada tombol tekan
#sekarang kita akan mendefinisikan dua fungsi callback
def my_callback(channel):
print "falling edge detected on 17" #tampilkan tulisan falling edge detected on 17
def my_callback2(channel):
print "falling edge detected on 23" #tampilkan tulisanfalling edge detected on 23
print "Make sure you have a button connected so that when pressed" #tampilkan tulisan Make sure you have a button connected so that when pressed
print "it will connect GPIO port 23 (pin 16) to GND (pin 6)\n" #tampilkan tulisan it will connect GPIO port 23 (pin 16) to GND (pin 6)
print "You will also need a second button connected so that when pressed" #tampilkan tulisan You will also need a second button connected so that when pressed
print "it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)\n" #tampilkan tulisan it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)
print "You will also need a third button connected so that when pressed" #tampilkan tulisan You will also need a third button connected so that when pressed
print "it will connect GPIO port 17 (pin 11) to GND (pin 14)" #tampilkan tulisan it will connect GPIO port 17 (pin 11) to GND (pin 14)
raw_input("Press Enter when ready\n>")
GPIO.add_event_detect(17, GPIO.FALLING, callback=my_callback, bouncetime=300)
GPIO.add_event_detect(23, GPIO.FALLING, callback=my_callback2, bouncetime=300)
try:
print "Waiting for rising edge on port 24"
GPIO.wait_for_edge(24, GPIO.RISING)
print "Rising edge detected on port 24. Here endeth the third lesson."
except KeyboardInterrupt:
GPIO.cleanup() # clean up GPIO on CTRL+C exit
GPIO.cleanup() # clean up GPIO on normal exit
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 23 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 17 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #GPIO 24 dipasang sebagai input, ditarik ke bawah, terhubung ke 3V3 pada tombol tekan
#sekarang kita akan mendefinisikan dua fungsi callback
def my_callback(channel):
print "falling edge detected on 17" #tampilkan tulisan falling edge detected on 17
def my_callback2(channel):
print "falling edge detected on 23" #tampilkan tulisanfalling edge detected on 23
print "Make sure you have a button connected so that when pressed" #tampilkan tulisan Make sure you have a button connected so that when pressed
print "it will connect GPIO port 23 (pin 16) to GND (pin 6)\n" #tampilkan tulisan it will connect GPIO port 23 (pin 16) to GND (pin 6)
print "You will also need a second button connected so that when pressed" #tampilkan tulisan You will also need a second button connected so that when pressed
print "it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)\n" #tampilkan tulisan it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)
print "You will also need a third button connected so that when pressed" #tampilkan tulisan You will also need a third button connected so that when pressed
print "it will connect GPIO port 17 (pin 11) to GND (pin 14)" #tampilkan tulisan it will connect GPIO port 17 (pin 11) to GND (pin 14)
raw_input("Press Enter when ready\n>")
GPIO.add_event_detect(17, GPIO.FALLING, callback=my_callback, bouncetime=300)
GPIO.add_event_detect(23, GPIO.FALLING, callback=my_callback2, bouncetime=300)
try:
print "Waiting for rising edge on port 24"
GPIO.wait_for_edge(24, GPIO.RISING)
print "Rising edge detected on port 24. Here endeth the third lesson."
except KeyboardInterrupt:
GPIO.cleanup() # clean up GPIO on CTRL+C exit
GPIO.cleanup() # clean up GPIO on normal exit
Video Pengaplikasian
Foto Pengaplikasian
Rangkaian Skematik
Kodingan
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 23 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 17 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #GPIO 24 dipasang sebagai input, ditarik ke bawah, terhubung ke 3V3 pada tombol tekan
#sekarang kita akan mendefinisikan dua fungsi callback
def my_callback(channel):
print "falling edge detected on 17" #tampilkan tulisan falling edge detected on 17
def my_callback2(channel):
print "falling edge detected on 23" #tampilkan tulisanfalling edge detected on 23
print "Make sure you have a button connected so that when pressed" #tampilkan tulisan Make sure you have a button connected so that when pressed
print "it will connect GPIO port 23 (pin 16) to GND (pin 6)\n" #tampilkan tulisan it will connect GPIO port 23 (pin 16) to GND (pin 6)
print "You will also need a second button connected so that when pressed" #tampilkan tulisan You will also need a second button connected so that when pressed
print "it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)\n" #tampilkan tulisan it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)
print "You will also need a third button connected so that when pressed" #tampilkan tulisan You will also need a third button connected so that when pressed
print "it will connect GPIO port 17 (pin 11) to GND (pin 14)" #tampilkan tulisan it will connect GPIO port 17 (pin 11) to GND (pin 14)
raw_input("Press Enter when ready\n>")
GPIO.add_event_detect(17, GPIO.FALLING, callback=my_callback, bouncetime=300)
GPIO.add_event_detect(23, GPIO.FALLING, callback=my_callback2, bouncetime=300)
try:
print "Waiting for rising edge on port 24"
GPIO.wait_for_edge(24, GPIO.RISING)
print "Rising edge detected on port 24. Here endeth the third lesson."
except KeyboardInterrupt:
GPIO.cleanup() # clean up GPIO on CTRL+C exit
GPIO.cleanup() # clean up GPIO on normal exit
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 23 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP) # GPIO 17 dipasang sebagai input, ditarik untuk menghindari deteksi kesalahan
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #GPIO 24 dipasang sebagai input, ditarik ke bawah, terhubung ke 3V3 pada tombol tekan
#sekarang kita akan mendefinisikan dua fungsi callback
def my_callback(channel):
print "falling edge detected on 17" #tampilkan tulisan falling edge detected on 17
def my_callback2(channel):
print "falling edge detected on 23" #tampilkan tulisanfalling edge detected on 23
print "Make sure you have a button connected so that when pressed" #tampilkan tulisan Make sure you have a button connected so that when pressed
print "it will connect GPIO port 23 (pin 16) to GND (pin 6)\n" #tampilkan tulisan it will connect GPIO port 23 (pin 16) to GND (pin 6)
print "You will also need a second button connected so that when pressed" #tampilkan tulisan You will also need a second button connected so that when pressed
print "it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)\n" #tampilkan tulisan it will connect GPIO port 24 (pin 18) to 3V3 (pin 1)
print "You will also need a third button connected so that when pressed" #tampilkan tulisan You will also need a third button connected so that when pressed
print "it will connect GPIO port 17 (pin 11) to GND (pin 14)" #tampilkan tulisan it will connect GPIO port 17 (pin 11) to GND (pin 14)
raw_input("Press Enter when ready\n>")
GPIO.add_event_detect(17, GPIO.FALLING, callback=my_callback, bouncetime=300)
GPIO.add_event_detect(23, GPIO.FALLING, callback=my_callback2, bouncetime=300)
try:
print "Waiting for rising edge on port 24"
GPIO.wait_for_edge(24, GPIO.RISING)
print "Rising edge detected on port 24. Here endeth the third lesson."
except KeyboardInterrupt:
GPIO.cleanup() # clean up GPIO on CTRL+C exit
GPIO.cleanup() # clean up GPIO on normal exit
4.11. Serial
[kembali]
Foto Pengaplikasian
Rangkaian dalam IC74HC595
Rangkaian Skematik
Flowchart
Kodingan
import RPi.GPIO as IO # memanggil library GPIO pada RPI3
import time # dekalarasi waktu delay
IO.setwarnings(False) # jangan tampilkan perintah yang tidak ingin
x=1
IO.setmode (IO.BCM) # memprogram GPIO dengan pinBCM
IO.setup(4,IO.OUT) # inisialisasi GPIO Pin4 sebagai output.
IO.setup(5,IO.OUT) # inisialisasi GPIO Pin5 sebagai output.
IO.setup(6,IO.OUT) # inisialisasi GPIO Pin6 sebagai output.
while 1: # looping
for y in range(8): # looping dengan hitung smpai 8
IO.output(4,1) # pull up the data pin for every bit.
time.sleep(0.1) # wait for 100ms
IO.output(5,1) # pull CLOCK pin high
time.sleep(0.1)
IO.output(5,0) # pull CLOCK pin down, to send a rising edge
IO.output(4,0) # clear the DATA pin
IO.output(6,1) # pull the SHIFT pin high to put the 8 bit data out parallel
time.sleep(0.1)
IO.output(6,0) # pull down the SHIFT pin
for y in range(8): # loop for counting up 8 times
IO.output(4,0) # clear the DATA pin, to send 0
time.sleep(0.1) # wait for 100ms
IO.output(5,1) # pull CLOCK pin high
time.sleep(0.1)
IO.output(5,0) # pull CLOCK pin down, to send a rising edge
IO.output(4,0) # keep the DATA bit low to keep the countdown
IO.output(6,1) # pull the SHIFT pin high to put the 8 bit data out paralle
l time.sleep(0.1)
IO.output(6,0)
import time # dekalarasi waktu delay
IO.setwarnings(False) # jangan tampilkan perintah yang tidak ingin
x=1
IO.setmode (IO.BCM) # memprogram GPIO dengan pinBCM
IO.setup(4,IO.OUT) # inisialisasi GPIO Pin4 sebagai output.
IO.setup(5,IO.OUT) # inisialisasi GPIO Pin5 sebagai output.
IO.setup(6,IO.OUT) # inisialisasi GPIO Pin6 sebagai output.
while 1: # looping
for y in range(8): # looping dengan hitung smpai 8
IO.output(4,1) # pull up the data pin for every bit.
time.sleep(0.1) # wait for 100ms
IO.output(5,1) # pull CLOCK pin high
time.sleep(0.1)
IO.output(5,0) # pull CLOCK pin down, to send a rising edge
IO.output(4,0) # clear the DATA pin
IO.output(6,1) # pull the SHIFT pin high to put the 8 bit data out parallel
time.sleep(0.1)
IO.output(6,0) # pull down the SHIFT pin
for y in range(8): # loop for counting up 8 times
IO.output(4,0) # clear the DATA pin, to send 0
time.sleep(0.1) # wait for 100ms
IO.output(5,1) # pull CLOCK pin high
time.sleep(0.1)
IO.output(5,0) # pull CLOCK pin down, to send a rising edge
IO.output(4,0) # keep the DATA bit low to keep the countdown
IO.output(6,1) # pull the SHIFT pin high to put the 8 bit data out paralle
l time.sleep(0.1)
IO.output(6,0)
Video Pengaplikasian
Cara Instal
Instalasi Fritzing Pastikan sistem anda memenuhi salah satu persyaratan ini :Windows - XP dan upMac - OSX 10.5 dan upLinux - sebuah distro linux yang lumayan baru dengan libc > = 2.6
1. Mulai men-download paket Fritzing yang tepat untuk Anda .
2. Unzip folder Fritzing Anda di suatu tempat nyaman pada hard drive Anda . Ini juga mungkin waktu yang baik bagi Anda untuk membuat shortcut ke aplikasi Fritzing Sebuah program unzip gratis dapat ditemukan di sini , jika Anda membutuhkannya . Jika Anda memperbarui pembebasan Anda dari Fritzing , file kustom Anda ( bagian dan sampah ) tidak disimpan dengan aplikasi tersebut , sehingga mereka tidak akan hancur jika Anda menghapus versi lama dari folder aplikasi Fritzing .
3. Untuk memulai Fritzing :
pada Windows : klik dua kali fritzing.exe
pada Mac : klik dua kali aplikasi Fritzing
pada Linux : klik dua kali Fritzing , atau mencoba / Fritzing di jendela shell Anda .
4. Jika Anda mengalami masalah , silakan coba download lagi . Hal ini sering membantu . Jika tidak , kita lihat forum kami .
5. Catatan Linux : rilis biner ini telah dibangun dan diuji di bawah Ubuntu LTS 10.4.2 . Distro untuk rasa lain dari linux dapat ditemukan di sini , dan di sini, ada satu-klik download untuk openSUSE , dan cari forum untuk bahkan lebih . Pengguna Fedora dapat menginstal Fritzing dengan ' yum install fritzing ' . Kami sungguh-sungguh berterima kasih openSUSE , Thomas Zimmermann , Debian.org , Bruno Canning , Fedora Project , Ed Marshall , dan orang-orang dan organisasi lain untuk membuat ini tersedia
1. Mulai men-download paket Fritzing yang tepat untuk Anda .
2. Unzip folder Fritzing Anda di suatu tempat nyaman pada hard drive Anda . Ini juga mungkin waktu yang baik bagi Anda untuk membuat shortcut ke aplikasi Fritzing Sebuah program unzip gratis dapat ditemukan di sini , jika Anda membutuhkannya . Jika Anda memperbarui pembebasan Anda dari Fritzing , file kustom Anda ( bagian dan sampah ) tidak disimpan dengan aplikasi tersebut , sehingga mereka tidak akan hancur jika Anda menghapus versi lama dari folder aplikasi Fritzing .
3. Untuk memulai Fritzing :
pada Windows : klik dua kali fritzing.exe
pada Mac : klik dua kali aplikasi Fritzing
pada Linux : klik dua kali Fritzing , atau mencoba / Fritzing di jendela shell Anda .
4. Jika Anda mengalami masalah , silakan coba download lagi . Hal ini sering membantu . Jika tidak , kita lihat forum kami .
5. Catatan Linux : rilis biner ini telah dibangun dan diuji di bawah Ubuntu LTS 10.4.2 . Distro untuk rasa lain dari linux dapat ditemukan di sini , dan di sini, ada satu-klik download untuk openSUSE , dan cari forum untuk bahkan lebih . Pengguna Fedora dapat menginstal Fritzing dengan ' yum install fritzing ' . Kami sungguh-sungguh berterima kasih openSUSE , Thomas Zimmermann , Debian.org , Bruno Canning , Fedora Project , Ed Marshall , dan orang-orang dan organisasi lain untuk membuat ini tersedia