Laporan Akhir : Percobaan 6
1.) Prosedur [kembali]
- Siapkan komponen-komponen yang akan dirangkai sesuai percobaan
- Rangkai komponen pada breadboard
- Buka aplikasi Thonny IDE pada laptop
- Masukkan Listing program
- Hubungkan rangkaian breadboard dengan laptop
- Upload Listing program pada rangkaian
- Rangkaian sudah dapat dijalankan
2.) Hardware dan Diagram Blok [kembali]
A. Hardware
1. Raspberry Pi Pico
Raspberry Pi Pico adalah papan mikrokontroler berbiaya rendah dan berkinerja tinggi dengan antarmuka digital fleksibel, yang dibuat di atas silikon yang dirancang di Raspberry Pi . Fitur-fitur utamanya meliputi: Chip mikrokontroler RP2040 yang dirancang oleh Raspberry Pi di Inggris Raya. Prosesor dual-core ARM Cortex M0+, clock fleksibel yang berjalan hingga 133 MHz.
2. Potensimeter
Potensiometer tergolong sebagai variabel resistor. Dalam hal ini, potensiometer berfungsi sebagai pembagi tegangan yang bisa disesuaikan. Dengan demikian, nilai resistansi pada potensiometer bisa diatur sesuai dengan kebutuhan. Baik itu berdasarkan kebutuhan pemakaian ataupun pada rangkaian elektronika lainnya.
3. Motor Servo
Servo Motor adalah perangkat listrik yang digunakan pada mesin-mesin industri pintar yang berfungsi untuk mendorong atau memutar objek dengan kontrol yang dengan presisi tinggi dalam hal posisi sudut, akselerasi dan kecepatan, sebuah kemampuan yang tidak dimiliki oleh motor biasa.
Motor servo dikendalikan dengan memberikan Pulse Wide Modulation / PWM melalui kabel kontrol. Durasi "denyut" (pulse) yang diberikan akan menentukan posisi sudut putaran dari poros motor servo. Poros motor servo akan bergerak dan bertahan di posisi yang telah diperintahkan ketika durasi "denyut"nya telah diberikan. Motor servo akan mencoba menahan atau melawan dengan besarnya kekuatan torsi yang dimilikinya apabila ada yang mencoba memutar atau mengubah posisi tersebut. Posisi motor servo tidak akan seterusnya diam saja karena sinyal "denyut"nya harus diulang setiap 20 ms (mili second) untuk menginstruksikan agar tetap pada posisinya.
4. LCD (Light Crystall Display)
Layar LCD 16x2 adalah layar kristal cair yang dapat menampilkan 16 karakter di setiap dua barisnya, sehingga totalnya menjadi 32 karakter informasi. Layar ini umumnya digunakan untuk menampilkan informasi alfanumerik di berbagai perangkat elektronik.
Layar LCD 16x2 bekerja dengan mengendalikan kristal cair untuk menghalangi atau membiarkan cahaya masuk, sehingga tercipta karakter dan simbol di layar. Layar dikontrol dengan mengirimkan data dan perintah ke pengontrolnya, yang selanjutnya mengelola tampilan informasi.
B. Diagram Blok
3.) Rangkaian Simulasi dan Prinsip Kerja [kembali]
Gambar rangkaian percobaan 6
Prinsip Kerja:
Rangkaian diatas memiliki 1 Raspberry Pi Pico yang digunakan sebagai mikrokontroler master pada percobaan i2c, LCD yang telah dilengkapi modul I2C sebagai output (slave) yang menampilkan output dari potensiometer, motor servo yang digunakan sebagai output, dan potensiometer sebagai input.
Ketika potensiometer diputar dengan besar sudut yang ditentukan, akan sinyal analog akan dikirimkan ke Raspberry Pi Pico yang nantinya kan diubah menjadi sinyal digital melalui pin ADC nya. Sinyal digital yang dihasilkan akan dikirimkan melalui protokol I2C yang mana SDA pada Raspberry Pi Pico ke SDA LCD dan pin SCL Raspberry Pi Pico ke SCL LCD. Sinyal digital yang dihasilkan juga dikirimkan ke motor servo yang nantinya akan bergerak sesuai input potensiometer. Pada LCD akan menampilkan besar sudut yang di inputkan ke motor servo tersebut.
4.) Flowchart dan Listing Program [kembali]
Flowchart:
a. main.py
from machine import Pin, ADC, PWM, I2C
from pico_i2c_lcd import I2cLcd
import utime
# 1. Setup Potensiometer (GP26 = ADC0)
pot = ADC(Pin(26))
# 2. Setup Servo (GP15)
servo = PWM(Pin(15))
servo.freq(50) # Frekuensi PWM standar servo
# 3. Setup LCD I2C 16x2
I2C_ADDR = 0x27 # Alamat I2C LCD, bisa 0x3F tergantung modul
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) # GP0=SDA, GP1=SCL
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
# Fungsi untuk mapping nilai
def map_value(x, in_min, in_max, out_min, out_max):
return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
# Kalibrasi servo
SERVO_MIN_DUTY = 1500 # Duty cycle untuk 0°
SERVO_MAX_DUTY = 7500 # Duty cycle untuk 180°
while True:
# Baca nilai potensiometer
pot_value = pot.read_u16()
# Konversi ke sudut 0-180°
angle = map_value(pot_value, 0, 65535, 0, 180)
# Konversi sudut ke duty cycle
duty = map_value(angle, 0, 180, SERVO_MIN_DUTY, SERVO_MAX_DUTY)
servo.duty_u16(duty)
# Tampilkan di LCD
lcd.clear()
lcd.putstr("Sudut Servo:")
lcd.move_to(0, 1)
lcd.putstr(f"{angle} derajat")
utime.sleep_ms(200) # Delay untuk mengurangi flicker
b. lcdapi
# forked from https://github.com/T-622/RPI-PICO-I2C-LCD/
import time
class LcdApi:
# Implements the API for talking with HD44780 compatible character LCDs.
# This class only knows what commands to send to the LCD, and not how to get
# them to the LCD.
#
# It is expected that a derived class will implement the hal_xxx functions.
#
# The following constant names were lifted from the avrlib lcd.h header file,
# with bit numbers changed to bit masks.
# HD44780 LCD controller command set
LCD_CLR = 0x01 # DB0: clear display
LCD_HOME = 0x02 # DB1: return to home position
LCD_ENTRY_MODE = 0x04 # DB2: set entry mode
LCD_ENTRY_INC = 0x02 # DB1: increment
LCD_ENTRY_SHIFT = 0x01 # DB0: shift
LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on
LCD_ON_DISPLAY = 0x04 # DB2: turn display on
LCD_ON_CURSOR = 0x02 # DB1: turn cursor on
LCD_ON_BLINK = 0x01 # DB0: blinking cursor
LCD_MOVE = 0x10 # DB4: move cursor/display
LCD_MOVE_DISP = 0x08 # DB3: move display (0-> move cursor)
LCD_MOVE_RIGHT = 0x04 # DB2: move right (0-> left)
LCD_FUNCTION = 0x20 # DB5: function set
LCD_FUNCTION_8BIT = 0x10 # DB4: set 8BIT mode (0->4BIT mode)
LCD_FUNCTION_2LINES = 0x08 # DB3: two lines (0->one line)
LCD_FUNCTION_10DOTS = 0x04 # DB2: 5x10 font (0->5x7 font)
LCD_FUNCTION_RESET = 0x30 # See "Initializing by Instruction" section
LCD_CGRAM = 0x40 # DB6: set CG RAM address
LCD_DDRAM = 0x80 # DB7: set DD RAM address
LCD_RS_CMD = 0
LCD_RS_DATA = 1
LCD_RW_WRITE = 0
LCD_RW_READ = 1
def _init_(self, num_lines, num_columns):
self.num_lines = num_lines
if self.num_lines > 4:
self.num_lines = 4
self.num_columns = num_columns
if self.num_columns > 40:
self.num_columns = 40
self.cursor_x = 0
self.cursor_y = 0
self.implied_newline = False
self.backlight = True
self.display_off()
self.backlight_on()
self.clear()
self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)
self.hide_cursor()
self.display_on()
def clear(self):
# Clears the LCD display and moves the cursor to the top left corner
self.hal_write_command(self.LCD_CLR)
self.hal_write_command(self.LCD_HOME)
self.cursor_x = 0
self.cursor_y = 0
def show_cursor(self):
# Causes the cursor to be made visible
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def hide_cursor(self):
# Causes the cursor to be hidden
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def blink_cursor_on(self):
# Turns on the cursor, and makes it blink
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR | self.LCD_ON_BLINK)
def blink_cursor_off(self):
# Turns on the cursor, and makes it no blink (i.e. be solid)
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def display_on(self):
# Turns on (i.e. unblanks) the LCD
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def display_off(self):
# Turns off (i.e. blanks) the LCD
self.hal_write_command(self.LCD_ON_CTRL)
def backlight_on(self):
# Turns the backlight on.
# This isn't really an LCD command, but some modules have backlight
# controls, so this allows the hal to pass through the command.
self.backlight = True
self.hal_backlight_on()
def backlight_off(self):
# Turns the backlight off.
# This isn't really an LCD command, but some modules have backlight
# controls, so this allows the hal to pass through the command.
self.backlight = False
self.hal_backlight_off()
def move_to(self, cursor_x, cursor_y):
# Moves the cursor position to the indicated position. The cursor
# position is zero based (i.e. cursor_x == 0 indicates first column).
self.cursor_x = cursor_x
self.cursor_y = cursor_y
addr = cursor_x & 0x3f
if cursor_y & 1:
addr += 0x40 # Lines 1 & 3 add 0x40
if cursor_y & 2: # Lines 2 & 3 add number of columns
addr += self.num_columns
self.hal_write_command(self.LCD_DDRAM | addr)
def putchar(self, char):
# Writes the indicated character to the LCD at the current cursor
# position, and advances the cursor by one position.
if char == '\n':
if self.implied_newline:
# self.implied_newline means we advanced due to a wraparound,
# so if we get a newline right after that we ignore it.
pass
else:
self.cursor_x = self.num_columns
else:
self.hal_write_data(ord(char))
self.cursor_x += 1
if self.cursor_x >= self.num_columns:
self.cursor_x = 0
self.cursor_y += 1
self.implied_newline = (char != '\n')
if self.cursor_y >= self.num_lines:
self.cursor_y = 0
self.move_to(self.cursor_x, self.cursor_y)
def putstr(self, string):
# Write the indicated string to the LCD at the current cursor
# position and advances the cursor position appropriately.
for char in string:
self.putchar(char)
def custom_char(self, location, charmap):
# Write a character to one of the 8 CGRAM locations, available
# as chr(0) through chr(7).
location &= 0x7
self.hal_write_command(self.LCD_CGRAM | (location << 3))
self.hal_sleep_us(40)
for i in range(8):
self.hal_write_data(charmap[i])
self.hal_sleep_us(40)
self.move_to(self.cursor_x, self.cursor_y)
def hal_backlight_on(self):
# Allows the hal layer to turn the backlight on.
# If desired, a derived HAL class will implement this function.
pass
def hal_backlight_off(self):
# Allows the hal layer to turn the backlight off.
# If desired, a derived HAL class will implement this function.
pass
def hal_write_command(self, cmd):
# Write a command to the LCD.
# It is expected that a derived HAL class will implement this function.
raise NotImplementedError
def hal_write_data(self, data):
# Write data to the LCD.
# It is expected that a derived HAL class will implement this function.
raise NotImplementedError
def hal_sleep_us(self, usecs):
# Sleep for some time (given in microseconds)
time.sleep_us(usecs)
c. sensor lcd i2c
# forked from https://github.com/T-622/RPI-PICO-I2C-LCD/
import utime
import gc
from lcd_api import LcdApi
from machine import I2C
# PCF8574 pin definitions
MASK_RS = 0x01 # P0
MASK_RW = 0x02 # P1
MASK_E = 0x04 # P2
SHIFT_BACKLIGHT = 3 # P3
SHIFT_DATA = 4 # P4-P7
class I2cLcd(LcdApi):
#Implements a HD44780 character LCD connected via PCF8574 on I2C
def _init_(self, i2c, i2c_addr, num_lines, num_columns):
self.i2c = i2c
self.i2c_addr = i2c_addr
self.i2c.writeto(self.i2c_addr, bytes([0]))
utime.sleep_ms(20) # Allow LCD time to powerup
# Send reset 3 times
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
utime.sleep_ms(5) # Need to delay at least 4.1 msec
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
utime.sleep_ms(1)
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
utime.sleep_ms(1)
# Put LCD into 4-bit mode
self.hal_write_init_nibble(self.LCD_FUNCTION)
utime.sleep_ms(1)
LcdApi._init_(self, num_lines, num_columns)
cmd = self.LCD_FUNCTION
if num_lines > 1:
cmd |= self.LCD_FUNCTION_2LINES
self.hal_write_command(cmd)
gc.collect()
def hal_write_init_nibble(self, nibble):
# Writes an initialization nibble to the LCD.
# This particular function is only used during initialization.
byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA
self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytes([byte]))
gc.collect()
def hal_backlight_on(self):
# Allows the hal layer to turn the backlight on
self.i2c.writeto(self.i2c_addr, bytes([1 << SHIFT_BACKLIGHT]))
gc.collect()
def hal_backlight_off(self):
#Allows the hal layer to turn the backlight off
self.i2c.writeto(self.i2c_addr, bytes([0]))
gc.collect()
def hal_write_command(self, cmd):
# Write a command to the LCD. Data is latched on the falling edge of E.
byte = ((self.backlight << SHIFT_BACKLIGHT) |
(((cmd >> 4) & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytes([byte]))
byte = ((self.backlight << SHIFT_BACKLIGHT) |
((cmd & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytes([byte]))
if cmd <= 3:
# The home and clear commands require a worst case delay of 4.1 msec
utime.sleep_ms(5)
gc.collect()
def hal_write_data(self, data):
# Write data to the LCD. Data is latched on the falling edge of E.
byte = (MASK_RS |
(self.backlight << SHIFT_BACKLIGHT) |
(((data >> 4) & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytes([byte]))
byte = (MASK_RS |
(self.backlight << SHIFT_BACKLIGHT) |
((data & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytes([byte]))
gc.collect()
5.) Video Demo [kembali]
6.) Analisa [kembali]
7.) Download File [kembali]
HTML [disini]
Datasheet Raspberry Pi Pico [disini]
Datasheet Servo [disini]
Datasheet LCD [disini]
Datasheet Potensiometer [disini]
Video Demo [disini]
Komentar
Posting Komentar