Teknik Elektro LinksBarrier-Gate & Turnstile Interface, Thermostat, Relay Driver, Microcontroler Board

KISUNO – Dialek Pemrograman Ala Ladder Pada Arduino UNO

Tulisan ini adalah kopian dari blog KISUNO. Selamat membaca.

KISUNO adalah singkatan dari KIS (Keep It Simple) dan UNO (Arduino UNO).

KISUNO adalah dialek pemrograman mirip Ladder PLC untuk Arduino UNO (ATmega pada umumnya). Dialek ini saya kembangkan menggunakan bahasa pemrograman Forth. Dengan KISUNO, kita bisa memrogram board Arduino UNO (ATmega secara umum) secara

  • INTERAKTIF
  • TANPA IDE
  • TANPA PROGRAMMER/DOWNLOADER

INTERAKTIF artinya kita bisa berinteraksi secara langsung dengan mikrokontroler.Bagaimana bisa demikian? Karena Forth adalah interpreter. Seperti layaknya sebuah interpreter, kita memberikan perintah dan langsung direspon oleh mikrokontroler. Interaksi dilakukan melalui program komunikasi serial. Kita bisa menggunakan Hyperterminal, TeraTerm, picocom dan lain-lain.

TANPA IDE artinya kita tidak memerlukan IDE untuk mengetik dan menguji kode program. Karena Forth adalah interpreter dan juga dilengkapi dengan kompiler, maka proses pemrograman adalah semudah: Mengetik kode program –> Menekan ENTER –> Mendapatkan hasilnya.

Untuk program aplikasi, kita bisa mengetik kode program dan menyimpannya menjadi sebuah file Forth (ekstensi .fs pada umumnya) dan kemudian mengirimkannya ke interpreter Forth melalui program komunikasi serial.

TANPA PROGRAMMER artinya kita tidak memerlukan programmer atau downloader semacam AVRISPMKII atau USBASP untuk memrogram mikrokontroler. Karena Forth adalah interpreter dan sekaligus kompiler, maka kode program yang diterimanya akan langsung dikompilasi dan dijalankan.

Dengan demikian, kita bisa memangkas proses development yang umumnya adalah:

KETIK –> KOMPILASI –> LINK –> PROGRAM –> RUN

menjadi:

KETIK –> RUN

FlashForth

KISUNO saya kembangkan dalam lingkungan FlashForth, yakni versi Forth untuk mikrokontroler PIC18F, PIC24/30/33 dan ATMEL AVR ATmega.

Untuk mengetahui lebih detil mengenai FlashForth, berikut saya kutipkan penjelasan dari situsnya flashforth.com.

FlashForth is a Forth stamp system implemented on the Microchip 8-bit PIC18F and 16-bit PIC24, 30, 33 and the Atmel Atmega microcontroller families.

FlashForth also works on the popular Arduino UNO and MEGA boards.

FF (FlashForth) allows you to write and debug complex real-time applications. The complete system including the compiler is executing on the microcontroller.

A Forth interpreter, compiler, assembler, multitasker and user definable interrupts are provided.

A computer with a terminal emulator is used for communicating with FF via a serial or USB link. The Forth source files are edited and saved on the computer and uploaded to the microcontroller as Forth source code. A special ff-shell, written in python, provides command line editing, history and file transfer capabilities.

All microcontroller registers and memories can be read and written from the command line. When the application is ready, the application word address can be stored in the turnkey vector, and your autonomous embedded application has been set up.

FlashForth is mostly compatible with the ANS'94 standard. This guide describes the differences, and features not covered by the ANS'94 standard.

FlashForth is licensed according to the Gnu Public License v3.

If you feel that FlashForth has been useful for you, please contribute with a donation.

DESIGN PHILOSOPHY

The main idea with FlashForth is to enable a robust Forth stamp system that is easy to use.

The requirements were:
- Possibility to have data space in all types of memory.
  -> RAM EEPROM FLASH words to select the current dataspace
     Memory fetch and store that works with all kind of memory
  -> @ ! can branch to read/write routines based on address mapped memory types.
  -> No need for multiple copies of highlevel words for each memory type.
- Works with both block writeable and word writeable flash.
  -> Automatic ram buffer for flash writes.
  -> Enables multiple writes to flash solving all problems with word headers and DOES>
  -> Enables a peephole optimiser.
- Safe system with no need to reflash the kernel whatever the user throws at the system.
  -> Kernel write protection inside the flash write code.
  -> Address range check in flash block write routine or HW write protection.
  -> Cold literals can always be copied from write protected flash.
  -> At least the words EMPTY WARM can always be executed to reset the system to its initial state.
- Comfortable interactive way of working
  -> Made possible with the above features.
  -> Shell on PC for some offline intelligence (loading of files, flow control, commandline history, etc... )

KISUNO sebagai dialek pemrograman adalah sebuah program aplikasi dalam bahasa Forth yang mendefinisikan kata-kata yang siap digunakan untuk memrogram I/O pada board Arduino UNO.

Dalam bahasa Forth, fungsi disebut sebagai kata (word). Kumpulan kata-kata disebut sebagai kamus (dictionary). Jadi, KISUNO dapat disebut sebagai kamus yang terdiri dari kata-kata yang memungkinkan kita memrogram Arduino UNO dengan perintah-perintah yang mirip dengan Ladder PLC.

Contoh Program Dengan KISUNO

Dengan KISUNO, kita bisa memrogram Arduino UNO (ATmega pada umumnya) dengan cara yang unik seperti contoh berikut ini:

\ Jika I1=LOW maka Q1=ON
i1 ----> Q1
\ Jika I2=LOW maka Q2=ON
i2 ----> Q2
\ Jika I3=LOW dan Q2=ON maka Q3=ON
i3 Q2> and ----> Q3
\ Jika I4=Pulsed maka Toggle Q4 (on-->off, off-->on)
pi4 ----> tQ4

Menarik, bukan? Dan bagaimana menurut Anda dengan contoh kontrol Motor Starter STAR-DELTA berikut ini?

: kontroler
  cr ." kontroler start."
  cr ." tekan ENTER untuk selesai." cr
  \ contoh kontroler starter motor 3-fasa STAR-DELTA
  begin
    m1> ----> 5 rT1  \ reset Timer1 5s
    i1 ----> sM1     \ start
    M1> ----> T1     \ timer on 
    M1> mT1> and q2> and ----> Q1
    \ Q1=STAR on selama 5s
    M1> MT1> and q1> and ----> Q2
    \ Q2=DELTA setelah 5s
    i2 ----> rM1      \ stop

    key?
  until
  cr ." kontroler stop." cr
;

Bagaimana? Sangat menarik, bukan?

Rahasia KISUNO

Mungkin Anda bertanya bagaimana caranya sehingga kita bisa menciptakan dialek semacam KISUNO, semuanya tak lain adalah karena karakteristik dari Forth. Forth tidak hanya dikenal sebagai bahasa tingkat tinggi yang paling dekat dengan hardware, tapi juga dikenal sebagai Programming Language Tool. Dan Forth is extensible — dengan Forth, kita ibarat membuat bahasa pemrograman baru setiap kali kita membuat program aplikasi.

Dan satu hal lagi, Forth lebih dari sekedar bahasa pemrograman. Forth adalah sebuah cara atau metode dalam menyelesaikan masalah pemrograman. Filosofi Forth dapat Anda baca di sini.

Beberapa karakteristik Forth yang sangat menguntungkan dalam pembuatan dialek KISUNO antara lain adalah:

  • Kode program Forth adalah deretan kata-kata yang dikenali dan diinterpretasi kata demi kata secara berurutan. Kita bisa mendefinisikan kata-kata (fungsi) untuk membuat program kontrol Mesin Cuci open-loop sebagai berikut:
    : MESIN-CUCI
      Buka-Kran Sampai-Penuh Tutup-Kran
      Motor-WigWag-On Selama-10-Menit
      Buka-Kran Sampai-Kosong
    ;
  • Forth memiliki fungsi untuk mendefinisikan kata-kata yang tersusun dari kata-kata standar bawaan Forth.
  • Forth is extensible, artinya kita bisa mengembangkan bahasa pemrograman sesuai dengan domain masalah (aplikasi) yang kita buat.
  • Forth berbasis STACK. Forth menggunakan stack dalam setiap operasinya. Parameter fungsi diambil dari stack dan hasil dari fungsi dimasukkan ke stack.
  • Berbeda dengan bahasa konvensional seperti Basic atau C, kita bisa menghasilkan fungsi dengan lebih dari satu hasil (return-value). Bahkan, sebuah fungsi bisa mengembalikan 1 return-value pada satu kondisi, dan mengembalikan 5 return-value pada kondisi lain.
  • Karena Forth menggunakan stack dalam setiap operasinya, maka Forth menganut notasi Reverse Polish Notation (RPN). Setiap kata (fungsi) yang membutuhkan nilai parameter diawali dengan memasukkan nilai parameter ke dalam stack untuk kemudian diambil dan diproses oleh fungsi. Contoh: 4 5 +  ( 4 + 5 ). Ketika Forth membaca perintah tersebut, maka nilai 4 dan 5 akan dimasukkan stack. Selanjutnya, Forth mengenali + adalah kata yang mengambil 2 nilai dari stack dan mengembalikan hasil penjumlahannya ke dalam stack. Kata + didefinisikan sebagai : + ( n1 n2 — n ).

Galeri Foto Selama Eksperimen

Selama 2 bulan terakhir ini (September-Oktober 2016), saya mempelajari bahasa pemrograman Forth dan mulai mengembangkan KISUNO. Berikut ini adalah beberapa foto board Arduino UNO yang saya gunakan selama eksperimen untuk mengembangkan dialek KISUNO.

kisuno auxpic

flashforth_lcd kiswah4

ledison forth_pifs

c41-trafficlight-forth ledkeyforth

Video Demo

Penasaran bagaimana KISUNO beraksi? Simak beberapa video demo berikut ini.

Cuplikan Kode Program kisuno.fs

Pada saat ini, KISUNO masih dalam tahap awal pengembangan. Saat ini KISUNO memiliki fitur a.l.:

  • 5-channel INPUT dengan notasi (contoh pada I1):
    • I1 ( — n ) : input aktif-hi
    • i1 ( — n ) : input aktif-lo
    • pI1 ( — n ) : pulse input aktif-hi
  • 5-channel OUTPUT dengan notasi (contoh pada Q1):
    • Q1 ( n — ) : output Q1
    • tQ1 ( n — ) : toggle Q1
    • Q1> ( — n ) : baca status Q1
    • q1> ( — n ) : baca status NOT Q1
  • 10 Auxiliary-Contact / kontak-bantu (contoh pada M1):
    • M1 ( n — ) : output M1
    • sM1 ( n — ) : set M1
    • rM1 ( n — ) : reset M1
    • M1> ( — n ) : baca status M1
    • m1> ( — n ) : baca status NOT M1
  • akses LCD (LCD Keypad Shield)
    • lcd_init ( — )
    • lcd_data ( n — )
    • lcd_command ( n — )
    • lcd_home ( — )
    • lcd_line1 ( — )
    • lcd_line2 ( — )
    • lcd_xy1 ( n — )
    • lcd_xy2 ( n — )
    • lcd_clear ( — )
    • lcd_putc ( n — )
    • lcd_puts ( n — )
  • monitoring status I/O
    • status! ( — )

Untuk fungsi lain seperti TIMER dan COUNTER sedang saya kembangkan.

Berikut adalah cuplikan listing program kisuno.fs.

\ REGISTER GPIO
$23 constant PINB
$24 constant DDRB
$25 constant PORTB
$26 constant PINC
$27 constant DDRC
$28 constant PORTC
$29 constant PIND
$2a constant DDRD
$2b constant PORTD

\ LCD Keypad Shield
$1 constant lcd.rs
$2 constant lcd.enable
: lcd_init_pins
  lcd.enable DDRB mset
  lcd.enable PORTB mclr
  lcd.rs DDRB mset
  lcd.rs PORTB mclr
  DDRD c@ %11110000 or DDRD c!
;
: nop ;
: lcd_enable
  lcd.enable PORTB mset
  20 for nop next
  lcd.enable PORTB mclr
;
: write-hnibble ( n -- )
  $f0 and PORTD c@ $0f and or PORTD c!
  lcd_enable
;
: write-byte ( n -- )
  dup write-hnibble
  20 for nop next
  4 lshift write-hnibble
  20 for nop next
;
: lcd_command ( n -- )
  lcd.rs PORTB mclr
  write-byte
;
: lcd_data ( n -- )
  lcd.rs PORTB mset
  write-byte
;
: lcd_init
  lcd_init_pins
  #5 ms
  $05 $01 $06 $0c $28 $32 $33 2dup
  8 for lcd_command next ms
;
: lcd_home %10 lcd_command ;
: lcd_line1 $80 lcd_command ;
: lcd_line2 $c0 lcd_command ;
: lcd_xy1 1 - $80 + lcd_command ;
: lcd_xy2 1 - $c0 + lcd_command ;
: lcd_clear $01 lcd_command ;
: lcd_putc ( n -- ) lcd_data ;
: lcd_puts for c@+ lcd_putc next drop ;

: init_pins
  $00 DDRC c! \ PORTC input
  $3f PORTC c! \ with internal pullup
  $04 dup DDRD mset PORTD mclr
  $08 dup DDRD mset PORTD mclr
  $08 dup DDRB mset PORTB mclr
  $10 dup DDRB mset PORTB mclr
  $20 dup DDRB mset PORTB mclr
;
\ ---------------- kisuno
: not 0= ;
: ----> ;
: tf if 49 else 48 then ;

variable vI1
: I1 PINC c@ $02 and $02 = dup tf vI1 c! ;
: i1 I1 not ;
: pI1 i1 dup if #10 ms begin I1 until #10 ms then ;

variable vQ1
: Q1 dup tf vQ1 c! if $04 PORTD mset else $04 PORTD mclr then ;
: Q1> PORTD c@ $04 and $04 = dup tf vQ1 c! ;
: q1> Q1> not ;
: tQ1 if Q1> 0= Q1 then ;

variable vm1
: M1 vm1 c! ;
: M1> vm1 c@ ;
: m1> M1> not ;
: sM1 if -1 vm1 c! then ;
: rM1 if 0 vm1 c! then ;

: header s" kisuno ready" ;
: status s" I>11111 Q>00000" ;
: status!
 3 lcd_xy2
 vI5 c@ vI4 c@ vI3 c@ vI2 c@ vI1 c@
 lcd_putc lcd_putc lcd_putc lcd_putc lcd_putc
 12 lcd_xy2
 vQ5 c@ vQ4 c@ vQ3 c@ vQ2 c@ vQ1 c@
 lcd_putc lcd_putc lcd_putc lcd_putc lcd_putc
;

\ contoh program penggunaan dialek kisuno
\ kisuno - keep arduino simple
\ www.teknikelektrolinks.com / www.usbinov.com
\ --------------------------------------------
: kontroler
  reset
  init_pins
  lcd_init header lcd_puts
  lcd_line2 status lcd_puts

  cr ." kontroler start."
  cr ." tekan ENTER untuk selesai." cr
  begin
    i1 ----> Q1      \ if I1=LO, Q1=ON 
    pi2 ----> tQ2    \ toggle Q2 on I2 low-pulse
    i3 q4> ----> Q3  \ interlock dg Q4
    i4 q3> ----> Q4  \ interlock dg Q3
 
    status!
    key?
  until
  cr ." kontroler stop." cr
;

kontroler

Nah, demikian sekilas tentang KISUNO. Saya mohon dukungan dari Anda untuk dapat terus mengembangkan KISUNO.

KISUNO akan tersedia dalam versi GRATIS dan versi BERBAYAR. Mohon ditunggu rilisnya ya.

Terima kasih.

2 Comments

Add a Comment

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>