MENGUJI BOARD ARDUINO

      Perlu diketahi papan Arduino uno memiliki LED indikator  output pada pin13, sehingga untuk menguji board arduino uno anda tidak perlu lagi menggunakan LED tambahan, hal yang perlu anda lakukan untuk menguji papan Arduino yang anda miliki adalah ;

1.Bukalah Softwere Arduino IDE.

 

Gambar 2.6 Tampilan Awal Softwere Arduino IDE

2.Setelah itu bukalah Berkas  » Contoh » 01.Basics » Blink, Sehingga muncul program seperi pada gambar dibawah ini.

 

Gambar 2.7 Contoh Program

3.Pemilihan Papan Arduino 

Setelah itu pilihlah jenis Papan Arduino dengan cara klik Alat dan Pilih Papan seperti pada gambar dibawah ini. Namun perlu dikeahui pemilihan papan arduino harus sesuai dengan tipe Arduino yang anda gunakan seperti yang diketahui pada bab sebelumnya saya menggunakan papan Arduino Uno oleh sebab itu saya memilih papan arduino uno sebagai pilihanya namun jika anda mengunakan papan dengan tipe/ jenis Arduino yang berbeda maka pilihlah sesuai dengan yang anda gunakan.

 

Gambar 2.8 Pemilihan Board Arduino

4.Verify (Mengkompilasi Program)

Verify (Mengkompilasi) bertujuan untuk mengetahui kesalahan danjuga berguna untuk mengubah bahasa Pemprogramnan/ Sketch yang kita buat kedalam bahasa mesin atau kedalam format HEX sehingga dapat dijalankan oleh mikrokontroler atau papan Arduino.

Seperti yang kita ketahui bahwa Arduino IDE sendiri memiliki beberapa fasilitas di antaranya adalah Verify (Mengkompilasi Program) sehingga kita tidak perlu lagi menggunakan external Verify (Mengkompilasi Program), untuk MemVerify (Mengkompilasi Program) anda cukup menekan icon   ( Verify ) seperti pada gambar dibawah ini.

 

Gambar 2.9 Proses Kompilasi Program

Setelah Proses Verify/ Kompilasi selesai perhatikan Program/ Sketch apakah masih terdapat kesalahan atau tidak,jika masih terdapat kesalahan maka tampilanya akan menunjukanseperti pada gambar 5.10, pada bagian bawah yang berwarna jingga menunjukan kesalahan pada bagian sebelum digitalWrite yang digaris dengan warna merah jambu pada bagian Program, maka ceklah Program/ Sketch yang berada diatasnya  atau sebelumnya,perbaikilah program setelah itu Verify/dikompilasi kembali, jika sudah tidak ada kesalahan tampilanya akan berubah hal ini ditunjukan pada gambar 5. 11 disana tertulis selesai mengkompilasi dan proses selanjutnya adalah mengupload program.

Gambar 2.10 Kompilasi yang Masih Terdapat Kesalahan

Gambar 2.11 Kompilasi yang Berhasi

5. MEMILIH JALUR KOMUNIKASI

Setelah itu polihlah port yang anda gunakan dengan cara klik Alat  » Port yang digunakan untuk mengetahui port yang digunakan anda dapat melihatnya pada divace manager.

Gambar 2.12 Pemilihan Port

6.Mengupload Program (Sketch).

Untuk mengupload program ke papan arduino anda cukup menekan icon Upload seperti   atau bisa dilihat pada gambar dibawah ini.

Gambar 2.13 Mengupload Program

Atau jika anda menupload program menggunakan papan Selain papan Arduino anda juga dapat mengupload program/ sketch Arduino IDE ke sebuah minimum sistem, dengan menggunakan downloader external seperti USB Asp, Paralel Programer dan lain-lain  maka pilihlah jenis Downloadernya seperti pada gambar dibawah ini namun untuk menguploadnya anda tidak bisa dengan cara menekan icon upload melaikan dengan cara menekan Ctl+shift+U hal ini dikarenakan icon tersebut digunakan untuk menupload program hanya ke papan Arduino.

 Gambar 2.14 Arduino Programer

jika sudah mengupload program perhatikanlah LED pada pin 13,  jika LED pada pin 13  berkedip itu berarti papan arduino anda tidak bermasalah dan siap digunakan untuk project- project yang lainya.

Gambar 2.15 Tampilan Jika Berhasil

SEKILAS TENTANG ARDUINO

           Pengertian Arduino

        Arduino adalah sebuah platform open source (Gratis) yang digunakan untuk membuat proyek-proyek elektronika. Arduino terdiri dari dua bagian utama yaitu sebuah papan sirkuit fisik (sering disebut juga dengan mikrokontroler) dan sebuah perangkat lunak atau IDE (Integrated Development Environment) yang berjalan pada komputer. Perangkat lunak ini sering disebut Arduino IDE yang digunakan untuk menulis dan meng-upload kode dari komputer ke papan fisik (hardware) Arduino. 

1.   Sekilas Tentang Arduino

         Arduino sekarang ini menjadi sangat populer dengan pertambahan jumlah pengguna baru yang terus meningkat. Hal ini karena kemudahannya dalam penggunaan dan penulisan kode. Tidak seperti kebanyakan papan sirkuit pemrograman sebelumnya, Arduino tidak lagi membutuhkan programmer atau downloader tambahan untuk memuat atau meng-upload kode baru ke dalam mikrokontroler. 

          

       Cukup dengan menggunakan kabel USB untuk mulai menggunakan Arduino. Selain itu, Arduino IDE menggunakan bahasa pemrograman  C++  dengan versi yang telah disederhanakan, sehingga lebih mudah dalam belajar pemrograman. Arduino akhirnya berhasil menjadi papan sirkuit pemrograman paling disukai hingga menjadikannya sebagai bentuk standar dari fungsi mikrokontroler dengan paket yang mudah untuk diakses.

     Gambar 1 Papan Arduino Uno

          Gambar diatas menunjukan papan Arduino Uno yang merupakan salah satu Arduino paling populer diantara keluarga Arduino dan papan ini merupakan pilihan yang sangat cocok bagi para pemula. Dan selanjutnya artikel ini akan membahas lebih dalam mengenai Arduino terutama Arduino Uno.

     Kelebihan Arduino

       Hardware dan software Arduino dirancang bagi para seniman, desainer, penghobi, hacker, pemula dan siapapun yang tertarik untuk menciptakan objek interaktif dan pengembangan lingkungan. Arduino mampu berinteraksi dengan tombol, LED, motor, speaker, GPS, kamera, internet, ponsel pintar bahkan dengan televisi anda. Fleksibilitas ini dihasilkan dari kombinasi ketersediaan software Arduino yang gratis, papan perangkat keras yang murah, dan keduanya yang mudah untuk dipelajari. Hal inilah yang menciptakan jumlah pengguna menjadi sebuah komunitas besar dengan berbagai kontribusinya yang telah dirilis pada berbagai proyek dengan berbasiskan Arduino.

     Bagian Softwere Arduino IDE

,     Arduino IDE atau Integrated Development Enviroment merupakan softwere yang digunakan untuk menulis program/ sketch yang sudah disesuaikan dengan hardwere Arduino, selain dari itu arduino juga dilengkapi dengan berbagai contoh program dan library sehingga memudahkan kita untuk membuat program dan sketch, dibawah ini adalah tampilan dari Sofwere Arduino.

Gambar 2 Bagian Softwere Arduino IDE

       Seperti yang dilihat pada gambar  2  sudah diketahui bahwa Arduino IDE memiliki beberapa Icon-icon yang memiliki fungsi- fungsi khusus diantaranya;

1. Save,Digunakan untuk menyimpan Program/ Sketch yang telah dibuat.

2. Open ,Digunakan untuk membuka program yang telah dibuat.

3. New,Digunakan untuk membuat lebar kerja baru.

4. Verify,Digunakan untuk memeriksa Program/ Sketch apakah ada                kesalahan atau tidak.

5. Upload,Digunakan untuk memeriksa program (Verify) dan menguploadnya ke papan Arduino, dengan kata lain opload berfungsi ganda selain memeriksa (Verify) Program/ Sketch juga berfungsi sebagai tombol mengupload/ memasukan program ke papan Arduino.

Arduino: Membaca Data Jarak Menggunakan Modul Sensor Ultrasonik PING Parallax

Pada tutorial ini digunakan software Arduino 1.0.1 yang merupakan versi terbaru IDE Arduino. Namun tak hanya menggunakan versi terbaru, sebagai perbandingan, digunakan juga IDE Arduino-0022.

Pada kedua versi Arduino tersebut terdapat contoh program sensor PING yang dapat langsung diuji-coba tanpa modifikasi atau dengan sedikit modifikasi. Untuk praktisnya, kita akan merangkai Starduino Board dan PING Parallax sesuai dengan contoh program PING yang tersedia pada IDE Arduino.

Rangkaian Starduino + PING Parallax
Modul sensor ultrasonik PING buatan Parallax memiliki 3 kaki yakni: GND, 5V, dan SIG. Gambar di bawah ini menunjukkan koneksi modul PING dengan Starduino Board.

Kaki SIG dari modul PING dihubungkan dengan Pin-7 dari Starduino. Kaki GND dan 5Vdihubungkan ke GND dan +5V dari Starduino.

Setelah Starduino dan PING terangkai dengan benar, maka langkah selanjutnya adalah membuka sketch Ping yang telah tersedia pada contoh-contoh program bawaan IDE Arduino 1.0.1 maupun Arduino-0022 seperti ditunjukkan pada screenshot di bawah ini.

Sebelum program ini kita upload ke Starduino, kita edit sedikit program Ping pada bagian tampilan data serial dan delay sebagai berikut:

   Serial.print("Jarak = ");
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();

   delay(500);

Baris perintah pertama yang bercetak tebal menambahkan tulisan ‘Jarak =’ sebelum menampilkan nilai jarak dalam inci dan centimeter. Perubahan program lainnya adalah parameter fungsi delay() yang awalnya bernilai 100 diganti menjadi 500.

Selanjutnya, kita lakukan upload program ke Starduino dan buka window Serial Monitor. Jika tidak ada kesalahan pada hardware dan komunikasi, maka Starduino akan melakukan pengukuran dan mengirimkan hasil pengukuran jarak ke PC melalui port serial.

LED pada modul PING akan berkedip setiap 1/2 detik sebagai tanda bahwa modul PING bekerja memancarkan suara ultrasonik. Teknik pengukuran jarak dilakukan dengan mengukur lebar-pulsa dalam satuan waktu yang menunjukkan lamanya waktu semenjak PING memancarkan suara ultrasonik hingga menerima pantulan suara ultrasonik, atau mengalami TIMEOUT. Selanjutnya, program menghitung jarak dalam inci dan centimeter menggunakan fungsi-fungsi berikut:

long microsecondsToInches(long microseconds)
{
  // According to Parallax’s datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

Berikut adalah tampilan window Serial Monitor yang menampilkan data yang dikirimkan oleh Starduino Board melalui port serial RS232.

Nah, sangat mudah bukan? Dengan dukungan contoh-contoh program dan library-library siap pakai yang disediakan oleh Arduino, kita dapat membuat prototipe sistem dengan sangat cepat. Tak heran jika Arduino mengklaim dirinya sebagai Rapid Prototyping Platform.

Tak hanya mudah, Arduino juga murah. Dan tak hanya murah, Arduino juga menerapkan kebijakan open-source untuk software dan hardwarenya, sehingga siapapun boleh membuat sendiri versi Arduino-nya masing-masing. Termasuk juga saya dengan versi Starduino yang masih berbasis ATmega8.

Dengan Starduino dan PING Parallax, kita dapat membuat berbagai aplikasi berbasis pengukuran jarak seperti monitoring level air, pengukur tinggi badan, sistem pengaman mesin potong, dan lain-lain.

Berikut adalah screenshot aplikasi monitoring level ketinggian air dalam tandon dan aplikasi pengukur tinggi badan berbasis Starduino dan sensor jarak ultrasonik PING Parallax. Program dibuat menggunakan VB.NET 2005 Express Edition.

Read more: http://belajar-dasar-pemrograman.blogspot.com/2013/04/arduino-membaca-data-jarak-menggunakan.html#ixzz3SdNdM700

ARDUINO DAN VB.NET :: Komunikasi Arduino dengan VB.NET (serial port)

 

Pemrograman serial port pada Arduino

Hubungkan Arduino ke PC Anda menggunakan kabel USB, lalu buka software Arduino. Program ini untuk memastikan bahwa koneksi antara Arduino dan PC tidak ada kendala.   Ketik program seperti di bawah ini lalu upload ke Arduino.

int inByte=0; // variable to receive data from serial port
void setup()
{
Serial.begin(9600);
}

void loop()
{
if (Serial.available() > 0)
{
inByte=Serial.read();
Serial.write(inByte);
}
}

Setelah itu buka Tools > Serial Monitor pada aplikasi Arduino, untuk melihat interaksi antara PC dan mikrokontroler.  Jika kita mengirim sembarang data, maka Arduino akan membalas data yang sama.  Jangan lupa periksa kecepatan komunikasi, keduanya harus sama.  Dalam hal ini 9600 bit per detik.

Pada bagian setup, kita mengaktifkan fungsi serial port pada Arduino (yang terkoneksi langsung dengan port USB) dengan perintah:

Serial.begin(9600);

Perintah ini hanya dilakukan sekali saja, pada saat Arduino diaktifkan atau di-reset.  Jika kita ingin kecepatan lebih tinggi, ganti dengan 115000.  Jika kita ingin menggunakan serial port yang lain, gunakan Serial1, Serial2 atau Serial3. (berlaku untuk mikro yang serial portnya lebih dari satu, contohnya Arduino Mega, terletak pada pin 14 sampai 19).  Jika Anda menggunakan Uno, maka tidak ada pilihan lain.

Fungsi Serial.available() memberikan nilai BENAR jika ada data yang masuk.  Sedangkan fungsi  Serial.read() untuk membaca data yang masuk sebesar 1 byte.  Perintah untuk mengirim data dari mikro ke luar adalahSerial.write(data_yg_ditulis);

Dengan melihat program di atas, maka mikrokontroler hanya akan mengirim ke luar jika ada masukan data serial, dan pengirimannya akan diulang terus sebanyak berapa byte data yang masuk.

Mengendalikan LED lewat serial port

Sekarang kita akan coba menyalakan atau mematikan LED (pin 13), melalui serial port.  Kita buat ketentuan yang sederhana sebagai berikut:  jika menerima karakter ‘A’ maka lampu akan menyala, jika menerima karakter ‘B’ maka lampu akan mati.

// variable to receive data from serial port
int inByte=0;
// Pin 13 has an LED connected on most Arduino boards.
int led = 13;
void setup()
(
// initialize UART at 9600bps
Serial.begin(9600);
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

void loop()
{
if (Serial.available() > 0) {
inByte=Serial.read();
Serial.write(inByte);

if (inByte==65)
{
digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
}
if (inByte==66)
{
digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
}

}
}

Ketik program di atas, upload dan jalankan Serial Monitor.  Kirim karakter ‘A’ atau ‘B’ untuk menyalakan dan mematikan LED yang ada di papan Arduino.  Catatan: tentu saja Anda bisa mengganti karakter tersebut dengan yang lain, sesuai keinginan.  (‘A’ = ASCII nomor 65 dan ‘B’ = ASCII nomor 66).

Membaca status input melalui serial port

Tahap berikutnya adalah pembacaan status input pada Arduino melalui serial port. Ketentuan yang kita buat adalah jika salah satu pin digital pada Arduino bernilai 0/low maka Arduino akan mengirim karakter ‘L’ dan jika bernilai 1/high maka akan mengirim karakter ‘H’.  Untuk memudahkan pengamatan, masing-masing karakter diikuti oleh karakter ‘CR’ atau ‘\n’.

Di contoh ini, kita gunakan pin nomor 24 yang dihubungkan ke sebuah tombol.  Kaki satu lagi dihubungkan ke ground.

// variable to receive data from serial port
int inByte=0;

// Pin 13 has an LED connected on most Arduino boards.
int led = 13;

// Push button is connected to pin 24
int buttonPin = 24;
int buttonState=0;

void setup()
{
// initialize UART at 9600bps
Serial.begin(9600);
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop()
{
if (Serial.available() > 0) {
inByte=Serial.read();
Serial.write(inByte);

if (inByte==65)
{
digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
}
if (inByte==66)
{
digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
}
}
buttonState=digitalRead(buttonPin);
if (buttonState==LOW)
{
Serial.write("L\n");  // send ‘L’ + CR
}
if (buttonState==HIGH)
{
Serial.write("H\n"); // send ‘H’ + CR
}
}

Ketik program di atas, lalu upload.  Buka Serial Monitor, lalu amati data yang diterima. Cobalah juga menekan/melepas tombol sambil mengamati perubahan yang terjadi antara ‘L’ dan ‘H’.  Di percobaan ini kita bisa amati, bahwa Arduino mengirimkan data secara terus menerus baik L ataupun H, meskipun tombol ditekan atau dilepas lama. Ingat bahwa hal ini karena instruksi ini terletak di dalam program utama/main loop.

Sekarang kita akan coba modifikasi program, sehingga yang terkirim hanya satu kali saja saat terjadi perubahan dari L ke H atau H ke L.  Untuk itu, kita harus membandingkan kondisi nilai tombol saat ini dengan kondisi pada loop sebelumnya. Variabel yang digunakan lastButtonState.  Jika tidak sama dengan buttonState, maka baru kita proses apa yang kita inginkan yaitu mengirimkan data.

// variable to receive data from serial port
int inByte=0;

// Pin 13 has an LED connected on most Arduino boards.
int led = 13;

// Push button is connected to pin 24
int buttonPin = 24;
int buttonState=0;
int lastButtonState=0;

void setup()
{
// initialize UART at 9600bps
Serial.begin(9600);
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
pinMode(buttonPin, INPUT);
}

void loop()
{
if (Serial.available() > 0)
{
inByte=Serial.read();
Serial.write(inByte);

if (inByte==65)
{
digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
}
if (inByte==66)
{
digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
}
}

buttonState=digitalRead(buttonPin);
if (buttonState != lastButtonState)
{
if (buttonState==LOW)
{
Serial.write("L\n");
}
else
{
Serial.write("H\n");
}
}
lastButtonState=buttonState;
}

Ketik program di atas, lalu upload, kemudian amati di Serial Monitor. Tekan tombol yang agak lama sambil amati karakter yang terkirim.  Arduino hanya akan mengirimkan satu kali saja saat ada perubahan L → H atau H → L.

Sampai di sini program di sisi Arduino sudah selesai, berikutnya kita masuk ke pemrograman serial port menggunakan Visual Studio .NET dalam hal ini kita coba memakai Visual Basic versi 2012.

ARDUINO :: Cara menggunakan Arduino GUI di Board lain, selain ARDUINO Board

Untuk kepentingan pembahasan dalam artikel ini anggap saja sistem Arduino terdiri dari dua sub sistem utama. Yang pertama adalah Arduino IDE, yaitu software yang beroperasi di komputer. Menurut situs http://www.arduino.cc perangkat lunak ini mereka sebut sebagai Arduino Software.

The open-source Arduino environment makes it easy to write code and upload it to the i/o board. It runs on Windows, Mac OS X, and Linux. The environment is written in Java and based on Processing, avr-gcc, and other open source software.

Tugas dari “Arduino Software” adalah menghasilkan sebuah file berformat hex yang akan di-download pada papan arduino atau papan sistem mikrokontroler lainnya. Ini mirip dengan Microsoft Visual Studio, Eclipse IDE, atau Netbeans. Lebih mirip lagi adalah IDE semacam Code::Blocks, CodeLite atau Anjuta yang mempermudah untuk menghasilkan file program. Bedanya kesemua IDE tersebut menghasilkan program dari kode bahasa C (dengan GNU GCC) sedangkan Arduino Software (Arduino IDE) menghasilkan file hex dari baris kode yang dinamakan sketch.

A sketch is the name that Arduino uses for a program. It’s the unit of code that is uploaded to and run on an Arduino board.

Sub sistem yang kedua adalah hardware (perangkat keras) yaitu papan Arduino (Arduino Boards). Sampai saat tulisan ini dibuat yang paling umum dijual adalah varian baru yaitu Arduino Uno dan Arduino Mega 2560. Kesemua papan arduino itu memiliki perangkat lunak yang dinamakanbootloader.

When you upload a sketch, you’re using the Arduino bootloader, a small program that has been loaded on to the microcontroller on your board. It allows you to upload code without using any additional hardware. The bootloader is active for a few seconds when the board resets; then it starts whichever sketch was most recently uploaded to the microcontroller. The bootloader will blink the on-board (pin 13) LED when it starts (i.e. when the board resets).

Pada umumnya sketch yang dibuat di Arduino Software di-compile dengan perintah verify / Compile (Ctrl+R) lalu hasilnya di-download ke papan Arduino seperti Arduino Uno atau Arduino Mega 2560. Program hasil kompilasi itu lalau dijalankan oleh bootloader.

Tetapi ternyata hasil kompilasi dari Arduino Software dapat dipergunakan dan dijalankan tidak hanya pada papan arduino (Arduino Boards) atau turunannya yang kompatibel. Program hasil kompilasi itu dapat dijalankan di sistem mikrokontroller Atmel AVR yang sesuai bahkan tanpa menggunakan bootloader. Selain memperluas pilihan varian IC microcontroller AVR yang bisa dipergunakan hal ini juga berarti semakin besar program yang bisa kita muat di flash memori IC itu.

If you want to use the full program space (flash) of the chip or avoid the bootloader delay, you can burn your sketches using an external programmer. [sumber]

If you have an external programmer (e.g. an AVR-ISP, STK500, or parallel programmer), you can burn sketches to the Arduino board without using the bootloader. This allows you to use the full program space (flash) of the chip on the Arduino board. So with anATmega168, you’ll get 16 KB instead of 14 (on an ATmega8 you’ll get 8 KB instead of 7). It also avoids the bootloader delay when you power or reset your board. [sumber]

Kemudahan untuk mempergunakan berbagai macam varian microcontroller dalam tulisan ini mengikuti karya dari Mark Sproul. Beliau telah berbuat amal [ :-) ] dengan melakukan pengujian dan kemudian mempublikasikan secara luas uji cobanya untuk mempergunakan Arduino IDE untuk memprogram berbagai uC IC AVR. Daftar hasil uji cobanya dapat dilihat di http://www.avr-developers.com/cputable.html. Untuk dapat memprogram berbagai IC AVR tanpa papan arduino kita perlu melakukan download file-file konfigurasi yang telah dimodifikasi oleh Mark Sproul.

Sep 29, 2010 Updated to version 0020 core
Based on Version 0020 core files

Download this file (arduino-extras.zip) uncompress it and add it in the hardware folder.    
On the Mac, this is /Applications/Arduino.app/Contents/Resources/Java/hardware 
This file contains ALL of the defintions that are included in the “arduino” folder as well. So your BOARDS menu will have duplicates.

This will give you access to just about EVERY ATmega that I can find that has been made into a comerically avaialable board.

NOTE: Not all cpus support bootloaders.

File arduino-extras.zip berisi tiga direktori: bootloaders, cores dan firmwares dan dua file:boards.txt dan programmers.txt. Kesemuanya di-copy-kan ke direktori hardware arduino, misalnya:/home/sunu/arduino-0022/hardware/arduino/ atau misalnya direktori arduino utak-atik saya/home/sunu/arduino-0022hknix/hardware/arduino/. Kesemua direktori dan file yang baru itu akan menimpa yang lama, aman, kecuali anda telah melakukan modifikasi pada fileyang lama yang sayang kalau hilang :-).

Ada dua cara konfigurasi untuk melakukan pemrograman tanpa papan arduino. Yang pertama melakukan konfigurasi pada file preferences.txt untuk mengubah secara otomatis setting pada semua pengaturan papan. Cara yang kedua adalah dengan melakukan konfigurasi pada fileboards.txt, ini jika kita hendak melakukan setting yang berbeda untuk tiap papan.

Untuk file preferences dapat ditemukan di sistem sebagai berikut:

* /Users/<USERNAME>/Library/Arduino/preferences.txt (Mac)
* c:\Documents and Settings\<USERNAME>\Application Data\Arduino\preferences.txt (Windows)
* ~/.arduino/preferences.txt (Linux) 

Perlu diperhatikan bahwa direktori ~/.arduino/ adalah direktori tersembunyi pada sistem GNU/Linux anda. Jika menggunakan file explorer Nautilus untuk menampilkan semua direktori tersembunyi dapat menggunakan Ctrl+h.

Modifikasi pada file preferences.txt dilakukan dengan melakukan pengubahan pada baris konfigurasi yang tercantum

upload.using=bootloader

menjadi salah satu nama programmer yang telah dicantumkan dalam fileprogrammer.txt.

Change: upload.using from bootloader to the identifier of one of the programmers in hardware/programmers.txt (e.g. avrispmkii).

Misalnya saya menggunakan dua programmer, yaitu USBasp dan USBtinyISP yang saya cantumkan di dalam file programmer.txt.

usbasp.name=USBaspusbasp.protocol=USBasp

usbtinyisp.name=USBtinyISP
usbtinyisp.protocol=usbtiny

Maka saya bisa mengubah baris yang tertulis sebagai upload.using=bootloader dalampreferences.txt menjadi upload.using=USBasp atau upload.using=USBtinyISP.

Saya sendiri lebih menyenangi cara yang kedua yaitu melakukan konfigurasi pada file boards.txt. Menurut saya cara ini lebih fleksibel, bahkan saya menjadi bisa untuk memiliki lebih dari satu konfigurasi untuk satu papan / boards / sistem. Misalnya saya memiliki dua konfigurasi untuk sistem/papan ATmega8, satu untuk internal clock 1 MHz dan satu lagi untuk  internal clock  8 Mhz.

File boards.txt pada sistem OS MS Windows dapat ditemukan di sub folder instalasinya misalnyaD:\arduino-0022\hardware\arduino\boards.txt. Pada sistem GNU/Linux dapat ditemukan di tempat instalasinya misalnya di /home/sunu/arduino-0022hknix/hardware/arduino/boards.txt.

Baris konfigurasi yang perlu diubah atau ditambahkan (jika belum ada) adalah baris yang tertulis sebagai: 

xxx.upload.using=nama_programmer

xxx.upload.protocol=nama_programmer

Misalnya:

    USBtinyISP-ATtiny2313.upload.using=usbtiny
    USBtinyISP-ATtiny2313.upload.protocol=usbtiny

atau

    arduino_attiny2313.upload.using=usbasp
    arduino_attiny2313.upload.protocol=usbasp

Berikut ini adalah konfigurasi yang saya buat untuk keperluan sistem saya, dapat dimodifikasi sesuai keperluan:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291

##############################################################   USBtinyISP-ATtiny2313.name=USBtinyISP ATtiny2313 8 MHZ internal   USBtinyISP-ATtiny2313.upload.using=usbtiny USBtinyISP-ATtiny2313.upload.protocol=usbtiny USBtinyISP-ATtiny2313.upload.maximum_size=2048 USBtinyISP-ATtiny2313.upload.speed=19200   USBtinyISP-ATtiny2313.bootloader.low_fuses=0x64 USBtinyISP-ATtiny2313.bootloader.high_fuses=0xdf USBtinyISP-ATtiny2313.bootloader.path=attiny45 USBtinyISP-ATtiny2313.bootloader.file=ATmegaBOOT.hex USBtinyISP-ATtiny2313.bootloader.unlock_bits=0x3F USBtinyISP-ATtiny2313.bootloader.lock_bits=0x0F   USBtinyISP-ATtiny2313.build.mcu=attiny2313 USBtinyISP-ATtiny2313.build.f_cpu=8000000L USBtinyISP-ATtiny2313.build.core=arduino   ##############################################################   arduino_attiny2313.name=USBasp ATtiny2313 8 MHZ internal   arduino_attiny2313.upload.using=usbasp arduino_attiny2313.upload.protocol=usbasp arduino_attiny2313.upload.maximum_size=2048 arduino_attiny2313.upload.speed=19200   arduino_attiny2313.bootloader.low_fuses=0x64 arduino_attiny2313.bootloader.high_fuses=0xdf arduino_attiny2313.bootloader.path=attiny45 arduino_attiny2313.bootloader.file=ATmegaBOOT.hex arduino_attiny2313.bootloader.unlock_bits=0x3F arduino_attiny2313.bootloader.lock_bits=0x0F   arduino_attiny2313.build.mcu=attiny2313 arduino_attiny2313.build.f_cpu=8000000L arduino_attiny2313.build.core=arduino   ##############################################################   atmega8usbasp1mhz.name=ATmega8 tanpa bootloader 1 MHz (USBasp)   atmega8usbasp1mhz.upload.using=usbasp atmega8usbasp1mhz.upload.protocol=usbasp atmega8usbasp1mhz.upload.maximum_size=8192 atmega8usbasp1mhz.upload.speed=19200   atmega8usbasp1mhz.build.mcu=atmega8 atmega8usbasp1mhz.build.f_cpu=1000000L atmega8usbasp1mhz.build.core=arduino   ##############################################################   atmega8usbasp8mhz.name=ATmega8 tanpa bootloader 8 MHz (USBasp)   atmega8usbasp8mhz.upload.using=usbasp atmega8usbasp8mhz.upload.protocol=usbasp atmega8usbasp8mhz.upload.maximum_size=8192 atmega8usbasp8mhz.upload.speed=19200   #catatan -U lfuse:w:0xE4 #catatan -U hfuse:w:0xD9   atmega8usbasp8mhz.build.mcu=atmega8 atmega8usbasp8mhz.build.f_cpu=8000000L atmega8usbasp8mhz.build.core=arduino   ##############################################################   atmega8.name=Arduino NG or older w/ ATmega8   atmega8.upload.protocol=stk500 atmega8.upload.maximum_size=7168 atmega8.upload.speed=19200   atmega8.bootloader.low_fuses=0xdf atmega8.bootloader.high_fuses=0xca atmega8.bootloader.path=atmega8 atmega8.bootloader.file=ATmegaBOOT.hex atmega8.bootloader.unlock_bits=0x3F atmega8.bootloader.lock_bits=0x0F   atmega8.build.mcu=atmega8 atmega8.build.f_cpu=16000000L atmega8.build.core=arduino   ##############################################################   atmega16_1Mhz_dalam.name=Atmega16 1 MHz internal   atmega16_1Mhz_dalam.upload.using=usbasp atmega16_1Mhz_dalam.upload.protocol=usbasp atmega16_1Mhz_dalam.upload.maximum_size=16384 atmega16_1Mhz_dalam.upload.speed=57600   #catatan -U lfuse:w:0xE1 #catatan -U hfuse:w:0x99   atmega16_1Mhz_dalam.build.mcu=atmega16 atmega16_1Mhz_dalam.build.f_cpu=1000000L atmega16_1Mhz_dalam.build.core=arduino   ##############################################################   arduino_atmega16.name=Arduino-Atmega16   arduino_atmega16.upload.protocol=stk500v2 arduino_atmega16.upload.maximum_size=14336 arduino_atmega16.upload.speed=57600   arduino_atmega16.bootloader.low_fuses=0xE4 arduino_atmega16.bootloader.high_fuses=0x98 arduino_atmega16.bootloader.extended_fuses=0xFF arduino_atmega16.bootloader.path=atmega arduino_atmega16.bootloader.file=ATmegaBOOT_168_atmega16.hex arduino_atmega16.bootloader.unlock_bits=0x3F arduino_atmega16.bootloader.lock_bits=0x0F   arduino_atmega16.build.mcu=atmega16 arduino_atmega16.build.f_cpu=8000000L arduino_atmega16.build.core=arduino   ##############################################################   atmega32_no_boot_1MHz.name=ATmega32 1 MHz internal   atmega32_no_boot_1MHz.upload.using=usbasp atmega32_no_boot_1MHz.upload.protocol=usbasp atmega32_no_boot_1MHz.upload.maximum_size=32768 atmega32_no_boot_1MHz.upload.speed=57600   #catatan -U lfuse:w:0xE1 #catatan -U hfuse:w:0x99   atmega32_no_boot_1MHz.build.mcu=atmega32 atmega32_no_boot_1MHz.build.f_cpu=1000000L atmega32_no_boot_1MHz.build.core=arduino   ##############################################################   atmega32_no_boot_8MHz.name=ATmega32 8 MHz internal   atmega32_no_boot_8MHz.upload.using=usbasp atmega32_no_boot_8MHz.upload.protocol=usbasp atmega32_no_boot_8MHz.upload.maximum_size=28672 atmega32_no_boot_8MHz.upload.speed=57600   #catatan -U lfuse:w:0xE4 #catatan -U hfuse:w:0x99   atmega32_no_boot_8MHz.build.mcu=atmega32 atmega32_no_boot_8MHz.build.f_cpu=8000000L atmega32_no_boot_8MHz.build.core=arduino   ############################################################## arduino_penguino_avr.name=Arduino-Penguino AVR   arduino_penguino_avr.upload.protocol=stk500v2 arduino_penguino_avr.upload.maximum_size=28672 arduino_penguino_avr.upload.speed=57600   arduino_penguino_avr.bootloader.low_fuses=0xFF arduino_penguino_avr.bootloader.high_fuses=0xDA arduino_penguino_avr.bootloader.extended_fuses=0x05 arduino_penguino_avr.bootloader.path=atmega arduino_penguino_avr.bootloader.file=stk500boot_v2_penguino.hex arduino_penguino_avr.bootloader.unlock_bits=0x3F arduino_penguino_avr.bootloader.lock_bits=0x0F   arduino_penguino_avr.build.mcu=atmega32 arduino_penguino_avr.build.f_cpu=16000000L arduino_penguino_avr.build.core=arduino   ##############################################################   uno.name=Arduino Uno uno.upload.protocol=stk500 uno.upload.maximum_size=32256 uno.upload.speed=115200 uno.bootloader.low_fuses=0xff uno.bootloader.high_fuses=0xde uno.bootloader.extended_fuses=0x05 uno.bootloader.path=optiboot uno.bootloader.file=optiboot_atmega328.hex uno.bootloader.unlock_bits=0x3F uno.bootloader.lock_bits=0x0F uno.build.mcu=atmega328p uno.build.f_cpu=16000000L uno.build.core=arduino   ##############################################################   mega2560.name=Arduino Mega 2560   mega2560.upload.protocol=stk500v2 mega2560.upload.maximum_size=258048 mega2560.upload.speed=115200   mega2560.bootloader.low_fuses=0xFF mega2560.bootloader.high_fuses=0xD8 mega2560.bootloader.extended_fuses=0xFD mega2560.bootloader.path=stk500v2 mega2560.bootloader.file=stk500boot_v2_mega2560.hex mega2560.bootloader.unlock_bits=0x3F mega2560.bootloader.lock_bits=0x0F   mega2560.build.mcu=atmega2560 mega2560.build.f_cpu=16000000L mega2560.build.core=arduino   ############################################################## arduino_atmega8515.name=Arduino-ATmega8515   arduino_atmega8515.upload.using=usbtinyisp arduino_atmega8515.upload.protocol=stk500 arduino_atmega8515.upload.maximum_size=8192 arduino_atmega8515.upload.speed=19200   arduino_atmega8515.bootloader.low_fuses=0xdf arduino_atmega8515.bootloader.high_fuses=0xca arduino_atmega8515.bootloader.path=atmega arduino_atmega8515.bootloader.file=ATmegaBOOT.hex arduino_atmega8515.bootloader.unlock_bits=0x3F arduino_atmega8515.bootloader.lock_bits=0x0F   arduino_atmega8515.build.mcu=atmega8515 arduino_atmega8515.build.f_cpu=16000000L arduino_atmega8515.build.core=arduino   ############################################################## arduino_atmega8535.name=Arduino-Test-Atmega8535   arduino_atmega8535.upload.protocol=stk500v2 arduino_atmega8535.upload.maximum_size=7168 arduino_atmega8535.upload.speed=38400   arduino_atmega8535.bootloader.low_fuses=0xEC arduino_atmega8535.bootloader.high_fuses=0x18 arduino_atmega8535.bootloader.extended_fuses=0xFD arduino_atmega8535.bootloader.path=atmega arduino_atmega8535.bootloader.file=stk500boot_v2_notdefined.hex arduino_atmega8535.bootloader.unlock_bits=0x3F arduino_atmega8535.bootloader.lock_bits=0x0F   arduino_atmega8535.build.mcu=atmega8535 arduino_atmega8535.build.f_cpu=16000000L arduino_atmega8535.build.core=arduino   ##############################################################   atmega328.name=Arduino Duemilanove or Nano w/ ATmega328   atmega328.upload.protocol=stk500 atmega328.upload.maximum_size=30720 atmega328.upload.speed=57600   atmega328.bootloader.low_fuses=0xFF atmega328.bootloader.high_fuses=0xDA atmega328.bootloader.extended_fuses=0x05 atmega328.bootloader.path=atmega atmega328.bootloader.file=ATmegaBOOT_168_atmega328.hex atmega328.bootloader.unlock_bits=0x3F atmega328.bootloader.lock_bits=0x0F   atmega328.build.mcu=atmega328p atmega328.build.f_cpu=16000000L atmega328.build.core=arduino   ##############################################################   diecimila.name=Arduino Diecimila, Duemilanove, or Nano w/ ATmega168   diecimila.upload.protocol=stk500 diecimila.upload.maximum_size=14336 diecimila.upload.speed=19200   diecimila.bootloader.low_fuses=0xff diecimila.bootloader.high_fuses=0xdd diecimila.bootloader.extended_fuses=0x00 diecimila.bootloader.path=atmega diecimila.bootloader.file=ATmegaBOOT_168_diecimila.hex diecimila.bootloader.unlock_bits=0x3F diecimila.bootloader.lock_bits=0x0F   diecimila.build.mcu=atmega168 diecimila.build.f_cpu=16000000L diecimila.build.core=arduino   ##############################################################

Saya melakukan modifikasi pada file boards.txt agar tampilan daftar pilihannya tidak terlalu panjang dan berisi penuh konfigurasi yang hampir tidak pernah saya pergunakan. Jika suatu hari nanti perlu ditambah atau dimodifikasi ulang toh caranya sangat gampang. 

File boards.txt maupun file programmers.txt yang berada di folder/direktori yang sama telah sayaupload di sini. File programmers.txt perlu dimodifikasi jika anda ingin membakar/download bootloader dengan papan selain turunan papan arduino. Misalnya jika ingin menggunakan programmer USBasp atau USBtinyISP.

Demikianlah, selamat mencoba. Silahkan melihat ke semua link (tautan) di tulisan di atas dan daftar referensi berikut:

- http://www.avr-developers.com/corefiles/index.html

- http://www.avr-developers.com/cputable.html

- http://www.arduino.cc/en/Hacking/Programmer

- http://tutorial.cytron.com.my/2011/09/30/how…

- http://blog.lincomatic.com/?p=10

- http://todbot.com/blog/2009/05/26/minimal-arduino-with-atmega8/

- mengatasi-masalah-uploading-arduino-mega-2560-di-linux-ubuntu

Sumber: pikirsa.wordpress.com