Belajar Pemrograman Python: membuat fractal segitiga (Rekursif)

Postingan ini adalah kelanjutan dari postingan sebelumnya Belajar Pemrograman Python: membuat fractal segitiga. Pembahasan kali ini lebih ke arah penggunaan teknik rekursif untuk pemecahan masalah yang sama. (Sebaiknya pelajari terlebih dahulu postingan sebelumnya tentang Belajar Pemrograman Python: membuat fractal segitiga)

Pada postingan sebelumnya terdapat lima (5) buah function utama untuk bisa menggambar (membuat fractal segitiga). kelima function itu adalah:

      triangle_1(some_pen,size)   #untuk membuat segitiga kecil (level 0)

      triangle_2(some_pen,size)   #untuk membuat segitiga lebih besar (level 1)

      triangle_3(some_pen,size)   #untuk membuat segitiga lebih besar (level 2)

      triangle_4(some_pen,size)   #untuk membuat segitiga lebih besar (level 3)

      draw()                      #untuk setting pena dan menjalankan triangle_4

dari kelima function tersebut, Kita akan fokus pada 4 function utama untuk membuat susunan segitiga fractal yaitu triangle+1, triangle_2, triangle_3, dan triangle_4. Perhatikan lagi bahwa function yang dipanggil adalah triangle_4, dan saat triangle_4 dieksekusi maka dia akan memanggil triangle_3, saat triangle_3 dieksekusi maka akan memanggil triangle_2, dan saat triangle_2 dieksekusi akan memanggil triangle_1. 

Dari sini dapat kita pelajari bahwa function triangle_2, triangle_3, dan triangle_4 sangat identik sehingga dapat diringkas menjadi suatu function yang bersifat rekursif. 

Sedangkan triangle_1 adalah sebagai function paling dasar. Oleh karena itu pada saat membuat function rekursif maka triangle_1 akan menjadi bagian paling ujung (stoping, penyetop fungsi rekursif).

Baik, berikut adalah function rekursif (saya namakan fractal) yg sudah Saya buat berdasar function triangle sebelumnya.

def fractal(level,some_pen,size):
    if (level==0):
        some_pen.begin_fill()
        some_pen.right(60)
        for i in range(1,3):
            some_pen.forward(size)
            some_pen.right(120)
        some_pen.forward(size)
        some_pen.end_fill()
    else:
        fractal(level-1,some_pen,size)
        some_pen.right(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.left(60)
        fractal(level-1,some_pen,size)
        some_pen.left(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.right(180)
        fractal(level-1,some_pen,size)
        some_pen.forward((2**(level-1))*size)


function ini memiliki tiga parameter input yaitu level, some_pen, dan size. Kalo dibandingkan dengan function triangle sebelumnya yang hanya dua parameter maka ada satu parameter tambahan yang berbeda yaitu "level". Parameter "level" ini menentukan mau membuat gambar segitiga fraktal sampai level berapa. Dengan catatan level 0 adalah saat hanya menggambar segitiga kecil saja. sebagai contoh dipostingan sebelumnya Saya hanya menggambar segitiga fraktal sampai dilevel 3 atau sampai di triangle_4.

Perhatikan bahwa if (level==0) berisi barisan perintah persis seperti function triangle_1. Karena ini akan menjadi bagian ujung (tidak lagi memanggil function yang lain saat dijalankan).

Sedangkan pada bagian else, berisi barisan perintah yang hampir sama dengan function triangle_2, triangle_3 dan triangle_4. Yang mana "function fractal" ini juga memanggil "dirinya sendiri" pada level yang lebih rendah. Hal ini juga terjadi pada function triangle_4 yang memanggil triangle_3 dan seterusnya.

Dengan menggunakan "function fractal" ini, jika kita ingin membuat segitiga fraktal level 7 misalnya, maka cukup memanggil function ini dengan menyertakan level 7 sebagai input. Tidak perlu membuat function ulang triangle_7, triangle_6, triangle_5, dan seterunya. Sehingga source code lebih ramping dan lebih mudah dibaca. (Pada contoh kasus ini lebih efisien).

Berikut adalah kode lengkapnya:


import turtle

def fractal(level,some_pen,size):
    if (level==0):
        some_pen.begin_fill()
        some_pen.right(60)
        for i in range(1,3):
            some_pen.forward(size)
            some_pen.right(120)
        some_pen.forward(size)
        some_pen.end_fill()
    else:
        fractal(level-1,some_pen,size)
        some_pen.right(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.left(60)
        fractal(level-1,some_pen,size)
        some_pen.left(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.right(180)
        fractal(level-1,some_pen,size)
        some_pen.forward((2**(level-1))*size)

def draw():
    window = turtle.Screen()
    window.bgcolor("red")

    pen = turtle.Turtle()

    pen.penup()
    pen.sety(200)
    pen.pendown()

    pen.shape("turtle")
    pen.color("blue")
    pen.speed(1)

    fractal(5,pen,10)

    window.exitonclick()

draw()
 

Dan berikut adalah hasil runningnya:

Developed by: 

Muhammad Nurul Puji

Project-H

Belajar Pemrograman Python: membuat fractal segitiga

Saat ini banyak sekali media-media pembelajaran online baik gratis maupun berbayar. Nah saat ini Saya mencoba untuk memanfaatkan pembelajaran online melalui Udacity. Udacity menyediakan kursus gratis maupun paket berbayar. Yang akan Saya share di sini adalah salah satu tugas dari kursus "Programming Foundations with Python" di Udacity, kursus ini gratis kok (sejauh ini gratis.hehe). Nah kira-kira salah satu tugasnya adalah membuat program untuk menggambar segitiga sebagai berikut:

Salah satu tugas di Udacity

Sebenernya di forum diskusi yang disediakan sudah ada peserta lain yang share codenya sih, tapi karena agak ribet maka Saya putuskan untuk mencoba menyelesaikan tugas ini sendiri.

Baik, Kalo kita perhatikan maka komponen dasar pembentuk gambar tersebut adalah segitiga kecil berwarna biru. Kemudian segitiga kecil ini disusun sedemikian hingga, sehigga terbentuk segitiga besar. Oiya abaikan gambar kura-kura dibagian atas, karena itu hanya ujung pena untuk menggambar (library yang digunakan adalah turtle). Intinya library ini digunakan untuk menggambar hehe. Lebih detil silahkan pelajari dokumentasi Library turtle.

Pertama gambar segitiga kecil berikut:

segitiga kesatu

Berikut adalah function tiangle_1 untuk menggambar segitiga biru kecil (segitiga kesatu):

 def triangle_1(some_pen,size):
    some_pen.begin_fill()
    some_pen.right(60)

    some_pen.forward(size)
    some_pen.right(120)

    some_pen.forward(size)
    some_pen.right(120)

    some_pen.forward(size)
    some_pen.end_fill()

Penjelasan: Gambar kura-kura menunjukkan pena/bulpoint. Default awalnya adalah pena menghadap ke kanan secara horisontal. Oiya untuk membuat segitiga diperlukan tiga garis. Dalam program ini Saya menggambar dari atas, samping kanan, bawah, samping kiri, dan balik ke atas. 

Karena awalnya pena menghadap ke kanan, maka perlu Saya putar sebesar 60 derajat kekanan (some_pen.right(60)), kemudian pena saya gerakkan sepanjang ukuran yang dikehendaki (some_pen.forward(size)). Sampai sini terbentuk garis samping kanan.

Untuk melanjutkan pergerakan pena membentuk garis dibagian bawah maka pena diputar 120 derajat kekanan (some_pen.right(120)) dan kemudian pena saya gerakkan sepanjang ukuran yang dikehendaki (some_pen.forward(size)). Sampai sini terbentuk garis bagian bawah.

Sekarang saatnya melanjutkan untuk menggambar garis sebelah kiri. Untuk itu maka pena saya putar lagi sebesar 120 derajat kekanan (some_pen.right(120)) dan kemudian pena saya gerakkan sepanjang ukuran yang dikehendaki (some_pen.forward(size)). Sampai sini terbentuk garis samping kiri.

Posisi pena terakhir adalah di bagian puncak atas menghadap ke atas (miring)

Perhatikan dibagian awal terdapat perintah some_pen.begin_fill() dan dibagian akhir terdapat some_pen.end_fill(). Hal ini untuk membuat segitiga terisi dengan warna (biru) ditengahnya.

Sekali lagi perhatikan bahwa terdapat adanya pengulangan kode dibagian tengah, sehingga kode dapat disimplifikasi menggunakan loop. Berikut kode (function) membuat segitiga menggunakan loop:

def triangle_1(some_pen,size):
    some_pen.begin_fill()
    some_pen.right(60)
    for i in range(1,3):
        some_pen.forward(size)
        some_pen.right(120)
    some_pen.forward(size)
    some_pen.end_fill()

Kedua, Gambar susunan segitiga berikut: 

segitiga kedua

Berikut adalah function untuk menggambar segitiga kedua:

def triangle_2(some_pen,size):
    triangle_1(some_pen,size)
    some_pen.right(120)
    some_pen.forward(size)
    some_pen.left(60)
    triangle_1(some_pen,size)
    some_pen.left(120)
    some_pen.forward(size)
    some_pen.right(180)
    triangle_1(some_pen,size)
    some_pen.forward(size) 

Perhatikan bahwa gambar segitiga kedua tersusun dari tiga segitiga kesatu. Secara umum langkahnya adalah membuat segitiga kecil atas, kemudian kanan bawah, kemudian kiri bawah.

sehingga langkah pertama adalah menggambar segitiga atas dengan memanfaatkan function triangle_1:
    triangle_1(some_pen,size)

kemudian memindahkan pena kebagian bawah kanan dari segitiga kesatu (dan juga setelah sampai dibawah, arahkan pena kembali mendatar kearah kanan, karena untuk menggambar segitiga kecil defaultnya adalah pena mendatar kekanan):

    some_pen.right(120)
    some_pen.forward(size)

    some_pen.left(60)  #untuk mengarahkan pena kembali mendatar arah kanan

Kemudian menggambar segitiga kanan bawah dengan memanfaatkan function triangle_1:

    triangle_1(some_pen,size)

kemudian memindahkan pena kebagian bawah kiri dari segitiga kesatu (dan juga setelah sampai dibawah, arahkan pena kembali mendatar kearah kanan, karena untuk menggambar segitiga kecil defaultnya adalah pena mendatar kekanan):

    some_pen.left(120)
    some_pen.forward(size)
    some_pen.right(180)  #untuk mengarahkan pena kembali mendatar arah kanan

Kemudian menggambar segitiga kiri bawah dengan memanfaatkan function triangle_1:

    triangle_1(some_pen,size)

Untuk memudahkan routing berikutnya maka dibagian akhir, Posisi pena adalah selalu di bagian puncak atas menghadap ke atas (miring):

    some_pen.forward(size)  #untuk memindahkan pena ke puncak atas (miring)

Ketiga, Gambar susunan segitiga berikut:

 

segitiga ketiga

Perhatikan dengan seksama bahwa gambar segitiga kedua tersusun dari tiga segitiga kedua. Secara umum langkahnya adalah membuat segitiga kedua dibagain atas, kemudian kanan bawah, kemudian kiri bawah. Langkah ini sangat mirip dengan langkah pada saat menggambar segitiga kedua.

Jika pada saat menggambar segitiga kedua adalah memanfaatkan segitiga kesatu (triangle_1). Maka untuk menggambar segitiga ketiga ini memanfaatkan segitiga kedua (triangle_2). 

Berikut adalah function untuk menggambar segitiga ketiga:

def triangle_3(some_pen,size):
    triangle_2(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*size)   #perpindahan masing-masing sisi menjadi dua kali
    some_pen.left(60)
    triangle_2(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*size)   #perpindahan masing-masing sisi menjadi dua kali

    some_pen.right(180)
    triangle_2(some_pen,size)
    some_pen.forward(2*size)   #perpindahan masing-masing sisi menjadi dua kali

 

Keempat, Gambar susunan segitiga berikut:

 

segitiga keempat

Berikut adalah function untuk menggambar segitiga keempat:

def triangle_4(some_pen,size):
    triangle_3(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*2*size)
    some_pen.left(60)
    triangle_3(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*2*size)
    some_pen.right(180)
    triangle_3(some_pen,size)
    some_pen.forward(2*2*size)

##pembahasan sama dengan bagian ketiga

Bagian kelima:

Bagian kelima ini adalah bertugas untuk mempersiapkan pena dan memanggil fungsi untuk menggambar (triangle_4). Disini Saya membuat function bernama draw sebagai berikut:

def draw():
    window = turtle.Screen()   #instansiasi screen (aktivasi screen)
    window.bgcolor("red")      #set background screen berwarna merah

    pen = turtle.Turtle()      #instansiasi pena

    pen.penup()                #angkat pena (supaya bisa dipindahkan posisinya)
    pen.sety(100)              #memindahkan posisi pena (optional)
    pen.pendown()              #menurunkan pena (siap untuk menulis/menggambar)

    pen.shape("turtle")        #set bentuk pena (berbentuk kura-kura)
    pen.color("blue")          #set warna pena
    pen.speed(1)               #set kecepatan gerak pena

    triangle_4(pen,20)         #memanggil fungsi triangle_4 untuk menggambar

    window.exitonclick()       #menutup window hanya jika diklik (setelah selesai menggambar)

Bagian keenam:

Dibagian ini Saya tunjukkan secara utuh source codenya. Termasuk import modul turtle. Dan dibagian akhir adalah dengan memanggil function draw().

Berikut source code keseluruhan:

import turtle

def triangle_1(some_pen,size):
    some_pen.begin_fill()
    some_pen.right(60)
    for i in range(1,3):
        some_pen.forward(size)
        some_pen.right(120)
    some_pen.forward(size)
    some_pen.end_fill()

def triangle_2(some_pen,size):
    triangle_1(some_pen,size)
    some_pen.right(120)
    some_pen.forward(size)
    some_pen.left(60)
    triangle_1(some_pen,size)
    some_pen.left(120)
    some_pen.forward(size)
    some_pen.right(180)
    triangle_1(some_pen,size)
    some_pen.forward(size)

def triangle_3(some_pen,size):
    triangle_2(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*size)
    some_pen.left(60)
    triangle_2(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*size)
    some_pen.right(180)
    triangle_2(some_pen,size)
    some_pen.forward(2*size)

def triangle_4(some_pen,size):
    triangle_3(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*2*size)
    some_pen.left(60)
    triangle_3(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*2*size)
    some_pen.right(180)
    triangle_3(some_pen,size)
    some_pen.forward(2*2*size)

def draw():
    window = turtle.Screen()
    window.bgcolor("red")

    pen = turtle.Turtle()

    pen.penup()
    pen.sety(100)
    pen.pendown()

    pen.shape("turtle")
    pen.color("blue")
    pen.speed(1)

    triangle_4(pen,20)

    window.exitonclick()

draw()

Berikut adalah hasil runningnya:

Dengan menggunakan kode diatas kita juga dapat memodifikasi untuk membuat segitiga serupa yang lebih besar tingkatannya, namun harus menambah kode misal triangle_5, triangle_6, dst. 

Teman-teman juga dapat menyederhanakan koding tersebut dengan teknik rekursif. Dengan teknik rekursif maka akan lebih simple jika kita menginginkan gambar pada tingkat tertentu.

Developed by: 

Muhammad Nurul Puji

Project-H

Revisi Library Modul ADC MCP3424 pada Arduino

Late post, seharusnya sekitar bulan September 2017. 


Pada postingan kali ini Saya akan membahas mengenai library untuk modul ADC MCP3424. Library untuk Arduino ini awalnya Saya download dari https://github.com/battosai30/MCP3424. (Kalau tidak salah Saya download sekitar bulan Juli atau Agustus 2017)

Oiya sebelumnya perlu Saya infokan bahwa modul ADC MCP3424 ini merupakan IC untuk mengkonversi sinyal analog menjadi sinyal digital. IC ini memiliki resolusi 18 bits. Untuk berkomunikasi dengan mikrokontroler, IC ini menggunakan protokol I2C. IC ini juga sudah memiliki PGA (Programmable Gain Amplifier - sebesar 1x, 2x, 4x dan 8x) didalamnya, sehingga sinyal yang kecil bisa langsung dikuatkan dengan cara memprogram IC ini. Range kerja IC ini adalah -2,048 V sampai +2,048 V (setelah dikuatkan melalui PGA). Untuk lebih detil silahkan cek di datasheet MCP3424.

Cara mudah menggunakan IC ini adalah dengan mencari dan menggunakan library yang sudah tersedia (jika ada hehehe). Dan Alhamdulillah sudah ada yang membuat dan membagikan library tersebut. Library untuk Arduino ini awalnya Saya download dari https://github.com/battosai30/MCP3424. Saya download sekitar bulan juli 2017 kalo tidak salah.

Yang akan Saya share disini adalah adanya sedikit kesalahan pada saat pembacaan. Perbaikan ini juga sudah Saya sampaikan ke pembuat library awal (batto@hotmail.fr). Kira-kira begini ceritanya.hehe Mohon maaf jika bahasa inggrisnya kacau.

##the first problem dealed with negative number
in the previous version, the conversion (for example from 18 to 32 bits format)
is just by using adding ('or' logic) the magnitute value 0x xxxxxxxx xxxxxxxx with 10000000 00000000 00000000 00000000
this will give result 10000000 0000000x xxxxxxxx xxxxxxxx
the problem is 10000000 0000000x xxxxxxxx xxxxxxxx (32 bits format) is not the same number with 1x xxxxxxxx xxxxxxxx (18 bits format)
lets take an example if we have 11 11111111 11111110 (18 bits format) = -2 (decimal)
conversion --> 01 11111111 11111110 (magnitute only) + 10000000 00000000 00000000 00000000 = 10000000 00000001 11111111 11111110 (32 bits format) = -2147352578 (decimal)
and it is big different number (that the problem)

considering two's complement concept for negative number (it was mention in datasheet that negative number format deal with two's complement concept).
so the conversion should be done by using:
adding ('or' logic) the magnitute value 00000000 0000000x xxxxxxxx xxxxxxxx with 11111111 11111110 00000000 00000000
with the same example if we have 11 11111111 11111110 (18 bits format) = -2
conversion --> 01 11111111 11111110 (magnitute only) + 11111111 11111110 00000000 00000000 = 11111111 11111111 11111111 11111110 (32 bits format) = -2 (decimal)
and the problem solved.

considering datasheet again for 18 bits format, the data will take 3 bytes or 24 bits. and for negative number the data format is
1111111x xxxxxxxx xxxxxxxx (without extract the magnitute value) and we just need to add ('or' logic) with 11111111 00000000 00000000 00000000 (0xFF000000 in hex)
so the conversion will result 11111111 1111111x xxxxxxxx xxxxxxxx

considering datasheet again for 16, 14, 12 bits format, the data will take 2 bytes or 16 bits, so for negative conversion
we just need to add ('or' logic) with 11111111 11111111 00000000 00000000 (0xFFFF0000 in hex)


##the second problem dealed with positive magnitute extraction on 14 and 12 bits format
in previous version, for 14 bits:
_resultat = (((long)_buffer[0] & 0xBF) << 8) | ((long)_buffer[1] & 0xFF);
it should be:
_resultat = (((long)_buffer[0] & 0x1F) << 8) | ((long)_buffer[1] & 0xFF);    
//0x1F (0b00011111) because in 14 bits, the magnitute started from 13rd bit (or from 5th bit in first byte)


in previous version, for 12 bits:
_resultat = (((long)_buffer[0] & 0x0F) << 8) | ((long)_buffer[1] & 0xFF);
it should be:
_resultat = (((long)_buffer[0] & 0x07) << 8) | ((long)_buffer[1] & 0xFF);    
//0x07 (0b00000111) because in 12 bits, the magnitute started from 11st bit (or from 3rd bit in first byte)

Berikut adalah link untuk download Library MCP3424 Revisi

Sebagai catatan, pada saat Saya mencoba dengan simulasi proteus ISIS terdapat masalah pada range nilai negatif. Oiya ini hanya saat simulasi di proteus ISIS (mudah-mudahan saat ini sudah diperbaiki oleh Proteus ISIS)

##the third problem dealed with the range for negative number
after trial updated library in Proteus ISIS simulation, i found the problem again.
now is about the negative range, in datasheet i found the range should be -1 LSB to -VRef
but in simulation the range is inverted (from -VRef to -1 LSB)
so i use this formula (for 18 bits):
_resultat = (-1) - _resultat + (-131071) ;
the negative range should be -1 to -131072 for 18 bit
because there is bit for 0 (zero) number in bitween negative and positive number, i choose -131071 instead

for 16 bits:
_resultat = (-1) - _resultat + (-32767) ;
for 14 bits:
_resultat = (-1) - _resultat + (-8191) ;
for 12 bits:
_resultat = (-1) - _resultat + (-2047) ;

Berikut adalah link untuk download Library MCP3424 Revisi (untuk simulasi Proteus ISIS)

Screenshoot saat simulasi Proteus ISIS

Revised by: 

Muhammad Nurul Puji

to support Project-G