Proyek 8×8 dot Matrik Arduino versi 1

Cara memprogram 8×8 Dot Metrik dengan ARDUINO

Pertama-tama kami ingin menjelaskan tentang Proyek ini, sebenarnya Proyek ini kami tunjukan dengan sederhana atau langkah pertama untuk proyek 8×8 Dot Matrix ini. Adapun Proyek 8×8 Dot Matrix yang lebih rumit nanti kita akan jelaskan Proyek versi lanjut pada postingan selanjutnya atau Versi 2, Versi 3 dan Versi-versi lanjutan.

Pada Proyek ini, dimana tugas Anda mengenal Dasar dari Pemrogramannya terlebih dahulu (Besic).

ROW 1 sampai 8 adalah Kaki atau Pin pada Dote Matrix, sedangkan nomor 2 sampai 9 adalah Pin Platform Mikrokontroler(Arduino). Termasuk COL juga pada intinya sama dengan ROW, namun ROW adalah Baris Lampu dari atas ke bawah, sedangkan COL adalah baris lampu dari Kanan ke Kiri.

Untuk membedakan mana urutan Kaki nomor 1 sampai 8, anda bisa melihat Bentuk Benjolan atau label pada Dot Matrix.

Kontruksi pada Dot Matrix 8×8

Katoda

Anoda

Ukuran dan Keterangan Kontruksi

Bar Pin

Tahap Akhir, Kode Pemrograman

KODE

/* PROYEK – 8×8 Dot Matrix

#define ROW_1 2
#define ROW_2 3
#define ROW_3 4
#define ROW_4 5
#define ROW_5 6
#define ROW_6 7
#define ROW_7 8
#define ROW_8 9

#define COL_1 10
#define COL_2 11
#define COL_3 12
#define COL_4 13
#define COL_5 A0
#define COL_6 A1
#define COL_7 A2
#define COL_8 A3

const byte rows[] = {
ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8
};
const byte col[] = {
COL_1,COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8
};

// The display buffer
// It’s prefilled with a smiling face (1 = ON, 0 = OFF)
byte ALL[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};
byte EX[] = {B00000000,B00010000,B00010000,B00010000,B00010000,B00000000,B00010000,B00000000};
byte A[] = { B00000000,B00111100,B01100110,B01100110,B01111110,B01100110,B01100110,B01100110};
byte B[] = {B01111000,B01001000,B01001000,B01110000,B01001000,B01000100,B01000100,B01111100};
byte C[] = {B00000000,B00011110,B00100000,B01000000,B01000000,B01000000,B00100000,B00011110};
byte D[] = {B00000000,B00111000,B00100100,B00100010,B00100010,B00100100,B00111000,B00000000};
byte E[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00111100,B00000000};
byte F[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00100000,B00000000};
byte G[] = {B00000000,B00111110,B00100000,B00100000,B00101110,B00100010,B00111110,B00000000};
byte H[] = {B00000000,B00100100,B00100100,B00111100,B00100100,B00100100,B00100100,B00000000};
byte I[] = {B00000000,B00111000,B00010000,B00010000,B00010000,B00010000,B00111000,B00000000};
byte J[] = {B00000000,B00011100,B00001000,B00001000,B00001000,B00101000,B00111000,B00000000};
byte K[] = {B00000000,B00100100,B00101000,B00110000,B00101000,B00100100,B00100100,B00000000};
byte L[] = {B00000000,B00100000,B00100000,B00100000,B00100000,B00100000,B00111100,B00000000};
byte M[] = {B00000000,B00000000,B01000100,B10101010,B10010010,B10000010,B10000010,B00000000};
byte N[] = {B00000000,B00100010,B00110010,B00101010,B00100110,B00100010,B00000000,B00000000};
byte O[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000010,B00111100,B00000000};
byte P[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100000,B00100000,B00000000};
byte Q[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001};
byte R[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100100,B00100100,B00000000};
byte S[] = {B00000000,B00111100,B00100000,B00111100,B00000100,B00000100,B00111100,B00000000};
byte T[] = {B00000000,B01111100,B00010000,B00010000,B00010000,B00010000,B00010000,B00000000};
byte U[] = {B00000000,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000,B00000000};
byte V[] = {B00000000,B00100010,B00100010,B00100010,B00010100,B00010100,B00001000,B00000000};
byte W[] = {B00000000,B10000010,B10010010,B01010100,B01010100,B00101000,B00000000,B00000000};
byte X[] = {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000};
byte Y[] = {B00000000,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00000000};
byte Z[] = {B00000000,B00111100,B00000100,B00001000,B00010000,B00100000,B00111100,B00000000};

float timeCount = 0;

void setup()
{
// Open serial port
Serial.begin(9600);

// Set all used pins to OUTPUT
// This is very important! If the pins are set to input
// the display will be very dim.
for (byte i = 2; i <= 13; i++)
pinMode(i, OUTPUT);
pinMode(A0, OUTPUT);
pinMode(A1, OUTPUT);
pinMode(A2, OUTPUT);
pinMode(A3, OUTPUT);
}

void loop() {
// This could be rewritten to not use a delay, which would make it appear brighter
delay(5);
timeCount += 1;

if(timeCount < 20)
{
drawScreen(A);
}
else if (timeCount < 40)
{
drawScreen(R);
}
else if (timeCount < 60)
{
drawScreen(D);
}
else if (timeCount < 80)
{
drawScreen(U);
}
else if (timeCount < 100)
{
drawScreen(I);
}
else if (timeCount < 120)
{
drawScreen(N);
}
else if (timeCount < 140) {
drawScreen(O);
}
else if (timeCount < 160)
{
drawScreen(ALL);
}
else if (timeCount < 180)
{
drawScreen(ALL);
}
else {
// back to the start
timeCount = 0;
}
}
void drawScreen(byte buffer2[])
{
// Turn on each row in series
for (byte i = 0; i < 8; i++) // count next row
{
digitalWrite(rows[i], HIGH); //initiate whole row
for (byte a = 0; a < 8; a++) // count next row
{
// if You set (~buffer2[i] >> a) then You will have positive
digitalWrite(col[a], (buffer2[i] >> a) & 0x01); // initiate whole column

delayMicroseconds(100); // uncoment deley for diferent speed of display
//delayMicroseconds(1000);
//delay(10);
//delay(100);

digitalWrite(col[a], 1); // reset whole column
}
digitalWrite(rows[i], LOW); // reset whole row
// otherwise last row will intersect with next row
}
}
//
/* this is siplest resemplation how for loop is working with each row.
digitalWrite(COL_1, (~b >> 0) & 0x01); // Get the 1st bit: 10000000
digitalWrite(COL_2, (~b >> 1) & 0x01); // Get the 2nd bit: 01000000
digitalWrite(COL_3, (~b >> 2) & 0x01); // Get the 3rd bit: 00100000
digitalWrite(COL_4, (~b >> 3) & 0x01); // Get the 4th bit: 00010000
digitalWrite(COL_5, (~b >> 4) & 0x01); // Get the 5th bit: 00001000
digitalWrite(COL_6, (~b >> 5) & 0x01); // Get the 6th bit: 00000100
digitalWrite(COL_7, (~b >> 6) & 0x01); // Get the 7th bit: 00000010
digitalWrite(COL_8, (~b >> 7) & 0x01); // Get the 8th bit: 00000001
}*/

KONTRUKSI

Lihat juga Postingan lainnya :

Cara memprogram Chip ATtiny85 menggunakan Arduino versi 2

Memprogram ATtiny85 (Menggunakan Arduino Uno)
Mengecilkan proyek Arduino Anda menghemat uang dan ruang! Berikut kami akan menunjukan langkah-langkah atau cara memprogram chip ATtiny85(Chip Mikrokontroler).

KOMPONEN

Mikrochip ATtiny85
Kabel Jumper M-M
LED
Kapasitor 10uF
Resistor 330 ohm
Breadboard

Sebelum kita mulai dengan pembuatan sirkuit, buka Arduino IDE.

Perangkat Lunak Arduino
Buka Sketch ArduinoISP dari menu File, Example dan ArduinoISP:

Verifikasi dan unggah sketsa ini ke Arduino Anda
Perangkat lunak Arduino tidak mendukung ATtiny85 secara asli sehingga kami perlu menambahkan dukungan untuk itu.

Buka Dialog Preferensi dari menu File.
Masukkan tautan ke ” URL Pengelola Papan Tambahan “.
Klik Oke!

PERHATIAN
Buka Manajer Papan dari Alat, Menu Papan
Pilih ATtiny dari daftar setelah perangkat lunak diperbarui
Perhatikan bahwa Anda akan memerlukan koneksi internet untuk mengunduh pengelola papan ATtiny.

Cari ATtiny, baik menggulir daftar secara manual, atau mengetik “attiny” di bidang filter.
Klik Instal (Gunakan versi terbaru).

Pengaturan Program
Mari kita mengatur program untuk menggunakan Arduino sebagai programmer.

Pilih Arduino sebagai ISP dari Alat, Menu Programmer
Pilih ATtiny dari Tools, Board Menus
Pilih ATtiny85 dari Alat, Menu Prosesor
Saya memilih Internal 16Mhz dari Alat, Menu Jam
Chip tersebut memiliki 8 pin(Kaki), untuk memprogram ATtiny85 kita hanya tertarik 6 saja diantaranya MISO, MOSI, SCK, RESET, Ground, dan Positive.

Jika Anda melihat lebih dekat pada chip, Anda akan melihat sebuah titik. Ini adalah Pin 1. Pin 2 hingga 8 mengikuti urutan berlawanan arah jarum jam di sekitar chip.

Header pada Arduino mudah digunakan untuk memprogram ATtiny85.

Membangun Sirkuit
Kami siap untuk terjun ke dalam membangun sirkuit pemrograman:

Cabut Arduino Anda
Tempatkan Chip ATtiny ke papan tempat memotong roti
Hubungkan ground dari Arduino ke Ground Rail
Hubungkan 5V dari Arduino ke pin 8 ATTINY
Hubungkan pin 4 chip ke ground
Tempatkan kapasitor antara ground dan strip terminal lain (Anoda kapasitor harus terhubung ke ground)
Hubungkan katoda kapasitor ke pin Reset Arduino
Hubungkan kabel dari pin header 10 Arduino ke pin 1 chip
Hubungkan Arduino Pin 11 ke Pin 5 dari chip
Hubungkan Arduino Pin 12 ke Pin 6 dari chip dan
Hubungkan Arduino Pin 13 ke Pin 7 dari ATtiny85


Tambahkan LED
Programmer sekarang akan bekerja, tetapi saya akan menambahkan beberapa LED karena LED menyenangkan untuk dimiliki.

  • Hubungkan resistor 330k ke ground dan strip terminal.
  • Hubungkan pin Arduino 7, 8 dan 9 ke strip terminal yang terpisah.
  • Tempatkan LED di antara masing-masing strip terminal (terhubung ke 7, 8 dan 9) dan ke strip terminal dengan Resistor 330k.

Kembali ke Arduino IDE

Kembali ke Arduino IDE. Pertama kita perlu membakar Bootloader ke chip.

  • Pilih Burning Bootloader dari Menu Alat.

Setelah selesai, Anda dapat mengunggah Sketsa Arduino ke chip ATtiny, seolah-olah itu adalah Arduino.

Ingat saja batasan pada chip ATtiny dan program apa pun dalam batasan itu akan berfungsi.

KODE

ArduinoISP

Entri github untuk ArduinoISP,ino File ini juga tersedia dari dalam ArduinoISP di bawah File >Contoh >ArduinoISP

UNDUH KODE

KONTRUKSI

Terima Kasih banyak atas Kunjungan Anda

Dipublikasikan oleh Electric Dermayon©

Lihat juga Postingan lainnya

Cara memprogram ATtiny85 dengan Arduino versi 1

Langkah-langkah tentang cara memprogram mikrokontroler ATtiny85 dengan papan pengembangan Arduino Uno.

ATtiny85

KOMPONEN :

  • Platform Arduino
  • ATtiny85
  • Kapasitor Pemisah Elektrolit – 10 uF/25v
  • Kabel Jumper M-M

TENTANG PROYEK INI

Kami sedang mengerjakan proyek yang mengharuskan membaca beberapa data sensor di lokasi yang berbeda. Ini hanya membutuhkan beberapa pin PWM sehingga menggunakan beberapa Arduino Uno akan mahal dan tidak perlu. Jadi kami memutuskan untuk menggunakan mikrokontroler ATtiny85 sebagai pengganti papan pengembangan Arduino Uno. ATtiny85 adalah alternatif yang murah dan kuat ketika Anda tidak membutuhkan terlalu banyak pin PWM. Karena ATtiny85 hanyalah mikrokontroler, kami memerlukan Arduino Uno untuk memprogramnya. Dalam proyek ini kami akan menjelaskan bagaimana melakukannya. Di bawah ini adalah konfigurasi pin ATtiny85 dan datasheet dapat ditemukan di sini

Konfigurasi Arduino Uno sebagai ISP (Pemrograman Dalam Sistem)
Untuk memprogram ATtiny85 kita harus terlebih dahulu mengatur Arduino Uno dalam mode ISP. Hubungkan Arduino Uno Anda ke PC. Buka Arduino IDE dan buka file contoh ArduinoISP (File -> Contoh -> ArduinoISP) dan unggah.

Menambahkan Dukungan ATtiny85 ke Arduino IDE
Secara default Arduino IDE tidak mendukung ATtiny85 jadi kita harus menambahkan papan ATtiny ke Arduino IDE. Buka File -> Preferensi dan di URL Pengelola Papan Tambahan, berikan url ini https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json .


Setelah ini selesai, buka Alat -> Papan -> Manajer Papan

Setelah membuka Board Manager, cari ke bawah daftar yang bertuliskan “attiny by Davis A. Mellis“. Klik itu dan instal.



Setelah menginstal sekarang Anda akan dapat melihat entri baru di menu Papan



Menghubungkan ATtiny85 dengan Arduino Uno
Sekarang dengan semua hal di atas siap, kita akan mulai memprogram attiny85. Hubungkan arduino uno ke attiny85 menggunakan breadboard seperti di bawah ini.

Arduino Uno – ATtiny85

5V – Vcc
Gnd – Gnd
Pin 13 – Pin 2
Pin 12 – Pin 1
Pin 11 – Pin 0
Pin 10 – Atur Ulang

Tambahkan kapasitor 10uF antara RESET dan GND di arduino. Hal ini untuk menghindari arduino auto reset saat kita mengupload program ke attiny85. Jika Anda menggunakan kapasitor elektrolitik pastikan anoda masuk dalam GND dari uno.

Mengunggah program ke ATtiny85
Sekarang kembali ke Arduino IDE. Pilih ATtiny di bawah Alat -> Papan. Kemudian pilih ATtiny85 di bawah Alat -> Prosesor. Dan pilih 8 MHz (internal) di bawah Tools -> Clock.

Kemudian pastikan Arduino sebagai ISP dipilih di bawah Alat -> Programmer

Secara default ATtiny85 berjalan pada 1MHz. Untuk membuatnya berjalan pada 8MHz pilih Tools -> Burn Bootloader.

Anda akan mendapatkan informasi seperti di atas jika burning bootloader berhasil.

Sekarang buka contoh Blink dari contoh arduino dan ubah nomor pin dari 13 menjadi 0 dan unggah.

Anda akan melihat informasi seperti di atas jika semuannya berhasil, sekarang mari kita Uji

Kontruksi untuk menguji Proyek

Sekarang waktunya untuk menguji. Hapus semua koneksi dari Arduino dan ambil sumber daya. Di sini saya akan menggunakan sel tombol untuk menyalakan ATtiny85.


Itu dia program kedip yang berjalan pada ATtiny85 hanya dengan sel baterai untuk menyalakannya. Anda dapat melakukan banyak proyek dengan biaya rendah, daya rendah, dan ruang rendah. Hanya imajinasi Anda yang membatasi di sini dan jumlah pin PWM tentunya.

Membuat menjadi Shield ATtiny85
Saya mengubah rangkaian di atas menjadi perisai yang kompatibel dengan Arduino Uno.

Shield ATtiny85



(Catatan: Menjadi pengembang perangkat lunak, ini adalah proyek pertama saya di bidang elektronik. Berikan saran Anda untuk membantu saya berbuat lebih banyak.)

Kode :

Program Kedip ATtiny85

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

Most Arduinos have an on-board LED you can control. On the Uno and
Leonardo, it is attached to digital pin 13. If you’re unsure what
pin the on-board LED is connected to on your Arduino model, check
the documentation at http://arduino.cc

This example code is in the public domain.

modified 8 May 2014
by Scott Fitzgerald
*/


// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(0, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
digitalWrite(0, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(0, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

Terima Kasih banyak atas kunjungan Anda

Dipublikasikan oleh Electric Dermayon

Lihat Postingan lainnya :

http://electricdermayon@gmail.com
Jl.Bukit Barisan Desa Mekarsari-Tukdana
Jl. Pantura Jatibarang-Kadipaten
Indramayu, Jawa Barat
Indonesia

Cara mengganti Air otomatis dengan Arduino

Proyek mengganti Air Otomatis

Dipublikasi : Indramayu, Indonesia

Pada Proyek ini mungkin kami akan menjelaskan lebih mendetail tentang Cara Mengganti Air secara Otomatis menggunakan Platform Arduino Uno.

Maksud dari “Cara Mengganti Air secara Otomatis” menggunakan Platform Arduino adalah ketika kita mempunyai sebuah Bak Aquarium atau Tampungan Air dan Air dalam tampungan tersebut Keruh, tentu saja kita akan menggantinya dengan Air yang lebih bersih, tapi terkadang kita lelah mengisinya atau membawa Air dengan sebuah Ember apalagi ketika kita memiliki banyak kesibukan, oleh karena itu tehnik ini mulai dipakai dalam lingkungan.

Proyek ini adalah Proyek yang Besar, mungkin sebagian pelajar mencari tehnik ini untuk menyelesaikan tugas Deskripsi dalam bidang Technik Elektro, Technik Informatika dan Technik bidang lainnya dalam bidang Electric dan Pemrograman. Kami menemukan Technik ini pada saat Studi Kami di bidang Technik Automotive, sebenarnya Technik ini juga di butuhkan oleh pelajar yang menekuni bidang Technik Automotive tentang System Pompa Oli Mesin (Motor Öl Pumpen System) dan Motor Benzin Pumpen System (System Pompa Tangki Bensin).

KOMPONEN :


• Mikrokontroler

Platform Arduino Uno R3


• Prototype Ekspansi IO untuk Arduino V7.1


Prototype Ekspansi IO

• Sensor Kekeruhan Analog Untuk Arduino

Sensor Kekeruhan Air jenis Analog


• Pompa Air (Tabung Immersible)

Pompa Air Aquarium


• Sensor pH Analog / Kit Meter Untuk Arduino

Sensor Kadar pH Analog


• Adaptor 12V DC (Catu daya).

Adaptor 12v DC


• Modul Relay 5A Digital

Relay 5A Digital


• Modul Tampilan LCD Arduino I2C 16×2

Fungsi-Fungsi Komponen :

• Platform Arduino.

Arduino adalah papan komputasi dunia fisik berukuran kecil untuk akademisi atau pengembangan. Ini adalah papan mikrokontroler sederhana yang sepenuhnya kompatibel dengan lingkungan pengembangan sumber terbuka Arduino UNO R3 dan Arduino IDE. Lingkungan ini mengimplementasikan bahasa Pemrosesan / Pengkabelan. Arduino dapat digunakan untuk mengembangkan objek interaktif yang berdiri sendiri atau dapat dihubungkan ke perangkat lunak di komputer Anda (misalnya Flash, Processing, MaxMSP). IDE sumber terbuka dapat diunduh secara gratis (saat ini untuk Mac OS X, Windows, dan Linux).

Board ini memiliki fitur ATmega16U2 yang diprogram sebagai konverter USB-to-serial. Bonus tambahan adalah DFRduino kami masih menggunakan Chip AVR paket DIP. Anda dapat menghapusnya untuk memperbarui atau memprogram ulang firmware chip, atau bahkan menempatkannya pada proyek yang sudah selesai dan lebih ringkas.

” Arduino Uno ” adalah papan mikrokontroler berbasis ATmega328 . Ini memiliki 14 pin input/output digital (6 di antaranya dapat digunakan sebagai output PWM), 6 input analog, osilator kristal 16 MHz, koneksi USB, colokan listrik, header ICSP, dan tombol reset. Ini berisi semua yang diperlukan untuk mendukung mikrokontroler; cukup sambungkan ke komputer dengan kabel USB atau nyalakan dengan adaptor AC-ke-DC atau baterai untuk memulai.

Board ini menambahkan pin SDA dan SCL yang dekat dengan pin AREF dan dua pin baru lainnya yang ditempatkan di dekat pin RESET, yaitu IOREF yang memungkinkan shield untuk beradaptasi dengan tegangan yang diberikan dari board. Di masa depan, perisai akan kompatibel baik dengan papan yang menggunakan AVR, yang beroperasi dengan 5V dan dengan “Arduino Due” yang beroperasi dengan 3.3V. Yang kedua adalah pin yang tidak terhubung, yang dicadangkan untuk tujuan di masa mendatang.

• Sensor kekeruhan Air.

Sensor Kekeruhan Air juga terdapat dengan penggunaan di Platform Arduino yang bertujuan untuk mendeteksi kualitas air dengan mengukur tingkat kekeruhan . Ia mampu mendeteksi partikel tersuspensi dalam air dengan mengukur transmisi cahaya dan laju hamburan yang berubah dengan jumlah total padatan tersuspensi (TSS) dalam air. Dengan meningkatnya TTS, tingkat kekeruhan cairan meningkat. Anda juga dapat memeriksa Panduan Pemilihan Sensor Cairan untuk lebih mengenal seri sensor cairan kami.
Sensor kekeruhan Arduino ini memiliki mode keluaran sinyal analog dan digital. Anda dapat memilih mode sesuai dengan MCU karena ambang batas dapat disesuaikan dalam mode sinyal digital.

Sensor kekeruhan dapat digunakan dalam pengukuran kualitas air di sungai dan sungai, pengukuran air limbah dan efluen, penelitian transportasi sedimen, dan pengukuran laboratorium.

• Pompa immersible

Ini dapat digunakan untuk menyiram tanaman Anda , membuat air mancur atau air terjun, bahkan mengganti air tangki ikan Anda. Ia bekerja dengan tenang dengan tingkat suara di bawah 40db.

Pompa memiliki filter di dalam serta cangkir hisap yang dapat membantu menempelkannya ke permukaan yang halus dengan erat.

Catatan: Pompa ini dimaksudkan untuk digunakan HANYA DI BAWAH air! (Coklat/Merah-Positif; Biru/Hitam-Negatif)

Aplikasi
Ini banyak digunakan untuk produk solar , air mancur, bebatuan, AC, lemari es dan peralatan industri pendingin dll.

• Sensor pH Analog.

Jika Anda Ingin mengukur kualitas air dan parameter lainnya tetapi tidak memiliki pH meter yang murah? Merasa sulit untuk digunakan dengan Arduino? Pengukur pH analog DFRobot, dirancang khusus untuk pengontrol Arduino dan memiliki konektor ” Gravitasi ” yang nyaman dan praktis serta banyak fitur. Koneksi instan ke probe Arduino Anda untuk mendapatkan pengukuran pH pada ± 0,1pH (25 ). Untuk sebagian besar penghobi, kisaran akurasi yang luar biasa ini dan biayanya yang rendah menjadikannya alat yang hebat untuk biorobotik dan proyek lainnya! Ini memiliki LED yang berfungsi sebagai Indikator Daya, konektor BNC, dan antarmuka sensor PH2.0. Untuk menggunakannya, cukup sambungkan sensor pH dengan konektor BND, dan colokkan antarmuka PH2.0 ke port input analog dari pengontrol Arduino apa pun. . Jika sudah diprogram, Anda akan mendapatkan nilai pH dengan mudah. Hadir dalam kotak plastik kompak dengan busa untuk penyimpanan seluler yang lebih baik.

Bangun gadget pengukur PH Anda sendiri atau stasiun pemantauan air untuk tangki air Anda. Ini dan perangkat sensor air kami yang lain dapat menjadi perangkat kontrol air terbaik. Gunakan untuk aquaponik Anda atau tangki ikan atau bahan lain yang membutuhkan pengukuran.

Ini adalah pemeriksaan laboratorium, tidak dapat direndam dalam cairan terlalu lama. Anda dapat memeriksa di sini untuk seluruh Analog pH Sensor / Meter Pro Kit Untuk Arduino atau Probe Industri cadangan sebagai pengganti

Sensor pH Analog /Kit Meter untuk Koneksi Arduino

Apa itu pH?

“pH adalah singkatan dari kekuatan hidrogen, yang merupakan pengukuran konsentrasi ion hidrogen dalam tubuh. Skala pH total berkisar dari 1 hingga 14, dengan 7 dianggap netral. pH kurang dari 7 dikatakan asam dan larutan dengan pH lebih besar dari 7 bersifat basa atau basa.

Catatan: Solusi buffer tidak disertakan.
Setelah Anda menerima paket Anda! Anda mungkin menemukan beberapa partikel putih pada busa pelindung yang merupakan kristalisasi KCl dari tutupnya. Tolong jangan khawatir tentang kristalisasi di kotak kemasan, itu normal. Sebenarnya, karena pembatasan transportasi pada cairan, kami telah menuangkan larutan KCL3N di tutupnya, sedikit kristalisasi di kotak kemasan harus bocor sejak sisa. Bagaimanapun, setelah Anda menerima probe, Anda harus menyimpannya dalam larutan KCL3N, Anda tidak dapat meninggalkannya dalam keadaan kering.

Aplikasi
Pengujian kualitas air
Akuakultur

• Adaptor 12v DC (Catu Daya)

Kualitas tinggi switching ‘kutil dinding’ ‘adaptor dinding’ AC ke catu daya dinding DC 12V 1A. Ini adalah catu daya mode sakelar yang berarti output diatur ke 12V (tidak ada lagi output 14V!). Mereka mengambil input 100-240Vac 50/60Hz dan output 12V 1A. Ini akan memberi daya pada sebagian besar proyek yang tidak memerlukan lebih dari 1A arus. Konektor barel 5.5×2.1mm (0.22×0.08 “) pusat-positif dapat langsung dicolokkan ke Arduino Power Jack standar. Mereka dirancang untuk mengambil SATU posisi di strip outlet atau stopkontak Anda. Ini akan mengubah tegangan internasional (100V-240Vac 50/60Hz) secara otomatis; tidak diperlukan transformator. Bagus untuk banyak proyek elektronik!

• Modul Relay 5A Digital.

Modul Relay 5A Digital adalah relai standar yang digunakan dengan papan pengontrol untuk menghubungkan sirkuit atau modul listrik eksternal . Beberapa aplikasi yang paling umum dengan Arduino adalah: Pencahayaan rumah, peralatan listrik berdaya tinggi dan peralatan lainnya. Desain modular memudahkan integrasi dengan papan pengontrol . Relay mengintegrasikan LED status , untuk mengenali statusnya ON atau OFF secara visual. Ini dapat dikontrol melalui port IO digital, dengan papan HIGH atau LOW sederhana yang kompatibel dengan Arduino . Papan lain akan bekerja membutuhkan tingkat tegangan yang sama. Penggunaan lain termasuk kontrol katup solenoid, lampu, motor dan perangkat arus tinggi atau tegangan tinggi lainnya.

Diagram Kontruksi Modul Relay 5A Digital



Meningkatkan silkscreen pada lapisan bawah sensor untuk menunjukkan koneksi perangkat keras.
Beberapa kit mungkin termasuk dudukan akrilik dan set sekrup nilon untuk mencegah korsleting antarmuka daya tinggi dengan permukaan logam.

• Modul I2C LCD 16X2.

Ini adalah tampilan layar LCD 16×2 dengan antarmuka I2C. Hal ini dapat menampilkan 16×2 karakter pada 2 baris, karakter putih pada latar belakang biru.

Biasanya, proyek tampilan LCD Arduino akan mudah kehabisan sumber daya pin, terutama dengan Arduino Uno . Dan itu juga sangat rumit dengan penyolderan dan penyambungan kawat. Layar LCD Arduino I2C 16×2 ini menggunakan antarmuka komunikasi I2C. Artinya hanya membutuhkan 4 pin untuk tampilan LCD : VCC, GND, SDA, SCL. Ini akan menghemat setidaknya 4 pin digital/analog di Arduino . Semua konektor adalah XH2.54 standar (tipe papan tempat memotong roti). Anda dapat terhubung dengan kabel jumper secara langsung.

Modul LCD I2C 16×2


Untuk menghindari konflik alamat I2C dengan perangkat I2C lainnya, seperti sensor ultrasonik , IMU , akselerometer, dan giroskop, alamat I2C modul dapat dikonfigurasi dari 0x20-0x27. Dan kontrasnya dapat diatur secara manual.

Pilihan alternatif lainnya adalah I2C 20×4 Arduino LCD Display Module jika diperlukan lebih banyak karakter.

Implementasi semua fungsi modul
Persediaan air


Pasokan air adalah mata rantai termudah di seluruh sistem. Disini saya menggunakan Immersible Pump & WaterTube .

Tempatkan badan pompa dalam wadah berisi air bersih, dan tempatkan pipa air di tangki ikan. Air bersih akan dengan mudah dipasok ke tangki ikan hanya setelah dihidupkan.


Ada masalah kecil. Pipa air sering bergerak selama pasokan air. Jadi saya mendesain ini.

Pipa air tidak akan bergerak setelah diperbaiki dengan cara ini.

Gambar model bagian pemasangan adalah seperti yang ditunjukkan di bawah ini. Teman-teman yang tertarik dapat merujuknya.



1. Pengeringan air
Saya menghabiskan banyak waktu untuk menguras air.

Setelah cairan diisi dalam struktur pipa berbentuk U dengan menggunakan gaya yang diterapkan dari perbedaan ketinggian level cairan, tempatkan ujung dengan bukaan tinggi ke dalam wadah berisi cairan. Kemudian, cairan dalam wadah akan terus mengalir keluar dari lubang di posisi bawah melalui siphon.

Prinsip fisiknya adalah, dua wadah memiliki ketinggian level cairan yang berbeda; setelah cairan dalam dua wadah tersebut dihubungkan, tren gerak tingkat cairan yang sama akan dipertahankan, yaitu gaya resultan yang ditanggung oleh cairan yang mengalir akan berubah ke bawah, sehingga cairan akan mengalir ke tempat yang lebih rendah.

Umumnya tangki ikan diletakkan di atas meja, jadi saya hanya perlu meletakkan ember (atau wadah lain) di tanah dan kemudian menggunakan pipa untuk menghubungkannya.

Setelah pengurasan air berhasil direalisasikan, saya menambahkan katup solenoid. Sakelar akan dihidupkan setelah dihidupkan dan dimatikan setelah dimatikan. Kemudian, Anda dapat mengalirkan air sesuai keinginan.

Memperhatikan:
1. Pipa air harus berdiameter kecil, karena kami memelihara beberapa ikan kecil, dan pipa berdiameter besar akan menyerap ikan-ikan kecil keluar dari tangki.

2. Disarankan untuk membeli katup solenoid dengan kapasitas minimum on line (9V atau 12V), tidak hanya menghemat daya tetapi juga memiliki sedikit kebisingan. Tidak perlu menggunakan kapasitas yang lebih besar.

3. Untuk pengurasan air berdasarkan prinsip siphon, pertama-tama harus ada air di dalam pipa air yang menghubungkan kedua wadah. Saya mengisap ringan dengan mulut saya ketika seluruh sistem mulai beroperasi.

Jika menurut Anda itu kotor, Anda dapat membeli perangkat ekstraksi udara manual secara online. Air akan dipompa dengan cara meremas di sini dengan tangan Anda seperti yang ditunjukkan pada gambar di bawah ini.


2. Deteksi otomatis nilai PH dan nilai kekeruhan
Nilai PH dan nilai kekeruhan harus dipilih sebagai indeks untuk penggantian air. Fluktuasi nilai PH air di tangki ikan tidak boleh melebihi 0,2, yaitu, perubahan kualitas air harus dikontrol dalam waktu 1,6 kali untuk setiap penggantian air. Jika demikian, tidak apa-apa untuk mengganti 1/2 air dengan suhu yang sama. Jika tidak, volume penggantian air yang diizinkan lebih sedikit.

Saya memutuskan untuk hanya mengganti sekitar sepersepuluh hingga seperdua belas air setiap kali. Namun frekuensi pergantian air ini harus tinggi, yaitu air perlu diganti bila nilai PH dan nilai kekeruhan yang terdeteksi tidak sesuai dengan spesifikasi. Diperkirakan, air perlu diganti tiga atau empat kali sehari. Frekuensi seperti itu tidak tinggi.


3. Tampilan
Saya menggunakan I2C 16×2 Arduino LCD Display Module.

Tes keseimbangan level air
Masalah ini perlu dijelaskan secara terpisah. Meskipun kami telah menyadari otomatisasi pengurasan dan suplai air, kami tidak dapat menjaga keseimbangan level air di bawah otomatisasi ini, karena kecepatan pengurasan dan suplai air berbeda. Kecepatan diatur selama produksi. Oleh karena itu, saya perlu mencari cara untuk mengukur kecepatan pengurasan dan suplai air, dan kemudian memodifikasi durasi operasinya sesuai untuk mencapai keseimbangan level air.

Pengujian sebagai berikut:

Pertama, kami memeriksa Kapasitas Tangki ikan secara visual, sekitar 15 Liter . Sepersepuluh air diganti setiap kali, yaitu 1,5 Liter. Dengan pembulatan, saya memutuskan untuk menggunakan air 2 Liter untuk melakukan tes.

Saya tidak punya gelas ukur, jadi saya memutuskan untuk menggunakan gelas atau cangkir dengan kapasitas 250 ml. 2 Liter air berarti 8 gelas. Saya menggunakan cangkir untuk menuangkan air ke sebuah Ember sebanyak 8 kali. Kemudian, saya mulai menguji kecepatan pasokan air:

Saat memasok air, kami mulai menggunakan stopwatch di ponsel kami untuk mengatur waktu. Akhirnya, waktu penyediaan air yang dihitung adalah 1:01:71.

Kemudian, saya menguji kecepatan pengeringan air:

Sementara itu, saya juga mencatat waktu pengurasan air 3:56:20

Perhitungannya adalah :
Waktu pasokan air: 1.01.71=61.71 dtk
Kecepatan suplai air: 2000/61=32,41ml/dtk
Waktu pengeringan air: 3.56.20=236.20 dtk
Kecepatan pengeringan air: 2000/236.20 = 8.47ml/dtk

Water supply time: 1.01.71=61.71S
Water supply speed: 2000/61=32.41ml/s
Water draining time: 3.56.20=236.20S
Water draining speed: 2000/236.20=8.47ml/s

Kode Program

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x20,16,2);//
#define TurbidityPin A0//
#define PHPin A1//
#define Supplywaterpin 11//
#define Drainwaterpin 12//
float Turbidityval;//
float PHval;//
void setup()
{
lcd.init();//
lcd.backlight();//
pinMode(Supplywaterpin, OUTPUT);//
pinMode(Drainwaterpin, OUTPUT);//
Serial.begin(9600); //
}
void loop()
{
getTurbidity();//
getPH();//


if (Turbidityval<4.06 || PHval<7.0 || PHval>8)//
{
delay(10000);
getTurbidity();//
getPH();//
if(Turbidityval<4.06 || PHval<7.0 || PHval>8)//
{
Serial.print(“change water”);
Drainwater();//
Supplywater();//
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“change water”);
delay(20000);//
Supplywater_end();//
lcd.setCursor(0,0);
lcd.print(“change water”);
delay(56000);//
}
else
{
Serial.print(” no change “);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“no change”);
Drainwater_end();//
Supplywater_end();//
delay(8000);//
}
}
else
{
delay(10000);//
}
}

void getTurbidity()//
{
Turbidityval=analogRead(A0)/1024.0*5.0;
Serial.print(” Trubidity value: “);
Serial.println( Turbidityval);//
lcd.setCursor(0,0);
lcd.print(“Turbidity:”);
lcd.setCursor(12,0);
lcd.println(Turbidityval);
}

void getPH()//
{
PHval=analogRead(A1)/1024.0*5.0*1.45;
Serial.print(” PH value: “);
Serial.println(PHval);
lcd.setCursor(0,1);
lcd.print(“PH:”);
lcd.setCursor(12,1);
lcd.println(PHval);
}


void Supplywater()//
{
digitalWrite(Supplywaterpin, HIGH);
}


void Drainwater()//
{
digitalWrite(Drainwaterpin, HIGH);
}


void Supplywater_end()//
{
digitalWrite(Supplywaterpin, LOW);
}


void Drainwater_end()//
{
digitalWrite(Drainwaterpin, LOW);
}

Penjelasan rinci telah ditambahkan. Saya percaya Anda bisa mengerti sebagian besar. Namun, saya ingin membuat beberapa penjelasan tentang poin berikut:
“if (Turbidityval<4.06 || PHval<7.0 || PHval>8)// jika output sensor kekeruhan kurang dari 4V atau nilai PH kurang dari 6,5
{
penundaan (10000);
getTurbidity();//pembacaan kekeruhan
getPH();//pembacaan nilai PH
if(Turbidityval<4.06 || PHval<7.0 || PHval>8)// kekeruhan dan nilai PH masih memenuhi kondisi perubahan air”

Mengapa ada dua “pernyataan if” di atas?

Karena ikan melewati sensor kekeruhan secara sembarangan atau pakan ikan berserakan di dekat sensor kekeruhan yang akan menyebabkan kekeruhan sementara.

Kita tentu tahu bahwa air tidak benar-benar keruh. Namun, mesin tidak tahu, jadi kami harus memberi tahu mesin.

Jadi, saya menambahkan baris kode ini. Peralatan akan menentukan air keruh jika mendeteksi air tetap keruh dalam waktu 10 detik. (Ikan harus memakan pakan di lokasi dalam 10 detik)

Untuk waktu pengurasan dan penyediaan air, saya merencanakan batas perubahan volume pada frekuensi tinggi, sehingga setiap waktu pemberian air hanya 20 detik, dan waktu pengurasan air adalah 20*3,8=76 detik.

Lihat Postingan lainnya :

Membuat Sistem Pergantian Air dengan Arduino

Bagi warga yang tinggal di pedesaan, keterbatasan ketersediaan air merupakan masalah yang sangat umum. Oleh karena itu, banyak orang memasang tangki air di atap gedung. Air, yang disimpan dalam tangki air di basement (tanah) dipompa ke tangki air di atap menggunakan motor pompa. Dengan cara ini, masalah ketersediaan air yang terbatas dapat diperbaiki dan air dapat digunakan dengan cara yang lebih efisien jika pengontrol pompa tangki air otomatis disertakan dalam pengaturan.

Menggunakan tradisional untuk pengontrol ketinggian air memiliki keunggulan struktur sederhana dan biaya rendah. Pengontrol ketinggian air tradisional dapat mengontrol air di antara dua tingkat dengan bantuan bola mengambang/saklar pelampung sebagai sensor untuk pendeteksian ketinggian. Sesuai dengan posisi bola apung/saklar pengapung, sambungan listrik motor pompa diatur ke on atau off. Namun, unit pengontrol biasanya ditempatkan di bagian atas tangki air, kelembaban dapat menimbulkan korosi pada titik kontak sakelar sensor. Ini akan menyebabkan sakelar sensor menjadi tidak berfungsi. Sementara itu, karena tidak ada alat untuk mendeteksi ketinggian air tangki air basement, ada kemungkinan motor pompa akan terbakar jika ketinggian air di tangki air basement sangat rendah/nol.

Perangkat Keras Saklar Pompa Tangki Air Otomatis Automatic

•Unit Mikrokontroler: Rangkaian yang dirancang yang ditampilkan di sini mencakup Atmega328P-PU sebagai kernel, sejumlah LED untuk menampilkan status sistem, sakelar tombol tekan untuk pemilihan mode otomatis/manual, relai elektromagnetik sebagai penggerak motor pompa, dan beberapa komponen eksternal lainnya.

Ide desain dasarnya adalah mengatur dua port MCU untuk deteksi ketinggian air, satu port untuk pemilihan sakelar mode otomatis/manual, dan dua port untuk indikasi status visual. Dari pembacaan port pendeteksi ketinggian air, perangkat lunak internal dapat menentukan ketinggian air tangki air di atas kepala. Perhatikan bahwa opsi penyimpanan E 2 PROM dari mikrokontroler juga digunakan di sini.

Diagram Sistem Dasar

•Sensor Ketinggian Air: ketinggian tangki air atap (overhead) tidak lain adalah sakelar apung (siap pakai/buatan sendiri) yang digerakkan vertikal-mount (tingkat 2 titik) terdiri dari sensor ketinggian air rendah dan tinggi, ditempatkan di dua ketinggian yang berbeda di tangki air di atas kepala. Sensor level tangki air bawah tanah adalah sakelar apung sederhana (level 1 titik) lainnya, yang ditambahkan sebagai pelindung dry-run. Sakelar buluh tertutup rapat dalam kaca yang terletak di dalam batang diaktifkan/dinonaktifkan oleh gerakan magnet kuat ke atas/bawah di bagian ekor pelampung.

•Unit Catu Daya: Sirkuit akan bekerja dengan tegangan suplai DC dalam rentang 9 – 12V, dan karenanya setiap adaptor daya dc standar 1 Amper dengan tegangan output dalam rentang tersebut dapat digunakan untuk memberi energi ke seluruh sistem. Regulator tegangan linier on-board disertakan dalam sistem untuk menyediakan suplai dc bersih ke seluruh sirkuit elektronik.

Deskripsi sistem
Sebagaimana dinyatakan, untuk membaca ketinggian air tangki air di atas ada dua sensor, satu untuk level rendah (L) dan yang lainnya untuk level tinggi (H). Coba gunakan sakelar pelampung magnet yang mengaktifkan dua sensor buluh sehingga pelampung (dengan magnet) harus menghentikan perjalanannya di depan sensor buluh L dan H. Jika sensor L memicu input mikrokontroler, pompa air diaktifkan. Sekarang LED indikator STANDBY mati, dan LED indikator PUMP ON menyala. Ketika level H tercapai, yaitu sensor H memicu input mikrokontrolernya, pompa air dinonaktifkan. Sekarang indikator PUMP ON mati, dan indikator STANDBY menyala lagi. Pompa air diaktifkan kembali hanya ketika air turun kembali ke level L.

Selanjutnya, dalam mode otomatis, jika sensor ketiga (opsional) (sensor dry run) dipasang di tangki air basement, sensor (G) memicu input mikrokontrolernya untuk menginformasikan sistem bahwa tidak ada air di tangki air basement.
Akibatnya, sistem segera menonaktifkan pompa air untuk melindungi motor listrik pompa air.

Sensor Ketinggian Air

Sistem ini juga dilengkapi dengan operasi Otomatis/Manual. Dalam mode AUTO, pompa air berhenti kemudian level air maksimum (H) tercapai. Dalam mode MANUAL, proses deteksi ketinggian air diganti dan pompa air terus bekerja tanpa henti. Secara bersamaan, LED indikator mode MANUAL menyala sebagai indikator peringatan.
Mode AUTO/MAN dapat dialihkan pada ketinggian air mana pun menggunakan sakelar tombol tekan AUTO/MAN.

Deskripsi Sirkuit atau Kontruksi

Kontruksi FTDI

Chip Atmega328P-PU (IC1) di sirkuit ini sebenarnya adalah chip Arduino UNO, artinya IC1 menyimpan kode kecil yang disiapkan & diproses menggunakan Arduino IDE. Sakelar S1 adalah sakelar reset tradisional seperti yang ditemukan di papan Arduino. Di sini, port PD2, PD4 dan PD7 dari IC1 (D2, D4, D7 dari Arduino) dikonfigurasikan sebagai port input, dan port PB0, PB4 dan PB5 (D8, D12, D13 dari Arduino) dikonfigurasikan sebagai port output. Port PD2 terhubung ke sakelar pemilih mode AUTO/MAN. Sensor ketinggian air dibaca oleh port PD4 dan PD5. Port PB5 digunakan untuk mengontrol motor pompa air melalui relai elektromagnetik tugas berat (RL1) dengan bantuan transistor driver (T1). Port output lainnya (PB0 & PB5) digunakan untuk menggerakkan indikator status sistem (LED1 & LED2).

IC1 (tentu saja dengan Arduino UNO Bootloader yang telah dimuat sebelumnya) dapat diprogram/diprogram ulang melalui soket antarmuka serial J3 menggunakan papan FTDI Basic (papan konverter serial usb) yang tersedia secara umum. Sensor ketinggian air tangki air di atap, dan sensor ketinggian air tangki air di basement (tanah) dapat dihubungkan ke sirkuit melalui soket J1 dan J2 masing-masing.

Soket J4 adalah soket input DC, dari mana sistem ditenagai oleh suplai 5VDC yang diatur, yang telah diproses sebelumnya oleh chip pengatur tegangan terpasang (IC2). LED4 berfungsi sebagai indikator status catu daya (hidup/mati).

Dasar FTDI

Deskripsi Perangkat Lunak

Dari diagram sirkuit (perangkat keras), seseorang dapat menemukan bahwa sangat sedikit komponen eksternal yang diperlukan. Selain itu, orang juga dapat menemukan bahwa perangkat lunak ini sangat mudah untuk dimodifikasi jika lebih banyak fungsi yang akan ditambahkan. Ini akan meningkatkan fleksibilitas dan tanggung jawab desain. Berikut adalah inti logika mikrokontroler, disiapkan di Arduino IDE:

Download Kode
Tata letak Komponen yang disarankan untuk Papan PCB dua sisi

Tata letak komponen yang disarankan untuk PCB dua sisi

Mikrokontroler pada board Arduino memiliki memori EEPROM (E 2 PROM) yang nilainya disimpan saat board dimatikan. Pustaka EEPROM memungkinkan Anda membaca dan menulis byte tersebut. Mikrokontroler Atmega328 memiliki jumlah 1024 byte.

Terima Kasih banyak atas kunjungan Anda

Dipublikasikan oleh Electric Dermayon©

Proyek Remot Arduino

Proyek Remott dengan Inframerah(IR)

Dikirim oleh Electric Dermayon

Komunikasi inframerah (IR) adalah teknologi nirkabel yang banyak digunakan dan mudah diimplementasikan yang memiliki banyak aplikasi yang berguna. Contoh paling menonjol dalam kehidupan sehari-hari adalah remote control TV/video, sensor gerak, dan termometer inframerah.

Ada banyak proyek Arduino menarik yang menggunakan komunikasi IR juga. Dengan pemancar dan penerima IR sederhana, Anda dapat membuat robot yang dikendalikan dari jarak jauh, sensor jarak, monitor detak jantung, kendali jarak jauh kamera DSLR, kendali jarak jauh TV, dan banyak lagi.

Dalam tutorial ini pertama saya akan menjelaskan apa itu inframerah dan bagaimana cara kerjanya. Kemudian saya akan menunjukkan cara mengatur penerima IR dan remote pada Arduino . Saya juga akan menunjukkan cara menggunakan hampir semua remote IR (seperti yang untuk TV Anda) untuk mengontrol hal-hal yang terhubung ke Arduino.

APA ITU INFRAMERAH?

Radiasi inframerah adalah bentuk cahaya yang mirip dengan cahaya yang kita lihat di sekitar kita. Satu-satunya perbedaan antara cahaya IR dan cahaya tampak adalah frekuensi dan panjang gelombang. Radiasi inframerah terletak di luar jangkauan cahaya tampak, sehingga manusia tidak dapat melihatnya:

Tutorial Arduino IR – Diagram Spektrum Elektromagnetik
Karena IR adalah jenis cahaya, komunikasi IR membutuhkan garis pandang langsung dari penerima ke pemancar. Itu tidak dapat mentransmisikan melalui dinding atau bahan lain seperti WiFi atau Bluetooth.

CARA KERJA REMOTE DAN PENERIMA IR

Sistem komunikasi inframerah yang khas memerlukan pemancar IR dan penerima IR. Pemancar terlihat seperti LED standar, kecuali ia menghasilkan cahaya dalam spektrum IR, bukan spektrum yang terlihat. Jika Anda melihat bagian depan remote TV, Anda akan melihat LED pemancar IR:

Tutorial Jarak Jauh Arduino IR – Mengirimkan LED pada Jarak Jauh
Jenis LED yang sama digunakan pada papan breakout pemancar IR untuk Arduino. Anda dapat melihatnya di bagian depan pemancar IR Keyes ini:

Tutorial Jarak Jauh Arduino IR – LED Pemancar IR 2
Penerima IR adalah fotodioda dan pra-penguat yang mengubah cahaya IR menjadi sinyal listrik. Dioda penerima IR biasanya terlihat seperti ini:

Tutorial Jarak Jauh Arduino IR – Dua Dioda Penerima IR
Beberapa mungkin muncul di papan breakout seperti ini:

MODULASI SINYAL IR

Cahaya IR dipancarkan oleh matahari, bola lampu, dan apa pun yang menghasilkan panas. Itu berarti ada banyak kebisingan cahaya IR di sekitar kita. Untuk mencegah noise ini mengganggu sinyal IR, digunakan teknik modulasi sinyal.

Dalam modulasi sinyal IR, encoder pada remote IR mengubah sinyal biner menjadi sinyal listrik termodulasi. Sinyal listrik ini dikirim ke LED transmisi. Transmisi LED mengubah sinyal listrik termodulasi menjadi sinyal cahaya IR termodulasi. Penerima IR kemudian mendemodulasi sinyal cahaya IR dan mengubahnya kembali menjadi biner sebelum meneruskan informasi ke mikrokontroler:

Tutorial Penerima Jarak Jauh Arduino IR – Modulasi Sinyal IR
Sinyal IR termodulasi adalah serangkaian pulsa cahaya IR yang dinyalakan dan dimatikan pada frekuensi tinggi yang dikenal sebagai frekuensi pembawa. Frekuensi pembawa yang digunakan oleh sebagian besar pemancar adalah 38 kHz, karena sifatnya yang langka sehingga dapat dibedakan dari kebisingan sekitar. Dengan cara ini penerima IR akan mengetahui bahwa sinyal 38 kHz dikirim dari pemancar dan tidak diambil dari lingkungan sekitar.

Dioda penerima mendeteksi semua frekuensi cahaya IR, tetapi memiliki filter band-pass dan hanya memungkinkan melalui IR pada 38 kHz. Kemudian memperkuat sinyal termodulasi dengan pre-amplifier dan mengubahnya menjadi sinyal biner sebelum mengirimkannya ke mikrokontroler.

PROTOKOL TRANSMISI IR

Pola di mana sinyal IR termodulasi diubah menjadi biner ditentukan oleh protokol transmisi. Ada banyak protokol transmisi IR. Sony, Matsushita, NEC, dan RC5 adalah beberapa protokol yang lebih umum.

Semua Iklan PCB
Protokol NEC juga merupakan jenis yang paling umum dalam proyek Arduino, jadi saya akan menggunakannya sebagai contoh untuk menunjukkan kepada Anda bagaimana penerima mengubah sinyal IR termodulasi menjadi biner.

Logika ‘1’ dimulai dengan pulsa HIGH panjang 562,5 s dari 38 kHz IR diikuti oleh pulsa LOW panjang 1,687,5 s. Logika ‘0’ ditransmisikan dengan pulsa HIGH panjang 562,5 s diikuti oleh pulsa LOW 562,5 s:

Tutorial Penerima Jarak Jauh Arduino IR – Protokol NEC
Ini adalah bagaimana protokol NEC mengkodekan dan mendekode data biner menjadi sinyal termodulasi. Protokol lain hanya berbeda dalam durasi pulsa TINGGI dan RENDAH individu.

KODE IR

Setiap kali Anda menekan tombol pada remote control, kode heksadesimal unik dihasilkan. Ini adalah informasi yang dimodulasi dan dikirim melalui IR ke penerima. Untuk menguraikan tombol mana yang ditekan, mikrokontroler penerima perlu mengetahui kode mana yang sesuai dengan setiap tombol pada remote.

Remote yang berbeda mengirimkan kode yang berbeda untuk penekanan tombol, jadi Anda harus menentukan kode yang dihasilkan untuk setiap tombol pada remote khusus Anda. Jika Anda dapat menemukan lembar data, kode kunci IR harus dicantumkan. Jika tidak, ada sketsa Arduino sederhana yang akan membaca sebagian besar kendali jarak jauh populer dan mencetak kode heksadesimal ke monitor serial saat Anda menekan tombol. Saya akan menunjukkan cara mengaturnya sebentar lagi, tetapi pertama-tama kita harus menghubungkan receiver ke Arduino…

CARA MENGHUBUNGKAN PENERIMA IR KE ARDUINO

Ada beberapa jenis penerima IR yang berbeda, ada yang berdiri sendiri, dan ada yang dipasang di papan breakout. Periksa lembar data untuk penerima IR khusus Anda karena pin mungkin disusun secara berbeda dari penerima IR HX1838 dan perangkat jarak jauh yang saya gunakan di sini. Namun, semua penerima IR akan memiliki tiga pin: sinyal, ground, dan Vcc.

Mari kita mulai dengan koneksi perangkat keras. Tata letak pin pada sebagian besar papan breakout terlihat seperti ini:

Pinout dari kebanyakan dioda yang berdiri sendiri adalah seperti ini:

Diagram Pinout Stand-Alone Penerima IR
Untuk menghubungkan penerima IR yang dipasang di papan breakout, sambungkan ke Arduino seperti ini:

Arduino IR Remote Receiver – Diagram Pengkabelan Papan Breakout
Untuk menghubungkan dioda penerima yang berdiri sendiri, sambungkan seperti ini:


Arduino IR Remote Receiver – Diagram Pengkabelan Penerima IR yang Berdiri Sendiri

MEMPROGRAM PENERIMA IR

Setelah penerima terhubung, kita dapat menginstal perpustakaan Arduino dan memulai pemrograman. Pada contoh di bawah ini, saya akan menunjukkan cara menemukan kode yang dikirim oleh remote Anda, cara menemukan protokol IR yang digunakan oleh remote Anda, cara mencetak penekanan tombol ke monitor serial atau LCD, dan terakhir, cara mengontrol pin output Arduino dengan remote.

INSTAL PERPUSTAKAAN IRREMOTE

Kami akan menggunakan perpustakaan IRremote untuk semua contoh kode di bawah ini. Anda juga dapat mengunduh file ZIP perpustakaan di Internet atau di situs http://www.arduino.cc.

Untuk menginstal library dari file ZIP, buka Arduino IDE, lalu buka Sketch > Include Library > Add .ZIP Library, lalu pilih file IRremote ZIP yang Anda download.

TEMUKAN KODE UNTUK REMOTE ANDA

Untuk menemukan kode kunci untuk remote control Anda, unggah kode ini ke Arduino Anda dan buka monitor serial:

#include <IRremote.h>

const int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup(){
  Serial.begin(9600);
  irrecv.enableIRIn();
  irrecv.blink13(true);
}

void loop(){
  if (irrecv.decode(&results)){
        Serial.println(results.value, HEX);
        irrecv.resume();
  }

Sekarang tekan setiap tombol pada remote Anda dan catat kode heksadesimal yang dicetak untuk setiap penekanan tombol.

Dengan menggunakan program di atas, saya mendapatkan tabel kunci dan kode yang sesuai dari remote yang disertakan dengan receiver IR HX1838 dan remote set saya . Perhatikan bahwa Anda akan menerima kode 0XFFFFFFFF ketika Anda menekan tombol terus menerus.

Kunci       Kode
 CH-        0xFFA25D
 CH         0xFF629D
 CH+        0xFFE21D
 <<         0xFF22DD
 >>         0xFF02FD
 >>|        0xFFC23D
 -          0xFFE01F
 +          0xFFA857
 persamaan  0xFF906F
 100+       0xFF9867
 200+       0xFFB04F
 0           0XFF6897
 1           0xFF30CF
 2           0xFF18E7
 3           0xFF7A85
 4           0xFF10EF
 5           0xFF38C7
 6           0xFF5AA5
 7           0xFF42BD
 8           0xFF4AB5
 9           0xFF52AD

TEMUKAN PROTOKOL YANG DIGUNAKAN OLEH REMOTE ANDA

Mengetahui protokol mana yang digunakan jarak jauh Anda dapat berguna jika Anda ingin mengerjakan beberapa proyek yang lebih maju. Atau mungkin Anda hanya penasaran. Program di bawah ini akan mengidentifikasi protokol yang digunakan oleh remote Anda. Itu bahkan harus bekerja pada sebagian besar remote control di sekitar rumah Anda.

#include <IRremote.h>

const int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup(){
  Serial.begin(9600);
  irrecv.enableIRIn();
  irrecv.blink13(true);
}

void loop(){
  if (irrecv.decode(&results)){
        Serial.println(results.value, HEX);
        switch (results.decode_type){
            case NEC: Serial.println("NEC"); break ;
            case SONY: Serial.println("SONY"); break ;
            case RC5: Serial.println("RC5"); break ;
            case RC6: Serial.println("RC6"); break ;
            case DISH: Serial.println("DISH"); break ;
            case SHARP: Serial.println("SHARP"); break ;
            case JVC: Serial.println("JVC"); break ;
            case SANYO: Serial.println("SANYO"); break ;
            case MITSUBISHI: Serial.println("MITSUBISHI"); break ;
            case SAMSUNG: Serial.println("SAMSUNG"); break ;
            case LG: Serial.println("LG"); break ;
            case WHYNTER: Serial.println("WHYNTER"); break ;
            case AIWA_RC_T501: Serial.println("AIWA_RC_T501"); break ;
            case PANASONIC: Serial.println("PANASONIC"); break ;
            case DENON: Serial.println("DENON"); break ;
          default:
            case UNKNOWN: Serial.println("UNKNOWN"); break ;
          }
        irrecv.resume();
 }
}

CETAK KUNCI KE SERIAL MONITOR

Saya memperluas kode di atas untuk mencetak nilai kunci alih-alih kode heksadesimal:

#include <IRremote.h>

const int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
unsigned long key_value = 0;

void setup(){
  Serial.begin(9600);
  irrecv.enableIRIn();
  irrecv.blink13(true);
}

void loop(){
  if (irrecv.decode(&results)){
 
        if (results.value == 0XFFFFFFFF)
          results.value = key_value;

        switch(results.value){
          case 0xFFA25D:
          Serial.println("CH-");
          break;
          case 0xFF629D:
          Serial.println("CH");
          break;
          case 0xFFE21D:
          Serial.println("CH+");
          break;
          case 0xFF22DD:
          Serial.println("|<<");
          break;
          case 0xFF02FD:
          Serial.println(">>|");
          break ;  
          case 0xFFC23D:
          Serial.println(">|");
          break ;               
          case 0xFFE01F:
          Serial.println("-");
          break ;  
          case 0xFFA857:
          Serial.println("+");
          break ;  
          case 0xFF906F:
          Serial.println("EQ");
          break ;  
          case 0xFF6897:
          Serial.println("0");
          break ;  
          case 0xFF9867:
          Serial.println("100+");
          break ;
          case 0xFFB04F:
          Serial.println("200+");
          break ;
          case 0xFF30CF:
          Serial.println("1");
          break ;
          case 0xFF18E7:
          Serial.println("2");
          break ;
          case 0xFF7A85:
          Serial.println("3");
          break ;
          case 0xFF10EF:
          Serial.println("4");
          break ;
          case 0xFF38C7:
          Serial.println("5");
          break ;
          case 0xFF5AA5:
          Serial.println("6");
          break ;
          case 0xFF42BD:
          Serial.println("7");
          break ;
          case 0xFF4AB5:
          Serial.println("8");
          break ;
          case 0xFF52AD:
          Serial.println("9");
          break ;      
        }
        key_value = results.value;
        irrecv.resume(); 
  }
}

Jika remote Anda mengirimkan kode yang berbeda dari yang ada di tabel di atas, ganti saja kode hex di setiap baris yang bertuliskan:

case 0xFFA25D:
Serial.println(“CH-“);
Pada baris ini, ketika kode hex 0xFFA25D diterima, Arduino mencetak “CH-“.

CARA KERJA KODE

Untuk komunikasi IR apa pun yang menggunakan perpustakaan IRremote, pertama-tama kita perlu membuat objek yang disebut irrecv dan menentukan nomor pin tempat penerima IR terhubung (baris 3). Objek ini akan menangani protokol dan pemrosesan informasi dari penerima.

Langkah selanjutnya adalah membuat objek bernama results, dari decode_resultskelas, yang akan digunakan oleh irrecvobjek untuk berbagi informasi yang didekodekan dengan aplikasi kita (baris 5).

Di void setup()blok, pertama kita konfigurasikan baud rate monitor serial. Selanjutnya kita memulai penerima IR dengan memanggil IRrecv fungsi anggota enableIRIn()(baris 10).

Fungsi pada baris 11 akan berkedip Arduino di papan LED setiap kali penerima mendapat sinyal dari remote control, yang berguna untuk debugging. irrecv.blink13(true)

Di void loop()blok, fungsi irrecv.decode akan mengembalikan true jika kode diterima dan program akan mengeksekusi kode dalam pernyataan if. Kode yang diterima disimpan dalam results.value. Kemudian saya menggunakan sakelar untuk menangani setiap kode IR dan mencetak nilai kunci yang sesuai.

Sebelum blok sakelar dimulai, ada blok bersyarat:

if (results.value == 0XFFFFFFFF)
results.value = key_value;
Jika kita menerima 0XFFFFFFFF dari remote, itu berarti pengulangan dari kunci sebelumnya. Jadi untuk menangani pola kunci berulang, saya menyimpan kode hex dalam variabel global key_valuesetiap kali kode diterima:

key_value = results.value;

Saat Anda menerima pola pengulangan, maka nilai yang disimpan sebelumnya digunakan sebagai penekanan tombol saat ini.

Di akhir void loop() bagian, kami memanggil irrecv.resume() untuk mengatur ulang penerima dan mempersiapkannya untuk menerima kode berikutnya.

CETAK KUNCI KE LCD

Alih-alih mencetak nilai kunci ke monitor serial, Anda juga dapat menampilkan informasi pada LCD. Lihat artikel kami tentang pengaturan dan pemrograman LCD pada Arduino untuk informasi lebih lanjut tentang pemrograman LCD, tetapi pengaturan dasarnya terlihat seperti ini:



Arduino IR Remote – Cetak Kunci ke LCD
Resistor mengatur kecerahan lampu latar LCD. Itu bisa apa saja dari 200 ohm hingga sekitar 2K ohm. Potensiometer mengatur kontras karakter. Saya biasanya menggunakan potensiometer 10K ohm untuk yang satu ini.

Setelah semuanya terhubung, unggah kode ini ke Arduino:

#include <IRremote.h>
#include <LiquidCrystal.h>

const int RECV_PIN = 7;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
IRrecv irrecv(RECV_PIN);
decode_results results;
unsigned long key_value = 0;

void setup(){
  Serial.begin(9600);
  irrecv.enableIRIn(); 
  irrecv.blink13(true);
  lcd.begin(16, 2);
}

void loop(){
  if (irrecv.decode(&results)){
 
        if (results.value == 0XFFFFFFFF)
        results.value = key_value;
        lcd.setCursor(0, 0);
        lcd.clear();
        
        switch(results.value){
          case 0xFFA25D:          
          lcd.print("CH-");
          break;
          case 0xFF629D:
          lcd.print("CH");
          break;
          case 0xFFE21D:
          lcd.print("CH+");
          break;
          case 0xFF22DD:
          lcd.print("|<<");
          break;
          case 0xFF02FD:
          lcd.print(">>|");
          break ;  
          case 0xFFC23D:
          lcd.print(">|");
          break ;               
          case 0xFFE01F:
          lcd.print("-");
          break ;  
          case 0xFFA857:
          lcd.print("+");
          break ;  
          case 0xFF906F:
          lcd.print("EQ");
          break ;  
          case 0xFF6897:
          lcd.print("0");
          break ;  
          case 0xFF9867:
          lcd.print("100+");
          break ;
          case 0xFFB04F:
          lcd.print("200+");
          break ;
          case 0xFF30CF:
          lcd.print("1");
          break ;
          case 0xFF18E7:
          lcd.print("2");
          break ;
          case 0xFF7A85:
          lcd.print("3");
          break ;
          case 0xFF10EF:
          lcd.print("4");
          break ;
          case 0xFF38C7:
          lcd.print("5");
          break ;
          case 0xFF5AA5:
          lcd.print("6");
          break ;
          case 0xFF42BD:
          lcd.print("7");
          break ;
          case 0xFF4AB5:
          lcd.print("8");
          break ;
          case 0xFF52AD:
          lcd.print("9");
          break ;                   
        }
        key_value = results.value;
        irrecv.resume(); 
  }
}

Sekali lagi, jika kode hex tidak cocok dengan kode yang dikeluarkan oleh remote Anda, ganti saja untuk setiap karakter yang tertulis case 0xXXXXXXXX;.

MENGGUNAKAN REMOTE IR UNTUK MENGONTROL BERBAGAI HAL

Sekarang saya akan menunjukkan kepada Anda demonstrasi sederhana tentang bagaimana Anda dapat menggunakan remote IR untuk mengontrol pin output Arduino. Dalam contoh ini, kita akan menyalakan LED ketika tombol tertentu ditekan. Anda dapat dengan mudah memodifikasi kode untuk melakukan hal-hal seperti mengontrol motor servo, atau mengaktifkan relai dengan menekan tombol apa pun dari remote.

Contoh rangkaian memiliki penerima IR yang terhubung ke Arduino, dengan LED merah terhubung ke pin 10 dan LED hijau terhubung ke pin 11:


Arduino IR Remote Receiver – Mengontrol LED dengan IR Remote
Kode di bawah ini akan menulis pin digital 10 HIGH selama 2 detik saat tombol “5” ditekan, dan menulis pin digital 11 HIGH selama 2 detik saat tombol “2” ditekan:

#include <IRremote.h>

const int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
const int redPin = 10;
const int greenPin = 11;


void setup(){
  irrecv.enableIRIn();
  irrecv.blink13(true);
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
}

void loop(){
    if (irrecv.decode(&results)){

        switch(results.value){
          case 0xFF38C7: //Keypad button "5"
          digitalWrite(redPin, HIGH);
          delay(2000);
          digitalWrite(redPin, LOW);
          }

        switch(results.value){
          case 0xFF18E7: //Keypad button "2"
          digitalWrite(greenPin, HIGH);
          delay(2000);
          digitalWrite(greenPin, LOW);
          }

        irrecv.resume(); 
    }
}

Sejauh ini kita telah membahas sifat-sifat radiasi infra merah dan bagaimana komunikasi terjadi antara pemancar dan penerima. Kami melihat bagaimana mengidentifikasi kode kunci IR untuk remote control yang diberikan. Kami belajar bagaimana menampilkan penekanan tombol pada monitor serial dan pada layar LCD.

Akhirnya saya menunjukkan cara mengontrol output Arduino dengan remote. Bersenang-senang bermain dengan ini dan pastikan untuk memberi tahu kami di komentar jika Anda memiliki pertanyaan atau kesulitan mengaturnya!

Terima Kasih banyak atas Kunjungan Anda

Di Publikasikan oleh Electric Dermayon©

Lihat Postingan lainnya

Memprogram Arduino dengan Hp Android

Bagaimana memprogram Platform Arduino dengan Handphone Android ?

Memprogram Platform Arduino dengan Handphone Android

Pemrograman Platform Mikrokontroler Arduino dengan Laptop

Akhir-akhir ini telah banyak dari berbagai kalangan usia suka belajar seputar Technologi modern, seperti belajar Technologi Dasar menggunakan Platform Mikrokontroler Arduino.

Tapi tidak sedikit dari mereka yang belajar dengan Platform mikrokontroler Arduino harus kecewa, karena mereka tidak mempunyai Laptop atau Komputer untuk memprogramnya. Tujuan Pemrograman Platform Arduino memiliki sebuah keuntungan dari pemrogramannya lewat Handphone Android, di satu sisi dari keuntungannya, bahwa orang-orang bisa dengan Mudah memprogram Platform Mikrokontroler Arduino lebih Praktis dengan Handphone dari pada dengan Komputer. Akan tetapi di satu sisi lainnya terdapat juga sebuah kekurangan yakni Orang-Orang tidak mendapatkan fitur-fitur perangkat Lunak yang tidak memuaskan di banding memprogram di Komputer atau Laptop.

Akan tetapi dari masalah tersebut terdapat sebuah solusi untuk dapat memprogram Platform Mikrokontroler Arduino. Sebenarnya Anda bisa melakukan Pemrograman Platform Mikrokontroler Arduino dengan Handphone Android Anda, akan tetapi terdapat beberapa perangkat Keras dan perangkat Lunak yang akan Anda butuhkan nanti untuk melakukan Pemrograman Platform mikrokontroler Arduino.

Pemrograman Arduino dengan Hp Android oleh tim Electric Dermayon©

Perangkat-Perangkat yang akan Anda butuhkan sebagai berikut :

  • Platform Arduino
  • Kabel OTG
  • Aplikasi Arduinodroid
  • Penggunaan Aplikasi
  • Penjelasan Support Kabel OTG

Platform Arduino. Tentu saja yang Pertama Anda perlukan adalah Perangkat Keras dari Platform Arduino. Saya pikir, bahwa mungkin Anda sudah memiliki Platform Arduino-nya. Jadi hal ini tidak perlu di khawatirkan dan perlu Anda teliti, ketika Anda melakukan pemrograman Platform Mikrokontroler Arduino dengan Komputer Anda. Anda pastinya mengunakan Perangkat Keras berupa Kabel USB Type A ke B untuk menghubungkan Platform Arduino dengan Komputer Anda untuk memprogramnya.

Kabel USB Type A ke B

Jadi Anda hanya perlu Perangkat Keras Tambahan untuk bisa memprogram Platform Mikrokontroler Anda dengan Handphone Android. Berikut adalah Perangkat Keras Tambahan yang perlu Anda miliki. Sebenarnya Kabel USB Type A ke B adalah Kabel bawaan dari Platform Arduino.

Kabel OTG Type A ke C

Kabel USB On The Go (OTG) yang Anda perlukan untuk menghubungkan Kabel USB bawaan Platform Mikrokontroler Arduino dengan Kabel USB OTG, caranya Anda hanya tinggal Mencolokkan saja pada dudukan yang pas atau Cocok. Kabel ini bisa Anda temukan di Gerai penjualan Komponen Elektronik (Komputer & Perkakas Komponen) termasuk di Gerai penjualan Handphone.

Aplikasi Arduinodroi

Aplikasi Arduinodroid adalah Perangkat Lunak dari Anton Smirnov. Aplikasi ini bisa Anda Instal atau download lewat Internet, kami menginstalnya di Playstore.

Pengunaan Aplikasi ArduinoDroid. Anda buka Aplikasi ArduinoDroid, yang kemudian Pilih Tanda 3 titik pada Opsi seperti di Gambar yang di dalam Kotak Merah.

Selanjutnya Anda pilih Sketch pada pilihan dari daftar Opsi 3 titik, pemilihan Sketch yaitu untuk membuat Sketsa Program yang nantinya Anda buat atau menyalin dari daftar Pustaka (Library).

Setelah Anda memilih Sketch lalu pilihlah Examples. Examples adalah Sempel yang berisi Proyek-Proyek yang sudah di sediakan oleh ArduinoDroid di dalamnya untuk uji coba Proyek Started (Proyek Pemula).

Setelah Anda memilih Examples lalu muncul pilihan Proyek 1 sampai 11. Sebenarnya Anda bebas memilih Proyek mana yang akan di kerjakan, akan tetapi untuk pengertian yang lebih mudah, Anda kami sarankan untuk memilih Proyek Dasar nomor 1 terlebih dahulu, yang kemudian pilihlah Proyek Blink.

Sama seperti tehnik Pemrograman lainnya yaitu menentukan Ikon Kompiler untuk meng-Kompilasi pada Proyek Program yang sudah di buat oleh Anda. Pada Proyek Blink Anda tidak perlu membuat Programnya, karena sudah tersedia dalam bentuk Program, namun Anda hanya perlu mengikuti Konstruksi atau Skema penyusunan Komponen yang di Instruksikan di Aplikasi ArduinoDroid. Pada Gambar di bawah ini adalah ikon seperti Petir untuk Kompilasinya. Setelah itu Anda tunggu Kompilasinya selesai.

Perhatian (!) Pada saat Kompilasi, anda perlu memperhatikan keberhasilan Pemrograman, ketika Anda membuat Pemrograman yang benar atau sesuai Struktur Bahasa Program, maka pemrograman Anda di nyatakan Berhasil dan terdapat Tulisan Compilation Finised. Namun, ketika terdapat tulisan Compilation Error, yang artinya terdapat Kesalahan Pemrograman Anda.

Setelah Kompilasi Selesai, kemudian Anda Upload Sketsch Program dengan meng-Klik ikon seperti pada Gambar yang berada di dalam Kotak Merah. Ketika peng-Upload’an selesai, maka terdapat pesan pada Outputnya seperti yang sudah di Jelaskan di atas.

Penjelasan Support OTG, sebenarnya untuk bisa memprogram Platform Arduino dengan Handphone Android, tergantung pada Handphone Androinya itu sendiri. Apakah Handphone Android Anda sudah mendukung atau Mensupport OTG ?. Tidak semua dari Handphone Android mendukung perangkat Keras OTG, tapi saya pikir, bahwa hampir semua Handphone Android sekarang sudah mendukung Perangkat Keras OTG ini, hanya saja terdapat pengaturan pada setiap sistemnya, seperti Merk dagang Handphone Android asal negara China yang harus di setting secara manual pada Pengaturan Tambahan yaitu dengan mengaktifkan Koneksi OTG terlebih dahulu untuk bisa mensupport(mendukung) Koneksi OTG.

Handphone Android yang sudah mendukung Koneksi Perangkat Keras OTG seperti Handphone Android asal negara Korea yang tidak perlu melakukan Pengaturan Manual, tapi langsung secara Otomatis bisa ter-Koneksi dengan Perangkat Keras OTG.

Untuk penutupan, mungkin itu saja pada Postingan Memprogram Arduino dengan Handphone Android, jika Anda mempunyai sebuah Pertanyaan tolong jangan Ragu. Anda bisa bertanya dengan mengomentari Postingan ini. Terima Kasih banyak atas kunjungan Anda di Situs Electric Dermayon.

Instruksi Arduino untuk Pemula

Electric Dermayon copyright (c) 2016

Isi Bab

  • 1. Pengantar manual Arduino
  • 2. Perangkat keras dan perangkat lunak
  • 2.1 Perangkat Keras
  • 2.1.1 Deskripsi (pengontrol)
  • 2.1.2 Deskripsi (aksesoris)
  • 2.1.2.1 Papan tempat memotong roti
  • 2.1.2.2 Dioda pemancar cahaya, LED (light emitting diode)
  • 2.2 perangkat lunak
  • 2.2.1 Instalasi
  • 2.2.1.1 Instalasi dan pengaturan perangkat lunak Arduino
  • 2.2.1.2 Instalasi driver USB
  • 2.2.2 Menambahkan perpustakaan ke perangkat lunak Arduino
  • 3. Pemrograman
  • Struktur dasar untuk sketsa
  • Instruksi #1: LED berkedip
  • Instruksi # 2: Flasher bergantian

1. Pengantar manual Arduino

Arduino Uno R3 Original

Panduan ini sebagai dasar untuk belajar tentang platform Arduino. Ini harus memberi pengenalan pengenalan yang sederhana, menarik dan dipandu dengan topik Arduino. Instruksi terutama didasarkan pada tugas-tugas yang berorientasi pada praktik dengan pengenalan teoritis sebelumnya. Anda harus membaca ini terlebih dahulu agar tidak gagal karena hal-hal kecil dalam tugas-tugas Praktis nanti.

Instruksi ini dibuat sebagai bagian dari kegiatan mengajar. Ini dapat digunakan secara gratis untuk mempelajari platform Arduino, tetapi tidak dapat disalin atau digunakan tanpa izin. Instruksi telah dibuat dengan hati-hati dan berkomitmen, tetapi tidak ada jaminan yang diberikan untuk kebenaran dan kelengkapannya.

Untuk tugas-tugas Praktis Anda harus dilengkapi dengan beberapa komponen elektronik. Di situs web ini Anda dapat memesan set Arduino yang sesuai yang dirancang khusus untuk instruksi ini.

Apa sebenarnya “Arduino” itu?

Arduino adalah platform prototyping electronics open source untuk perangkat keras dan perangkat lunak yang fleksibel dan mudah digunakan di bidang mikrokontroler. Sangat cocok untuk mewujudkan proyek spektakuler dalam waktu singkat. Banyak dari mereka dapat ditemukan dengan istilah “Arduino” di YouTube. Hal ini terutama digunakan oleh seniman, desainer, pengotak dan penghobi untuk mewujudkan ide-ide kreatif.

Tetapi platform Arduino juga semakin banyak digunakan di sekolah, perguruan tinggi, dan universitas untuk memberikan siswa yang kreatif dan menarik, tetapi yang terpenting akses mudah ke topik “pengendalian mikro”.

2. Perangkat keras dan perangkat lunak

Istilah Arduino digunakan dalam penggunaan umum untuk berbagai “papan Arduino” (yaitu perangkat keras) serta untuk lingkungan pemrograman (perangkat lunak).

2.1 Perangkat Keras

“Arduino” adalah apa yang disebut papan mikrokontroler (selanjutnya disebut “papan”). Jadi pada dasarnya sebuah papan sirkuit tercetak dengan banyak elektronik di sekitar mikrokontroler sebenarnya. Di tepi papan ada banyak slot (pin disebut) yang dapat dilihat dengan berbagai macam benda. Ini termasuk: LED, sensor ultrasonik, sensor suhu, kontrol putar, tampilan, motor, servo, dll.

Ada berbagai versi papan yang dapat digunakan dengan perangkat lunak Arduino. Ini mencakup banyak  papan “resmi” besar dan kecil yang berbeda  dengan nama resmi “Arduino” serta sejumlah besar  papan “kompatibel” Arduino yang seringkali lebih murah tetapi setara . Papan resmi biasa disebut Arduino UNO, Arduino MEGA, Arduino Mini … dll.  Papan yang kompatibel seperti Arduino China, Freenove Uno, Funduino UNO , Funduino MEGA, Freeduino, Seeduino, Sainsmart UNO dll.

Freenove uno Kompatibel Arduino

2.1.1 Deskripsi (Pengontrol)

2.1.2 Deskripsi (aksesoris)

Selain sensor dan actuator, Anda memerlukan plug-in kabel yang terhubung dengan papan tempat roti (Breadboard) sebagai dasar untuk pengaturan yang cepat dan fleksibel. Ini menghemat pekerjaan penyolderan yang memakan banyak waktu. Selain itu, dioda pemancar cahaya sangat cocok untuk memeriksa keluaran sinyal papan.

2.1.2.1 Papan tempat memotong roti (Breadboard)

Papan tempat memotong roti atau “papan tempat memotong roti” adalah bantuan yang baik untuk membangun sirkuit tanpa menyolder. Beberapa kontak selalu terhubung satu sama lain dalam papan tempat memotong roti. Oleh karena itu, banyak kabel dapat dihubungkan satu sama lain pada titik ini tanpa harus disolder atau disekrup.

Gambar berikut menunjukkan dalam warna kontak mana yang terhubung satu sama lain.

Breadboard

2.1.2.2 Dioda pemancar cahaya, LED (light emitting diode)

LED dapat digunakan untuk menguji hasil proyek dengan sangat cepat. Oleh karena itu, mereka berguna untuk hampir semua proyek Arduino. Anda dapat membaca banyak tentang LED di internet. Berikut adalah informasi yang paling penting.

– Arus hanya dapat mengalir dalam satu arah melalui LED. Oleh karena itu, harus terhubung dengan benar. Sebuah LED memiliki kontak yang lebih panjang dan lebih pendek. Kontak yang lebih panjang adalah + dan yang lebih pendek adalah -.
– Sebuah LED dirancang untuk tegangan tertentu. Jika tegangan ini tidak tercapai, LED menyala kurang terang atau mati. Namun, jika voltase terlampaui, LED akan terbakar dengan sangat cepat dan menjadi sangat panas pada kontaknya (PERHATIAN!).
– Nilai tegangan khas menurut warna LED: biru: 3.1V, putih: 3.3V, hijau: 3.7V, kuning: 2.2V, merah: 2.1V Tegangan pada port digital papan adalah 5V. Saat terhubung langsung ke port ini, setiap LED dengan cepat melepaskan ghosting. Oleh karena itu resistor harus dimasukkan ke dalam rangkaian. Ada bantuan yang sangat bagus di Internet di bawah istilah pencarian “LED kalkulator resistansi”.
– Rekomendasi tidak mengikat untuk resistor pada LED berikut (saat terhubung ke pin 5V papan mikrokontroler:

Lampu LED – Perlawanan

Led Putih – 100 ohm
Led Merah – 200 ohm
Led Kuning – 200 ohm
Led Hijau – 100 ohm
Led Biru – 100 ohm
Inframerah – 100 ohm

2.2 perangkat lunak

Perangkat lunak yang digunakan untuk memprogram mikrokontroler adalah perangkat lunak sumber terbuka dan dapat diunduh secara gratis dari www.arduino.cc . Program kecil kemudian ditulis dalam “perangkat lunak Arduino” ini, yang nantinya akan dijalankan oleh mikrokontroler. Program kecil ini disebut “sketsa”.

Sketsa yang sudah jadi kemudian ditransfer ke mikrokontroler melalui kabel USB.

Lebih lanjut tentang ini nanti di topik “Pemrograman”.

2.2.1 Instalasi

Sekarang perangkat lunak Arduino dan driver USB untuk papan harus diinstal satu demi satu.

2.2.1.1 Instalasi dan pengaturan perangkat lunak Arduino

1. Unduh perangkat lunak dari www.arduino.cc dan instal di PC (papan Arduino BELUM terhubung). Kemudian buka folder software dan jalankan program dengan file arduino.exe.

Ada dua pengaturan penting untuk dipertimbangkan dalam program.

a) Papan kanan harus dipilih yang ingin Anda sambungkan. Papan “Arduino Uno”.




b) “Port serial” yang benar harus dipilih sehingga PC mengetahui port USB mana yang terhubung dengan papan. Namun, ini hanya mungkin jika driver telah diinstal dengan benar. Ini dapat diperiksa sebagai berikut:

Pada saat ini, Arduino belum terhubung ke PC. Sekarang klik “Serial Ports” di submenu perangkat lunak. Satu atau lebih port akan terlihat di sana (COM1 / COM4 / COM7 /…) Jumlah port yang ditampilkan tidak tergantung pada jumlah koneksi USB. Jika nanti board sudah terpasang dan terhubung dengan benar, ANDA AKAN MENEMUKAN SATU PORT LAGI DI SINI!!!!

2.2.1.2 Instalasi driver USB
Proses ideal:

1. Hubungkan papan ke PC.

2. PC mengenali papan dan ingin menginstal driver.

PERHATIAN: Jangan pergi terlalu cepat pada saat ini! Dalam kebanyakan kasus, driver tidak dikenali dan diinstal secara otomatis. Anda harus memilih driver sendiri selama instalasi. Itu terletak di folder program Arduino di subfolder “Driver”.

Kontrol: “Pengelola Perangkat” dapat ditemukan di panel kontrol komputer. Setelah instalasi berhasil, papan Arduino terdaftar di sini. Jika penginstalan tidak berhasil, tidak ada yang istimewa yang dapat ditemukan di sini atau ada perangkat USB yang tidak dikenal dengan tanda seru berwarna kuning. Dalam hal ini: Klik pada perangkat yang tidak dikenal dan klik “Perbarui driver”. Anda sekarang dapat melakukan proses instalasi manual lagi.

2.2.2 Penambahan perpustakaan ke perangkat lunak Arduino

Sebuah perpustakaan (juga disebut Perpustakaan ) berguna untuk beberapa proyek karena dapat diukurkan. Fungsi dari perpustakaan dapat digunakan dalam kode sehingga tidak harus ditulis sepenuhnya dalam kode. Pustaka semacam itu juga akan digunakan dalam instruksi selanjutnya. Ini harus terlebih dahulu ditambahkan dalam perangkat lunak Arduino. Untuk itu ada kemungkinan yang berbeda.

Opsi paling sederhana adalah menggunakan fungsi “Kelola perpustakaan …”. Ini terletak di perangkat lunak di bawah “Sketsa> Sertakan perpustakaan> Kelola perpustakaan …” Di sana, perpustakaan yang diinginkan dapat dicari menggunakan bidang pencarian dan diinstal secara langsung.
Setelah instalasi berhasil, perpustakaan dapat digunakan secara langsung.
Dengan pemasangan pustaka program, contoh sketsa sering ditambahkan ke perangkat lunak Arduino secara bersamaan. Contoh-contoh ini terletak di bawah “File> Contoh” dan dapat memberikan wawasan yang baik tentang fungsi individu dari perpustakaan masing-masing.

Ada juga opsi untuk mengunduh pustaka dari situs eksternal dan mengintegrasikannya menggunakan fungsi “Tambahkan pustaka .ZIP …”. Namun, ini lebih rumit daripada yang dijelaskan sebelumnya.

3. Pemrograman

Tapi sekarang ini benar-benar dimulai. Tanpa banyak teori, kami memperlambat memulai pemrograman. “Belajar dengan melakukan” adalah kata ajaib di sini. Sementara yang disebut “sketsa” dicetak di area kiri, penjelasan kode ada di area kanan. Jika Anda mengerjakan program sesuai dengan sistem ini, Anda akan dapat melihat sendiri kode program dan menerapkannya dalam waktu singkat. Anda kemudian dapat mengaktifkan diri dengan fungsi lainnya nanti. Instruksi ini hanyalah pengantar untuk platform Arduino. Semua kemungkinan fungsi program dan kode program tercantum di situs web ” www.arduino.cc ” di bawah item referensi.

Pertama-tama, informasi singkat tentang kemungkinan pesan kesalahan yang mungkin muncul saat bekerja dengan perangkat lunak Arduino. Yang paling umum adalah berikut:

Tampilan Pemrograman
1) Papan tidak dipasang dengan benar atau papan yang dipilih. 
Saat mengunggah sketsa, pesan ditampilkan di bagian bawah perangkat lunak, yang terlihat seperti yang ditunjukkan di sebelah kanan. 
Kemudian ada catatan “tidak sinkron” di teks kesalahan.


2) Ada kesalahan dalam sketsa. 
Misalnya, sebuah kata salah eja, atau hanya tanda kurung atau titik koma yang hilang. 
Pada contoh di sebelah kiri, tanda kurung kurawal yang memperkenalkan bagian loop tidak ada. 
Pesan kesalahan kemudian sering dimulai dengan “diharapkan …”. 
Artinya program mengharapkan sesuatu yang belum ada.

Struktur dasar untuk sketsa

Sebuah sketsa awalnya dapat dibagi menjadi tiga area.

1. Nama variabel

Di area pertama, elemen program diberi nama (kita pelajari apa artinya ini di program nomor 3). Bagian ini tidak wajib.

2. Setup (sangat diperlukan dalam program)

Papan hanya menjalankan pengaturan sekali. Di sini Anda memberi tahu program, misalnya, pin (slot untuk kabel) mana pada papan mikrokontroler yang merupakan output atau input.

Didefinisikan sebagai output: Sebuah tegangan akan menjadi output di sini di papan tulis. Contoh: Dioda pemancar cahaya akan dinyalakan dengan pin ini.

Didefinisikan sebagai input: Tegangan harus dibaca dari papan di sini. Contoh: Sebuah saklar ditekan. Papan memperhatikan ini dengan mendeteksi tegangan pada pin input ini.

Loop ke-3 (benar-benar diperlukan dalam program)

Papan mengulangi bagian loop terus menerus. Ini memproses sketsa sampai akhir dan kemudian mulai lagi di awal bagian loop.

Instruksi #1: LED berkedip
Tugas: Dioda pemancar cahaya harus berkedip.

Bahan: hanya papan mikrokontroler dengan kabel USB! ( Pengadaan bahan : http://www.Electricdermayon.data.blog )

LED sudah terpasang pada pin 13 pada Arduino (untuk tujuan pengujian). Seringkali lampu ini sudah berkedip saat Anda menghubungkan papan Arduino baru, karena program flashing untuk pengujian papan sudah terpasang terlebih dahulu, tergantung pada pabrikannya. Sekarang kita akan memprogram kedipan ini sendiri.

Sirkuit:

LED di papan dilingkari merah pada gambar.

Anda hanya perlu menghubungkan papan ke komputer dengan kabel USB.

1.2 Program bagian 2: Setup
– kami tidak akan melakukan apa pun di sini untuk saat ini! 1.1 Program bagian 1: Variabel penamaan

Kami hanya memiliki satu keluaran – tegangan harus dikeluarkan pada pin13 (LED akan menyala setelah semua).

Kami menulis di tengah bidang input putih perangkat lunak Arduino:

void setup () { Kode Program perintah di dalam Kurung Kurawal }

Informasi pengaturan sekarang ditempatkan di bagian antara tanda kurung kurawal. Dalam hal ini: “Pin13 harus menjadi output”.

void setup () 
{ 
  pinMode(13, OUTPUT);
}

1.3 Program bagian 3: loop (bagian utama)

Langkah awal Pemrogramman
1(Pertama) bagian program dimulai dengan mengketik void setup () 

Langkah ke-2(Kedua) bagian Program dimulai di dalam Kurung Kurawal { }

Langkah ke-3(Ketiga) bagian akhir dimulai dengan void loop () { }

Langkah ke-4(Keempat) bagian Delay(1000, HIGH); adalah Penundaan Waktu Kedip pada lampu LED, pada HIGH artinya Aktif atau menyala, sedangkan LOW artinya Rendah atau mati.

Sekarang isi dari bagian loop, yaitu program Utama

INI SKETSA LENGKAPNYA

void setup () 
 {
   pinMode(13, OUTPUT);
 }

void loop () 
{
  digitalWrite(13, HIGH);
   delay(1000);
  digitalWrite(13, LOW);
   delay(1000);
}
Kode Programm dalam bentuk nyata.

Jadi. Sketsa sekarang harus tetap seperti yang ditunjukkan pada gambar di sebelah kanan. Sekarang hanya perlu diunggah ke papan. Ini bekerja dengan tombol yang dilingkari merah (kiri atas dalam perangkat lunak).


1.4 Program sekarang dapat bervariasi. Contoh: LED harus berkedip sangat cepat. Untuk melakukan ini, kami mempersingkat waktu tunggu (dari 1000ms menjadi 200ms)

void setup ()

{

pinMode (13, OUTPUT);

}

void loop ()

{

digitalWrite (13, HIGH);

delay (200);

digitalWrite (13, LOW);

delay (200);

}



Sketsa baru sekarang harus diunggah ke papan lagi. Jika semuanya berjalan dengan baik, LED sekarang harus berkedip lebih cepat.

Instruksi #2: Flasher secara bergantian

Tugas: Dua dioda pemancar cahaya harus berkedip secara bergantian.

Konstruksi:

Kode Program :

// Dari sini code dapat disalin slowing ke perangkat lunak Arduino.

// Hitam, berwarna = kode dan abu-abu = penjelasan

void setup ( ) // Kita mulai dengan setup

{

pinMode ( 7 , OUTPUT ) ; // Pin 7 adalah keluaran.

pinMode ( 8 , OUTPUT ) ; // pin 8 adalah output.

}

void loop ( ) // Program utama dimulai.

{

digitalWrite ( 7 , HIGH ) ; // Nyalakan LED pada pin7.

delay ( 1000 ) ; // Tunggu 1000 milidetik.

digitalWrite ( 7 , RENDAH ) ; // Matikan LED pada pin7.

digitalWrite ( 8 , TINGGI ) ; // Nyalakan LED pada pin8.

delay ( 1000 ) ; // Tunggu 1000 milidetik.

digitalWrite ( 8 , LOW ) ; // Matikan LED pada pin8.

}

// Di sini, di akhir, program ke awal bagian loop. Begitu …

// …nyalakan LED pada Pin7.

// ..

Selamat Mencoba dan apabila Anda membutuhkan Proyek-Proyek Arduino Tingkat Lanjut. Anda bisa follow dan menyukai Situs ini untuk bisa mendapatkan Info-info terbaru dari kami. Terima kasih banyak atas Kunjungan Anda.

Rancang situs seperti ini dengan WordPress.com
Mulai