LAPORAN TB MIKROPROSESSOR
Dalam dunia konstruksi modern, proses pencampuran semen merupakan salah satu tahap penting yang menentukan kekuatan dan kualitas struktur bangunan. Aktivitas ini, yang tampak sederhana, sebenarnya menuntut ketelitian dalam mengukur komposisi material, suhu lingkungan, serta waktu pengadukan. Namun, di lapangan, proses ini masih sering dilakukan secara manual, sehingga rentan terhadap kesalahan manusia dan inkonsistensi hasil. Hal ini bukan hanya mempengaruhi efisiensi kerja, tetapi juga dapat membahayakan keselamatan para pekerja.
Di tengah pesatnya perkembangan teknologi, terutama di bidang otomasi dan mikrokontroler, muncul peluang untuk menciptakan sistem yang mampu memantau dan mengendalikan proses pengadukan semen secara otomatis dan real-time. Salah satu teknologi yang dapat dimanfaatkan adalah mikrokontroler Raspberry Pi Pico, yang ringan, fleksibel, dan mendukung integrasi dengan berbagai sensor.
Oleh karena itu, dirancanglah sebuah sistem cerdas berbasis Raspberry Pi Pico yang dilengkapi dengan sensor suhu (NTC thermistor), sensor ketinggian (ultrasonik), dan sensor berat (load cell), serta indikator buzzer dan motor DC sebagai aktuator. Sistem ini bertujuan untuk menciptakan proses pengadukan semen yang lebih efisien, aman, dan terstandar.
Melalui perancangan dan implementasi sistem ini, diharapkan masyarakat, khususnya para pelaku di dunia teknik sipil dan pendidikan, dapat memperoleh solusi inovatif yang tidak hanya meningkatkan kualitas pekerjaan, tetapi juga menjadi media pembelajaran praktis dalam memahami penerapan teknologi otomasi dalam kehidupan nyata.
- Memenuhi tugas project demo Modul 4 Praktikum
Mikroprosesor dan Mikrokontroller
- Mampu merangkai suatu alat berupa project demo
berdasarkan materi yang dipelajari pada modul-modul sebelumnya
- Mampu membuat prototype project demo dan simulasi rangkaian project demo pada WOKWI
- Mampu menjelaskan prinsip kerja rangkaian project demo Sistem Cerdas Monitoring dan Pengendali Pengaduk Semen Otomatis
- Mikrokontroller
Mikrokontroler bekerja dengan membaca input dari sensor atau perangkat lain, kemudian memproses data tersebut berdasarkan program yang telah ditanamkan (firmware), dan memberikan output berupa sinyal untuk mengaktifkan aktuator atau perangkat lainnya. Mikrokontroler banyak digunakan karena bentuknya yang kecil, konsumsi daya rendah, serta kemudahan dalam pemrograman dan integrasi ke dalam sistem elektronik.
Beberapa merek dan jenis mikrokontroler yang populer di kalangan pengembang dan praktisi pendidikan antara lain adalah Arduino (dengan chip ATmega328), STM32, ESP32, dan Raspberry Pi Pico. Pemilihan jenis mikrokontroler biasanya disesuaikan dengan kompleksitas proyek, kebutuhan komunikasi data, jumlah input/output yang dibutuhkan, serta efisiensi daya dan harga.
- Raspberry Pi Pico
Raspberry Pi Pico adalah papan rangkaian elektronik yang di dalamnya terdapat komponen utama chip mikrokontroler RP2040, yang dirancang dan diproduksi oleh Raspberry Pi Foundatio. Tidak seperti komputer mini raspberry Pi lainnya yang menjalankan sistem operasi seperti Linux, Pico dirancang untuk tugas-tugas yang lebih sederhana dan langsung (embedded system), seperti membaca sensor, mengontrol perangkat, atau melakukan pengolahan data pada tingkat hardware. Adapun spesifikasi dari Raspberry Pi Pico adalah sebagai berikut:
Spesifikasi dari Raspberry Pi Pico sendiri dapat dilihat pada tabel dibawah
- PWM (Pulse Width Modulation)
PWM atau kepanjangan Pulse Width Modulation, dalam bahasa Indonesia biasa disebut Modulasi Lebar Pulsa. Pada prinsipnya, PWM adalah salah satu teknik modulasi yang mengubah lebar pulsa (pulse width) dengan nilai frekuensi dan amplitudo (tinggi pulsa) yang tetap. PWM Signal ini digunakan menghasilkan sinyal analog dari perangkat Digital yang salah satu contohnya adalah dari Mikrokontroler.
Pembagian Pin PWM:
Setiap Board Arduino memiliki pin PWM dan nilai frekuensi yang berbeda-beda. Karena pada percobaan nanti kita akan menggunakan board arduino nano, maka gunakan salah satu dari pin berikut 3, 5, 6, 9, 10, 11.
PWM pada arduino bekerja pada frekuensi 500Hz, artinya 500 siklus/ketukan dalam satu detik. Untuk setiap siklus, kita bisa memberi nilai dari 0 hingga 255. Ketika kita memberikan angka 0, berarti pada pin tersebut tidak akan pernah bernilai 5 volt (pin selalu bernilai 0 volt). Sedangkan jika kita memberikan nilai 255, maka sepanjang siklus akan bernilai 5 volt (tidak pernah 0 volt). Jika kita memberikan nilai 127 (kita anggap setengah
dari 0 hingga 255, atau 50% dari 255), maka setengah siklus akan bernilai 5 volt, dan setengah siklus lagi akan bernilai 0 volt. Sedangkan jika jika memberikan 25% dari 255 (1/4 * 255 atau 64), maka 1/4 siklus akan bernilai 5 volt, dan 3/4 sisanya akan bernilai 0 volt, dan ini akan terjadi 500 kali dalam 1 detik.
- ADC (Analog Digital Convertion)
ADC atau Analog to Digital Converter merupakan salah satu perangkat elektronika yang digunakan sebagai penghubung dalam pemrosesan sinyal analog oleh sistem digital. Fungsi utama dari fitur ini adalah mengubah sinyal masukan yang masih dalam bentuk sinyal analog menjadi sinyal digital dengan bentuk kode-kode digital. Ada 2 faktor yang perlu diperhatikan pada proses kerja ADC yaitu kecepatan sampling dan resolusi. Kecepatan sampling menyatakan seberapa sering perangkat mampu mengkonversi sinyal analog ke dalam bentuk sinyal digital dalam selang waktu yang tertentu. Biasa dinyatakan dalam sample per second (SPS). Sementara Resolusi menyatakan tingkat ketelitian yang dimilliki. Pada Arduino, resolusi yang dimiliki adalah 10 bit atau rentang nilai digital antara 0 - 1023. Dan pada Arduino tegangan referensi yang digunakan adalah 5 volt, hal ini berarti ADC pada Arduino mampu menangani sinyal analog dengan tegangan 0 - 5 volt. Pada Arduino, menggunakan pin analog input yang diawali dengan kode A( A0- A5 padaArduino Uno). Fungsi untuk mengambil data sinyal input analog menggunakan analogRead(pin);
- Komunikasi
- Sensor Load Cell HX711
Beban diletakkan di atas permukaan load cell → menyebabkan deformasi logam.
Deformasi mengubah resistansi pada strain gauge → menghasilkan sinyal tegangan yang sangat kecil.
Sinyal tegangan ini diperkuat oleh HX711 → diubah menjadi sinyal digital oleh ADC internal.
Data digital dikirim secara serial ke mikrokontroler untuk diolah dan ditampilkan.
Kelebihan sistem load cell + HX711 ini adalah presisinya tinggi, konsumsi daya rendah, dan sangat cocok digunakan dalam sistem monitoring berat seperti timbangan digital, alat ukur otomatis, dan sistem kendali material seperti dalam proyek pengadukan semen ini.
- NTC Sensor Module
- Sensor Ultrasonik HC-SR04
- OLED
Komponen OLED Display 0.96" I2C (SSD1306) |
Resolusi 128x64 piksel |
Ukuran Layar 0.96 inci (umum), juga tersedia versi 1.3", 1.5", dll |
Warna Tampilan Monokrom (Putih, Biru, atau Kuning ) |
Antarmuka Komunikasi I2C (umum), SPI (tersedia juga) |
Tegangan Operasi 3.3V – 5V DC |
Analog Input Pins 6 |
Konsumsi Daya Rendah (sekitar 20-30 mA) |
Ukuran Fisik Sekitar 27 mm x 27 mm x 4 mm (untuk versi 0.96") |
Refresh Rate Hingga 100 Hz (tergantung konfigurasi software) |
Suhu Operasional -40°C hingga +85°C |
Tipe Layar OLED (Organic Light Emitting Diode) |
- Buzzer
Komponen Buzzer |
Operating Voltage 3-24 V |
Rated Current 5 V |
Sound Type Continous Beep |
Resonant Frequency ~2300 Hz |
- Motor DC
- Resistor
Simbol :
Resistor
adalah komponen Elektronika Pasif yang memiliki nilai resistansi atau hambatan
tertentu yang berfungsi untuk membatasi dan mengatur arus listrik dalam suatu
rangkaian Elektronika (V=I R).
Jenis
Resistor yang digunakan disini adalah Fixed Resistor, dimana merupakan
resistor dengan nilai tetap terdiri dari film tipis karbon yang
diendapkan subtrat isolator kemudian dipotong berbentuk spiral. Keuntungan
jenis fixed resistor ini dapat menghasilkan resistor dengan toleransi yang
lebih rendah.
Cara
menghitung nilai resistor:
Tabel warna
Contoh :
Gelang ke 1 : Coklat =
1
Gelang ke 2 : Hitam =
0
Gelang ke 3 :
Hijau = 5 nol dibelakang angka gelang ke-2; atau kalikan 105
Gelang ke 4 :
Perak = Toleransi 10%
Maka nilai resistor
tersebut adalah 10 * 105 = 1.000.000 Ohm atau 1 MOhm dengan toleransi 10%.
c. Rangkaian Simulasi dan Prinsip Kerja[Kembali]
Rangkaian Simulasi Proteus :
Proyek ini dirancang sebagai sebuah sistem otomatis yang mampu memantau dan mengendalikan proses pengadukan semen secara cerdas dengan bantuan berbagai sensor dan mikrokontroler Raspberry Pi Pico. Sistem dimulai dari proses pembacaan parameter lingkungan dan material menggunakan tiga jenis sensor utama. Sensor NTC Thermistor berfungsi untuk mendeteksi suhu di sekitar area pengadukan. Sensor ini memiliki karakteristik resistansi yang menurun ketika suhu meningkat, sehingga perubahan resistansi ini kemudian dikonversi menjadi tegangan analog yang dibaca oleh pin ADC pada Raspberry Pi Pico. Selanjutnya, sensor ultrasonik HC-SR04 digunakan untuk mengukur ketinggian atau level campuran di dalam wadah dengan cara memancarkan gelombang ultrasonik dan mengukur waktu pantulan gelombang dari permukaan cairan atau material. Sensor ini memberikan sinyal digital yang dikalkulasi menjadi jarak berdasarkan waktu tempuh gelombang suara. Sementara itu, load cell yang dikombinasikan dengan modul HX711 digunakan untuk mengukur berat material semen dalam wadah. Modul HX711 akan mengkonversi sinyal analog dari strain gauge pada load cell menjadi data digital yang dikirim ke Raspberry Pi Pico melalui komunikasi serial.
Semua data dari sensor-sensor tersebut diterima oleh mikrokontroler Raspberry Pi Pico yang berperan sebagai pusat pengolah data. Mikrokontroler ini memproses semua input berdasarkan algoritma yang telah diprogram sebelumnya. Jika terdeteksi bahwa berat dari campuran telah melebihi batas yang di tetapkan, maka motor DC akan otomatis berputar. Jika terdeteksi bahwa campuran di dalam mesin pengaduk melebihi batas yang telah di tetapkan, maka sistem akan mengaktifkan buzzer sebagai alarm peringatan otomatis dan mematikan motr DC. Kemudian, jika terdeteksi suhu dari motor telah melebihi batas karena panas atau semacamnya, maka motor juga akan otomatis mati. Selain itu, Raspberry Pi Pico juga mengontrol motor DC sebagai aktuator utama untuk proses pengadukan, yang hanya akan aktif jika semua parameter berada dalam rentang yang aman dan sesuai. Untuk membantu pengguna memantau kondisi sistem, nilai dari seluruh sensor ditampilkan secara real-time melalui layar OLED I2C, sehingga pengguna dapat dengan mudah melihat suhu, berat, dan ketinggian campuran kapan saja.
d. Flowchart dan Listing Program[Kembali]
a) Raspberry Pi Pico 1
b) Raspberry Pi Pico 2
Listing Program :
a) Raspberry Pi Pico 1
1) Raspberry Pi Pico
from machine import Pin, ADC, I2C, UART
import time
import ssd1306
from math import log
uart = UART(1, baudrate=9600, tx=Pin(4), rx=Pin(5))
TRIG = Pin(14, Pin.OUT)
ECHO = Pin(15, Pin.IN)
NTC = ADC(26)
BUZZER = Pin(20, Pin.OUT)
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
def read_distance():
TRIG.low()
time.sleep_us(2)
TRIG.high()
time.sleep_us(10)
TRIG.low()
timeout = 10000
while ECHO.value() == 0:
start = time.ticks_us()
while ECHO.value() == 1:
end = time.ticks_us()
duration = time.ticks_diff(end, start)
return (duration * 0.0343) / 2
def read_temperature():
voltage = NTC.read_u16() * 3.3 / 65535
if voltage >= 3.29 or voltage <= 0.01:
return 999
try:
resistance = (10000 * voltage) / (3.3 - voltage)
temp_K = 3950 / (log(resistance / 10000) + (3950 / 298.15))
temp_C = temp_K - 273.15
return temp_C + 20
except:
return 999
while True:
try:
distance = read_distance()
temperature = read_temperature()
buzzer_status = "OFF"
berat_str = "-"
motor_status = "-"
if temperature >= 65:
uart.write("STOP\n")
BUZZER.on()
buzzer_status = "ON"
else:
uart.write("START\n")
BUZZER.off()
if distance <= 3:
BUZZER.on()
buzzer_status = "ON"
if uart.any():
msg = uart.readline().decode().strip()
if msg:
parts = msg.split("|")
if len(parts) == 2:
berat_str = parts[0].strip()
motor_status = parts[1].split(":")[1].strip()
oled.fill(0)
oled.text("Ketinggian: {:.1f}cm".format(distance), 0, 0)
oled.text(berat_str, 0, 16)
oled.text("Suhu: {:.1f} C".format(temperature), 0, 32)
oled.text("Buzzer: {}".format(buzzer_status), 0, 48)
oled.show()
print("Distance: {:.1f}, Temp: {:.1f}, {} | {}".format(
distance, temperature, berat_str, motor_status))
time.sleep(1)
except Exception as e:
print("Error:", e)
BUZZER.off()
time.sleep(1)
2) SSD1306
# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
from micropython import const
import framebuf
# Register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
class SSD1306:
def _init_(self, width, height, external_vcc, color=framebuf.MONO_VLSB):
self.width = width
self.height = height
self.external_vcc = external_vcc
self.pages = self.height // 8
self.buffer = bytearray(self.pages * self.width)
fb = framebuf.FrameBuffer(self.buffer, self.width, self.height, color)
self.framebuf = fb
# Mapping fungsi framebuffer
self.fill = fb.fill
self.pixel = fb.pixel
self.hline = fb.hline
self.vline = fb.vline
self.line = fb.line
self.rect = fb.rect
self.fill_rect = fb.fill_rect
self.text = fb.text
self.scroll = fb.scroll
self.blit = fb.blit
self.init_display()
def init_display(self):
for cmd in (
SET_DISP | 0x00,
SET_MEM_ADDR, 0x00,
SET_DISP_START_LINE | 0x00,
SET_SEG_REMAP | 0x01,
SET_MUX_RATIO, self.height - 1,
SET_COM_OUT_DIR | 0x08,
SET_DISP_OFFSET, 0x00,
SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
SET_DISP_CLK_DIV, 0x80,
SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
SET_VCOM_DESEL, 0x30,
SET_CONTRAST, 0xff,
SET_ENTIRE_ON,
SET_NORM_INV,
SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
SET_DISP | 0x01):
self.write_cmd(cmd)
self.fill(0)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def poweron(self):
self.write_cmd(SET_DISP | 0x01)
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
x0 = 0
x1 = self.width - 1
if self.width == 64:
x0 += 32
x1 += 32
self.write_cmd(SET_COL_ADDR)
self.write_cmd(x0)
self.write_cmd(x1)
self.write_cmd(SET_PAGE_ADDR)
self.write_cmd(0)
self.write_cmd(self.pages - 1)
self.write_data(self.buffer)
class SSD1306_I2C(SSD1306):
def _init_(self, width, height, i2c, addr=0x3c, external_vcc=False, color=framebuf.MONO_VLSB):
self.i2c = i2c
self.addr = addr
self.temp = bytearray(2)
super()._init_(width, height, external_vcc, color)
def write_cmd(self, cmd):
self.temp[0] = 0x80
self.temp[1] = cmd
self.i2c.writeto(self.addr, self.temp)
def write_data(self, buf):
self.i2c.writeto(self.addr, b'\x40' + buf)
class SSD1306_SPI(SSD1306):
def _init_(self, width, height, spi, dc, res, cs, external_vcc=False, color=framebuf.MONO_VLSB):
self.rate = 10 * 1024 * 1024
dc.init(dc.OUT, value=0)
res.init(res.OUT, value=0)
cs.init(cs.OUT, value=1)
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
import time
self.res(1)
time.sleep_ms(1)
self.res(0)
time.sleep_ms(10)
self.res(1)
super()._init_(width, height, external_vcc, color)
def write_cmd(self, cmd):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs(1)
self.dc(0)
self.cs(0)
self.spi.write(bytearray([cmd]))
self.cs(1)
def write_data(self, buf):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs(1)
self.dc(1)
self.cs(0)
self.spi.write(buf)
self.cs(1)
# Raspberry Pi Pico 2 - Motor & Load Cell Unit
from machine import Pin, UART, I2C
from time import sleep
from hx711 import HX711
import ssd1306
import sys
# Load Cell via HX711
hx = HX711(d_out=2, pd_sck=3)
# UART1 (TX=GP4, RX=GP5)
uart = UART(1, baudrate=9600, tx=Pin(4), rx=Pin(5))
# Motor on GP13
motor = Pin(13, Pin.OUT)
# OLED I2C0 (SDA=GP0, SCL=GP1)
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
# Kalibrasi
OFFSET = 1975.31
SCALE = 7.6
MIN_WEIGHT_GRAM = 100
motor_allowed = True # Awalnya boleh nyala
def get_weight_gram():
try:
raw = hx.read()
weight = (raw - OFFSET) / SCALE
if weight < 0:
weight = 0
return round(weight, 1), raw
except:
return 0.0, 0
while True:
try:
weight, raw_val = get_weight_gram()
# Cek perintah dari Raspi 1
if uart.any():
try:
cmd = uart.readline().decode().strip()
if cmd == "STOP":
motor_allowed = False
elif cmd == "START":
motor_allowed = True
except:
pass
# Kontrol motor
if weight > MIN_WEIGHT_GRAM and motor_allowed:
motor.on()
motor_status = "ON"
else:
motor.off()
motor_status = "OFF"
# Kirim berat dan status motor ke Raspi 1
try:
uart.write("Berat: {:.1f}g | Motor: {}\n".format(weight, motor_status))
except:
pass
# OLED output
try:
oled.fill(0)
oled.text("Berat: {:.1f} g".format(weight), 0, 0)
oled.text("Motor: {}".format(motor_status), 0, 16)
oled.show()
except:
pass
print("Berat: {:.1f} g (raw: {}) | Motor: {}".format(weight, raw_val, motor_status))
sleep(1)
except Exception as e:
sys.print_exception(e)
motor.off()
sleep(1)
from utime import sleep_us, time
from machine import Pin
from micropython import const
class HX711Exception(Exception):
pass
class InvalidMode(HX711Exception):
pass
class DeviceIsNotReady(HX711Exception):
pass
class HX711:
CHANNEL_A_128 = const(1)
CHANNEL_A_64 = const(3)
CHANNEL_B_32 = const(2)
DATA_BITS = const(24)
MAX_VALUE = const(0x7fffff)
MIN_VALUE = const(0x800000)
READY_TIMEOUT_SEC = const(5)
SLEEP_DELAY_USEC = const(80)
def _init_(self, d_out, pd_sck, channel=CHANNEL_A_128):
self.d_out_pin = Pin(d_out, Pin.IN)
self.pd_sck_pin = Pin(pd_sck, Pin.OUT, value=0)
self._channel = channel
def _convert_from_twos_complement(self, value):
if value & (1 << (self.DATA_BITS - 1)):
value -= 1 << self.DATA_BITS
return value
def _set_channel(self):
for _ in range(self._channel):
self.pd_sck_pin.value(1)
self.pd_sck_pin.value(0)
def _wait(self):
start_time = time()
while not self.is_ready():
if time() - start_time > self.READY_TIMEOUT_SEC:
raise DeviceIsNotReady()
def is_ready(self):
return self.d_out_pin.value() == 0
def power_off(self):
self.pd_sck_pin.value(0)
self.pd_sck_pin.value(1)
sleep_us(self.SLEEP_DELAY_USEC)
def power_on(self):
self.pd_sck_pin.value(0)
self._set_channel()
def read(self, raw=False):
self._wait()
raw_data = 0
for _ in range(self.DATA_BITS):
self.pd_sck_pin.value(1)
self.pd_sck_pin.value(0)
raw_data = (raw_data << 1) | self.d_out_pin.value()
self._set_channel()
return raw_data if raw else self._convert_from_twos_complement(raw_data)
f. Download File[Kembali]
- Download HTML klik disini
- Download File Rangkaian klik disini
- Download Gambar Rangkaian klik disini
- Download Video Simulasi klik disini
- Download Library Sensor Arduino klik disini
- Download Library Sensor Ultrasonik klik disini
- Download Library Sensor Thermistor NTC klik disini
- Download Library Sensor Load Cell klik disini
- Download Datasheet Sensor Arduino klik disini
- Download Datasheet Sensor Infrared klik disini
- Download Datasheet Sensor Flame klik disini
- Download Datasheet Sensor PIR klik disini
- Download Datasheet Resistor klik disini
- Download Datasheet Transistor NPN klik disini
- Download Datasheet OPAMP klik disini
- Download Datasheet LED klik disini
- Download Datasheet Motor DC klik disini
- Download Datasheet Buzzer klik disini
- Download Datasheet Relay klik disini
- Download Datasheet Baterai klik disini
- Download Datasheet Dioda klik disinii
- Download Datasheet Switch klik disini
Komentar
Posting Komentar