Tutorial Cara Membuat Led Cube 4 X 4 X 4 Dengan Arduino

 

LED Cube Anduino adalah proyek yang menarik untuk dibuat, karena dapat digunakan sebagai hiasan atau digunakan dengan peralatan lain seperti mikrofon atau sensor gerak untuk berbagai aplikasi. Pada dasarnya LED Cube adalah kubus 3 dimensi yang terbuat dari Light Emitting Diodes (LED). Kubus dapat dibuat dengan berbagai cara tetapi untuk proyek ini akan menggunakan cara yaitu dikendalikan oleh mikrokontroler Arduino Uno.

Seperti yang terlihat pada gambar di bawah, kubus terdiri dari sumbu XY dan 4 lapisan yang ditumpuk satu sama lain. Lapisan bawah adalah nomor 0 dan yang atas adalah nomor 3. Demikian pula, LED diberi nomor seperti matriks 3 dimensi. Jadi, LED kiri bawah adalah (1,1) pada layer 0. Yang di atasnya juga (1,1) tetapi pada layer 1. Yang di sebelah kanan LED sudut ini adalah (2,1) pada layer 0 dan seterusnya. Semua lapisan horizontal adalah pin positif dari LED yang disolder bersama.

Semua pin negatif LED diletakkan pada kolom kubus matriks ini. Jadi akan memiliki 4 lapisan dan 16 kolom yang menjadikannya 20 kabel yang terhubung ke Arduino. Pin positif (lapisan) memiliki resistor 100 Ohm untuk membatasi aliran arus hingga 20mA (arus standar untuk LED).

Proses Pembuatan

Mikrokontroler – dalam kasus ini digunakan Arduino Uno, arduino uno memiliki batasan sumber arus pada pinoutnya, yaitu hanya dapat mengirimkan arus dalam jumlah yang aman sebelum terjadi kerusakan. Dalam kasus Arduino Uno, ini memiliki sumber arus 40mA. Jadi kalian pasti bertanya-tanya, tunggu dulu, jika sebuah LED membutuhkan 20mA, kenapa kita bisa menyalakan semua lampu secara bersamaan dan masih tidak membakar board Arduino? Ini karena pada waktu tertentu, hanya satu LED yang menyala.

Mata manusia (karena kegigihan penglihatan) tidak dapat melihat kedipan cepat LED jika dinyalakan dan dimatikan dengan sangat cepat. Karena kode pada Arduino berjalan sangat cepat, mata kita memikirkan beberapa LED seperti menyala. Ini juga membatasi arus ke tingkat yang aman karena pada waktu tertentu hanya satu LED yang menyala dan bahkan jika kita mengambil arus rata-rata dalam 1 detik, itu jauh di bawah ambang batas bahaya. Misalnya Anda ingin menyalakan LED di kiri bawah kubus, Anda akan memberikan sinyal positif dari mikrokontroler ke lapisannya yaitu lapisan 0, ini akan memberi tegangan positif pada pin positif LED. Kemudian Anda harus menginstruksikan mikrokontroler untuk membumikan pin kolom yang relevan dari LED itu, ini akan menghubungkan pin negatif LED ke ground dan Anda memiliki rangkaian bias maju lengkap yang akan menyalakan LED.

Bahan yang perlu disiapkan yaitu :

• Karton atau kayu (tebal sekitar 1 inci)
• baterai 3V
• Amplas (kelas sedang)
• 64 x Dioda Pemancar Cahaya Biru (LED)
• 4 x 100 Ohm Resistor
• 24 x Kabel Pita Berwarna Pria-Pria
• 1 x Female Pin Socket/Header (harus memiliki 20 pin socket inline)
• PCB Perfboard (sekitar 24×10 cm)
• Arduino Uno + Kabel USB
• Adaptor soket daya Arduino Uno
• Adaptor baterai 9V
• Baterai 9V
• Zip-dasi (25 cm)
• Pistol Lem + Tongkat Lem
• Besi Solder + Kawat Solder + Busa Basah
• Pompa Pematrian (jika penyolderan buruk)
• Kaca pembesar (untuk melihat penyolderan Anda)
• Pemotong Kawat Mini
• Tang Hidung Mini
• Kabel koneksi untuk kabel di bawah PCB (sekitar 1m) dan selotip

Tahap pembuatan led cube

Pertama-tama, Anda membutuhkan karton atau kayu yang cukup tebal (kira-kira satu inci sudah cukup). Bor lubang ke dalamnya sehingga membentuk pola kubus 4x4 dengan jarak yang sama antara semua lubang.

Dalam hal ini, pola tercetak ditempatkan di atas karton dan lubang 5mm (setiap lubang berjarak 2,4cm dari lubang berikutnya (tengah-tengah) dibor untuk LED. Pada gambar di bawah, Anda dapat melihat panah yang menunjuk ke arah kaki LED.

Sekarang, Anda harus menguji dan menyiapkan LED Anda. Anda dapat menggunakan baterai dengan daya 3V untuk tujuan ini. Uji semua LED agar Anda terhindar dari masalah nanti kaerna jika ada led yang bermasalah akan susah menggantinya dan cukup memakan waktu ketika setelah dirangkai secara keseluruhan.

Jika Anda ingin cahaya keluar dari semua sisi LED, Anda dapat menggosok keseluruhan kaca LED dengan amplas seperti pada gambar dibawah ini.

Pada gambar di bawah, LED di sebelah kiri menyebar dan yang di sebelah kanan dalam bentuk transparan aslinya. Terlihat perbedaan pada cahaya yang dihasilkan.

Ingat, bahwa kaki LED yang pendek adalah Katodanya (- pin) dan kaki panjangnya adalah Anode (+ pin). Jika Anda tidak yakin, maka Anda dapat mengujinya dengan multimeter atau baterai 3v untuk menemukan polaritasnya. Sekarang, dengan tang tekuk katoda (kaki pendek) pada sudut 90 derajat ke kanan dan tekuk lagi ke atas untuk membuat bentuk seperti yang ditunjukkan pada gambar di bawah.

Tempatkan LED di karton tetapi hati-hati dengan orientasinya. Ingat panah pada gambar di atas? Pin negatif dari LED yang ditekuk harus disejajarkan seperti panah. Ini karena kita akan membuat empat lapisan seperti itu dan mudah untuk menyoldernya. Tekuk semua kaki positif dari semua LED dan lakukan sedemikian rupa sehingga menghubungkan semua terminal positif LED bersama-sama, ini akan membuat lapisan arus positif

Namun, Anda akan melihat bahwa dua area di tengah lapisan ini dibiarkan tidak terhubung seperti yang ditunjukkan oleh lingkaran merah. Anda dapat menghubungkan pin ini dengan kabel tunggal atau kaki dari LED yang dipotong.

Sekarang, dengan menggunakan baterai 3v, buat penguji sederhana untuk memeriksa apakah semua LED berfungsi. Hubungkan kabel positif ke sembarang tempat pada lapisan dan satu per satu periksa semua kolom dengan kabel negatif.

Sekarang telah jadi lapisan pertama, kemudian buat 3 lapisan lagi sehingga menjadi 4 lapisan

Dalam proyek ini, potongan karton sederhana dipotong dan ditempatkan di antara lapisan yang akan disolder. Ini membuatnya mudah untuk menyoldernya tetapi Anda selalu dapat menggunakan alat lain seperti dudukan PCB, dll.

Setelah menyolder tiga lapisan, ada baiknya untuk memeriksa semua LED sekali lagi untuk berjaga-jaga. Seperti sebelumnya, hubungkan pin positif tester sel tombol Anda ke layer dan kemudian pin negatif ke semua kolom LED (- pin) satu per satu

Akhirnya, kubus LED disolder dan seperti inilah tampilannya:

Solder 20 pin (atau lebih) inline female header (celah 0,1 inci antara pin) ke PCB perfboard siap pakai dan letakkan Kubus di atasnya (pin kolom). Anda dapat menekuk beberapa kaki kubus LED di bawah papan untuk sementara agar tidak jatuh tetapi belum menyoldernya. Mereka akan disolder dengan kabel yang berasal dari pin header perempuan nanti.

Solder resistor dengan satu kaki terhubung ke pin header perempuan dan satu lagi untuk dihubungkan ke setiap lapisan terpisah pada kubus. Ingatlah untuk melihat pengaturan koneksi. Dalam proyek ini sisi paling kiri adalah pin nomor 0 pada Arduino hingga pin nomor 13 dan kemudian empat pin Analog untuk lapisan dan kemudian dua pin Analog untuk kolom yang tersisa. Lakukan beberapa pengujian cepat melalui soket header perempuan juga.

Hubungkan semua wirings menggunakan kabel pita jumper (male-male) sesuai dengan tabel koneksi yang ditunjukkan di bawah ini. Arduino dapat ditempel ke papan dengan doubletape sehingga dapat dengan mudah dilepas untuk digunakan dalam proyek lain. Anda dapat menyalakan Arduino dengan baterai 9V dan colokan listrik Arduino (setelah mengupload kode program ke papan arduino)

Setelah mengupload kode ke Arduino Uno, LED Cube 4x4x4 Anda sudah siap dinikmati.

[program]

/*
  4x4x4 LED Cube
  Connection Setup: 
  Columns
  [(x,y)-Pin]
  (1,1)-13
  (1,2)-12
  (1,3)-11
  (1,4)-10
  (2,1)-9
  (2,2)-8
  (2,3)-7
  (2,4)-6
  (3,1)-5
  (3-2)-4
  (3-3)-3
  (3,4)-2
  (4,1)-1
  (4,2)-0
  (4,3)-A5
  (4,4)-A4
  Layers
  [layer-Pin]
  a-A0
  b-A1
  c-A2
  d-A3
*/
//initializing and declaring led rows
  int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
//initializing and declaring led layers
  int layer[4]={A3,A2,A1,A0};

  int time = 250;
 
void setup()
{
  //setting rows to ouput
  for(int i = 0; i<16; i++)
  {
    pinMode(column[i], OUTPUT);
  }
  //setting layers to output
  for(int i = 0; i<4; i++)
  {
    pinMode(layer[i], OUTPUT);
  }
  //seeding random for random pattern
  randomSeed(analogRead(10));
}
//xxxxxxxxxxxxxxxxxxxxFUNCTION LOOPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void loop()
{
  turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  delay(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  delay(time);
  aroundEdgeDown();
  turnEverythingOff();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  delay(2000);
}


//xxxxxxxxxxxxxxxxxxxxFUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

///////////////////////////////////////////////////////////turn all off
void turnEverythingOff()
 {
   for(int i = 0; i<16; i++)
   {
     digitalWrite(column[i], 1);
   }
   for(int i = 0; i<4; i++)
   {
     digitalWrite(layer[i], 0);
   }
 }
 
////////////////////////////////////////////////////////////turn all on
void turnEverythingOn()
{
  for(int i = 0; i<16; i++)
  {
    digitalWrite(column[i], 0);
  }
  //turning on layers
  for(int i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 1);
  }
}
///////////////////////////////////////////////////////turn columns off
void turnColumnsOff()
{
  for(int i = 0; i<16; i++)
  {
    digitalWrite(column[i], 1);
  }
}
/////////////////////////////////////////////////////////////flicker on
void flickerOn()
{
  int i = 150;
  while(i != 0)
  {
    turnEverythingOn();
    delay(i);
    turnEverythingOff();
    delay(i);
    i-= 5;
  }
}
//////////////turn everything on and off by layer up and down NOT TIMED
void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
  int x = 75;
  for(int i = 5; i != 0; i--)
  {
    turnEverythingOn();
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 0);
      delay(x);
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 1);
      delay(x);
    }
      for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 0);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 1);
      delay(x);
    }
  }
}
//////////////////////////turn everything on and off by column sideways
void turnOnAndOffAllByColumnSideways()
{
  int x = 75;
  turnEverythingOff();
  //turn on layers
  for(int i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 1);
  }
  for(int y = 0; y<3; y++)
  {
    //turn on 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn on 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn off 12-15
    for(int i = 12; i<16; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 8-11
    for(int i = 8; i<12; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 4-7
    for(int i = 4; i<8; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
  }
}
/////////////////////////////////////////up and down single layer stomp
void layerstompUpAndDown()
{
  int x = 75;
  for(int i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 0);
  }
  for(int y = 0; y<5; y++)
  {
    for(int count = 0; count<1; count++)
    { 
      for(int i = 0; i<4; i++)
      {
        digitalWrite(layer[i], 1);
        delay(x);
        digitalWrite(layer[i], 0);
      }
      for(int i = 4; i !=0; i--)
      {
        digitalWrite(layer[i-1], 1);
        delay(x);
        digitalWrite(layer[i-1], 0);
      }
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 1);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 0);
      delay(x);
    }
  }
}
////////////////////////////////////////////////////////////flicker off
void flickerOff()
{
  turnEverythingOn();
  for(int i = 0; i!= 150; i+=5)
  {
    turnEverythingOff();
    delay(i+50);
    turnEverythingOn();
    delay(i);
  }
}
///////////////////////////////////////////around edge of the cube down
void aroundEdgeDown()
{
  for(int x = 200; x != 0; x -=50)
  {
    turnEverythingOff();
    for(int i = 4; i != 0; i--)
    {
      digitalWrite(layer[i-1], 1);
      digitalWrite(column[5], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[10], 0);
      
      digitalWrite(column[0], 0);
      delay(x);
      digitalWrite(column[0], 1);
      digitalWrite(column[4], 0);
      delay(x);
      digitalWrite(column[4], 1);
      digitalWrite(column[8], 0);
      delay(x);
      digitalWrite(column[8], 1);
      digitalWrite(column[12], 0);
      delay(x);
      digitalWrite(column[12], 1);
      digitalWrite(column[13], 0);
      delay(x);
      digitalWrite(column[13], 1);
      digitalWrite(column[15], 0);
      delay(x);
      digitalWrite(column[15], 1);
      digitalWrite(column[14], 0);
      delay(x);
      digitalWrite(column[14], 1);
      digitalWrite(column[11], 0);
      delay(x);
      digitalWrite(column[11], 1);
      digitalWrite(column[7], 0);
      delay(x);
      digitalWrite(column[7], 1);
      digitalWrite(column[3], 0);
      delay(x);
      digitalWrite(column[3], 1);
      digitalWrite(column[2], 0);
      delay(x);
      digitalWrite(column[2], 1);
      digitalWrite(column[1], 0);
      delay(x);
      digitalWrite(column[1], 1);
    }
  }
}
/////////////////////////////////////////////////////////random flicker
void randomflicker()
{
  turnEverythingOff();
  int x = 10;
  for(int i = 0; i !=750; i+=2)
  {
  int randomLayer = random(0,4);
  int randomColumn = random(0,16);
  
  digitalWrite(layer[randomLayer], 1);
  digitalWrite(column[randomColumn], 0);
  delay(x);
  digitalWrite(layer[randomLayer], 0);
  digitalWrite(column[randomColumn], 1);
  delay(x); 
  }
}
////////////////////////////////////////////////////////////random rain
void randomRain()
{
  turnEverythingOff();
  int x = 100;
  for(int i = 0; i!=60; i+=2)
  {
    int randomColumn = random(0,16);
    digitalWrite(column[randomColumn], 0);
    digitalWrite(layer[0], 1);
    delay(x+50);
    digitalWrite(layer[0], 0);
    digitalWrite(layer[1], 1);
    delay(x);
    digitalWrite(layer[1], 0);
    digitalWrite(layer[2], 1);
    delay(x);
    digitalWrite(layer[2], 0);
    digitalWrite(layer[3], 1);
    delay(x+50);
    digitalWrite(layer[3], 0);
    digitalWrite(column[randomColumn], 1);
  }
}
/////////////////////////////////////////////////////diagonal rectangle
void diagonalRectangle()
{
  int x = 350;
  turnEverythingOff();
  for(int count = 0; count<5; count++)
  {
    //top left
    for(int i = 0; i<8; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[3], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //middle middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //bottom right
    for(int i = 8; i<16; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //bottom middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //bottom left
    for(int i = 0; i<8; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //middle middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //top right
    for(int i = 8; i<16; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(x);
    turnEverythingOff();
    //top middle
    for(int i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(x);
    turnEverythingOff();
  }
  //top left
  for(int i = 0; i<8; i++)
  {
    digitalWrite(column[i], 0);
  }
  digitalWrite(layer[3], 1);
  digitalWrite(layer[2], 1);
  delay(x);
  turnEverythingOff();
}
//////////////////////////////////////////////////////////////propeller
void propeller()
{
  turnEverythingOff();
  int x = 90;
  for(int y = 4; y>0; y--)
  {
    for(int i = 0; i<6; i++)
    {
      //turn on layer
      digitalWrite(layer[y-1], 1);
      //a1
      turnColumnsOff();
      digitalWrite(column[0], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[15], 0);
      delay(x);
      //b1
      turnColumnsOff();
      digitalWrite(column[4], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[11], 0);
      delay(x);
      //c1
      turnColumnsOff();
      digitalWrite(column[6], 0);
      digitalWrite(column[7], 0);
      digitalWrite(column[8], 0);
      digitalWrite(column[9], 0);
      delay(x);
      //d1
      turnColumnsOff();
      digitalWrite(column[3], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[12], 0);
      delay(x);
      //d2
      turnColumnsOff();
      digitalWrite(column[2], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[13], 0);
      delay(x);
      //d3
      turnColumnsOff();
      digitalWrite(column[1], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[14], 0);
      delay(x);
    }
  }
  //d4
  turnColumnsOff();
  digitalWrite(column[0], 0);
  digitalWrite(column[5], 0);
  digitalWrite(column[10], 0);
  digitalWrite(column[15], 0);
  delay(x);
}
//////////////////////////////////////////////////////spiral in and out
void spiralInAndOut()
{
  turnEverythingOn();
  int x = 60;
  for(int i = 0; i<6; i++)
  {
    //spiral in clockwise
    digitalWrite(column[0], 1);
    delay(x);
    digitalWrite(column[1], 1);
    delay(x);
    digitalWrite(column[2], 1);
    delay(x);
    digitalWrite(column[3], 1);
    delay(x);
    digitalWrite(column[7], 1);
    delay(x);
    digitalWrite(column[11], 1);
    delay(x);
    digitalWrite(column[15], 1);
    delay(x);
    digitalWrite(column[14], 1);
    delay(x);
    digitalWrite(column[13], 1);
    delay(x);
    digitalWrite(column[12], 1);
    delay(x);
    digitalWrite(column[8], 1);
    delay(x);
    digitalWrite(column[4], 1);
    delay(x);
    digitalWrite(column[5], 1);
    delay(x);
    digitalWrite(column[6], 1);
    delay(x);
    digitalWrite(column[10], 1);
    delay(x);
    digitalWrite(column[9], 1);
    delay(x);
    ///////////////////////////////////////spiral out counter clockwise
    digitalWrite(column[9], 0);
    delay(x);
    digitalWrite(column[10], 0);
    delay(x);
    digitalWrite(column[6], 0);
    delay(x);
    digitalWrite(column[5], 0);
    delay(x);
    digitalWrite(column[4], 0);
    delay(x);
    digitalWrite(column[8], 0);
    delay(x);
    digitalWrite(column[12], 0);
    delay(x);
    digitalWrite(column[13], 0);
    delay(x);
    digitalWrite(column[14], 0);
    delay(x);
    digitalWrite(column[15], 0);
    delay(x);
    digitalWrite(column[11], 0);
    delay(x);
    digitalWrite(column[7], 0);
    delay(x);
    digitalWrite(column[3], 0);
    delay(x);
    digitalWrite(column[2], 0);
    delay(x);
    digitalWrite(column[1], 0);
    delay(x);
    digitalWrite(column[0], 0);
    delay(x);
    ///////////////////////////////////////spiral in counter clock wise
    digitalWrite(column[0], 1);
    delay(x);
    digitalWrite(column[4], 1);
    delay(x);
    digitalWrite(column[8], 1);
    delay(x);
    digitalWrite(column[12], 1);
    delay(x);
    digitalWrite(column[13], 1);
    delay(x);
    digitalWrite(column[14], 1);
    delay(x);
    digitalWrite(column[15], 1);
    delay(x);
    digitalWrite(column[11], 1);
    delay(x);
    digitalWrite(column[7], 1);
    delay(x);
    digitalWrite(column[3], 1);
    delay(x);
    digitalWrite(column[2], 1);
    delay(x);
    digitalWrite(column[1], 1);
    delay(x);
    digitalWrite(column[5], 1);
    delay(x);
    digitalWrite(column[9], 1);
    delay(x);
    digitalWrite(column[10], 1);
    delay(x);
    digitalWrite(column[6], 1);
    delay(x);
    //////////////////////////////////////////////spiral out clock wise
    digitalWrite(column[6], 0);
    delay(x);
    digitalWrite(column[10], 0);
    delay(x);
    digitalWrite(column[9], 0);
    delay(x);
    digitalWrite(column[5], 0);
    delay(x);
    digitalWrite(column[1], 0);
    delay(x);
    digitalWrite(column[2], 0);
    delay(x);
    digitalWrite(column[3], 0);
    delay(x);
    digitalWrite(column[7], 0);
    delay(x);
    digitalWrite(column[11], 0);
    delay(x);
    digitalWrite(column[15], 0);
    delay(x);
    digitalWrite(column[14], 0);
    delay(x);
    digitalWrite(column[13], 0);
    delay(x);
    digitalWrite(column[12], 0);
    delay(x);
    digitalWrite(column[8], 0);
    delay(x);
    digitalWrite(column[4], 0);
    delay(x);
    digitalWrite(column[0], 0);
    delay(x);
  }
}
//////////////////////////////////////go through all leds one at a time
void goThroughAllLedsOneAtATime()
{
  int x = 15;
  turnEverythingOff();
  for(int y = 0; y<5; y++)
  {
    //0-3
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(layer[count-1], 1);
      for(int i = 0; i<4; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count-1], 0);
    }
    //4-7
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(layer[count], 1);
      for(int i = 4; i<8; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count], 0);
    }
    //8-11
    for(int count = 4; count != 0; count--)
    {
      digitalWrite(layer[count-1], 1);
      for(int i = 8; i<12; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count-1], 0);
    }
    //12-15
    for(int count = 0; count < 4; count++)
    {
      digitalWrite(layer[count], 1);
      for(int i = 12; i<16; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
    digitalWrite(layer[count], 0);
    }
  }
}

Cara Membuat Countdown Dengan Arduino

 

Jika mengembangkan komponen elektronik, perangkat keras atau perangkat telah menjadi salah satu impian Anda, maka Anda berada di tempat yang tepat. Dalam posting ini, Anda akan diperkenalkan dengan proyek Arduino sederhana menggunakan papan Arduino Uno.

Proyek pemula ini difokuskan untuk membangun penghitung waktu mundur menggunakan Arduino Uno dan beberapa komponen yang akan diperkenalkan kepada Anda. Pengembangan penghitung waktu mundur adalah cara yang bagus untuk memulai dan langkah selanjutnya akan menunjukkan alasannya.

Bahan yang dibutuhkan

• Arduino Uno :  adalah papan mikrokontroler dengan ATmega 3284.
• Potensiometer : adalah resistor tiga pin kaki yang berfungsi sebagai pembagi tegangan yang dapat disesuaikan. Potensiometer akan digunakan untuk menyetel kontras LCD. Anda mungkin perlu sedikit mengutak-atiknya untuk melihatnya menampilkan sesuatu di layar.
• Layar LCD i2c : adalah Tampilan lampu latar yang menunjukkan angka pada hitungan mundur. LCD memiliki tampilan karakter 16 X 2 yang berarti dapat menampilkan hingga enam belas karakter pada masing-masing dari dua barisnya
• Project Board :  adalah papan yang digunakan untuk menghubungkan tiap komponen pada proyek
• Kabel jumper

Tahapan Membuat

Tata letak project board lengkap dengan sususan komponen beserta penyambungan kabel dapat pada gambar dibawah ini. Diagram skematik juga membantu Anda membaca koneksi untuk proyek tersebut. Diagram ini telah disediakan untuk membantu Anda memahami komponen mana yang pergi ke mana dan untuk tujuan verifikasi.

LCD pada dasarnya adalah LCD port paralel yang menampilkan tampilan karakter 16 X 2 yang berarti kita dapat menampilkan hingga 16 karakter pada masing-masing dari dua baris.

Dalam proyek ini, potensiometer berfungsi untuk menyetel kontras LCD. Potensio meter terletak pada bagian belakang LCD yaitu menempel pada komponen i2c.  Anda mungkin perlu mensettingnya sedikit untuk melihat teks yang muncul di layar. 

[program]

  #include  
 
int S = 59; // count seconds 
int M = 59; // count minutes
int H = 23; // count hours
//initialize the library with the numbers of the interface pins
LiquidCrystal lcd(4,6,10,11,12,13); // pins connected to LCD
 
void setup()
{
 lcd.begin(16,2);//set up the LCD's number of columns and rows
}
void loop()
{
 lcd.setCursor(1,0); 
 lcd.print ("belajarit.net");
 lcd.setCursor(6,1);
 lcd.print(":");
 lcd.setCursor(9,1);
 lcd.print(":");
 
 S--;
 delay(1000);
  
 if(S<0 h--="" h="23;" if="" m--="" m="59;" s="59;">9)
 {
   lcd.setCursor(7,1);
   lcd.print(M);
 }
 else
 {
   lcd.setCursor(7,1);
   lcd.print("0"); 
   lcd.setCursor(8,1);
   lcd.print(M);
   lcd.setCursor(9,1);
   lcd.print(":");
 }
  
 if(S>9)
 {
   lcd.setCursor(10,1);
   lcd.print(S);
 }
 else
 {
   lcd.setCursor(10,1);
   lcd.print("0"); 
   lcd.setCursor(11,1);
   lcd.print(S);
   lcd.setCursor(12,1);
   lcd.print(" ");
 }
  
 if(H>9)
 {
   lcd.setCursor(4,1);
   lcd.print (H);
 }
 else
 {
   lcd.setCursor(4,1);
   lcd.print("0"); 
   lcd.setCursor(5,1);
   lcd.print(H);
   lcd.setCursor(6,1);
   lcd.print(":");
 }
}
  

penjelasan Program

 lcd.setCursor(1,0); 
 lcd.print ("belajarit.net");
  

pada baris yang bertuliskan (1,0) merupakan posisi teks Belajarit.net pada baris 1 yang akan tampil pada layar LCD

 lcd.setCursor(6,1);
 lcd.print(":");

(6,1) merupakan memulai penulisan awal teks pada kolom ke 6 dan baris ke 1

 lcd.setCursor(9,1);
 lcd.print(":");

(9,1) merupakan memulai penulisan awal teks pada kolom ke 6 dan baris ke 1

Baris lain dalam kode bekerja dengan prinsip yang sama tetapi dalam kasus ini, kata-kata menjadi angka hitung mundur. Enam sel akan menunjukkan jam, menit, dan detik saat penghitung waktu mundur. Pengatur waktu berubah di bawah kondisi yang ditentukan yang ditentukan oleh beberapa kondisi 'jika' yang dapat Anda lihat pada kode yang diuraikan di atas. Penundaan 1000 ms di setiap iterasi telah diberikan. Ini karena waktu eksekusi 'nol-detik' untuk setiap baris lain dalam loop.

Penghitung waktu mundur yang dibangun di sini mulai dari 23 jam, 59 menit, dan 59 detik. Ini dimulai dari titik ini dan menghitung mundur ke nol dan mulai lagi. Titik awal penghitung waktu mundur juga dapat diubah dengan memasukkan nilai yang Anda inginkan seperti H, M, dan S dalam kode sketsa. Ini memungkinkan Anda menghitung mundur dari mana pun yang Anda pilih.

Sekian pada artikel kali ini semoga bermanfaat sampai berjumpa pada artikel selanjutnya..

Cara Menggunakan Multimeter Untuk Mengukur Tegangan

Setelah Kalian mulai merancang proyek Kalian sendiri, sirkuit menjadi lebih rumit dan Kalian mungkin akan menemukan bahwa Kalian telah membuat kesalahan kecil dan hal-hal tidak selalu bekerja seperti yang Kalian harapkan, di sinilah Kalian perlu belajar bagaimana gunakan multimeter untuk membantu memecahkan masalah proyek Kalian.

Mungkin kode Kalian atau mungkin sirkuit Kalian. Mengapa LED itu menyala redup ketika yang itu menyala penuh atau mengapa LED itu tidak pernah menyala? Jika ini adalah masalah sirkuit, Kalian mungkin memerlukan multimeter untuk membantu melacak kesalahan. Tutorial ini ditujukan untuk pemula di bidang elektronik dan akan menunjukkan cara membaca tegangan, arus, hambatan, dan memeriksa kontinuitas.

Donald Macadie, seorang insinyur Kantor Pos Inggris, memelihara peralatan telekomunikasi di awal tahun 1920-an, telah dikaitkan dengan penemuan instrumen tunggal yang dapat mengukur amp, volt, dan ohm. Kemudian dikembangkan dan dijual sebagai AVOmeter – Amps-Volts-Ohm. Itu berisi meteran kumparan bergerak, resistor presisi dengan berbagai soket dan sakelar untuk memilih mode dan jangkauan yang sesuai. Sebuah cermin di belakang jarum disertakan untuk membantu pembacaan yang akurat dari jarum.

Alat yang berguna ini memiliki beberapa nama lain: multitester, atau VOM (volt-ohm-milliammeter). Mereka mungkin analog (dengan jarum bergerak dan beberapa timbangan) atau digital dengan layar LCD numerik. Biaya yang lebih rendah dan presisi yang lebih besar dari meteran digital telah membuat versi analog menjadi usang.

Multimeter Analog

Ini adalah foto multimeter asli saya, dibeli pada tahun 1977. Masih berfungsi dengan baik.

Terlihat cukup rumit dengan 4 skala dan 6 set nilai yang diterapkan pada timbangan. Saklar dial digunakan untuk memilih tegangan DC (4 rentang), arus DC (2 rentang), Ohm dan tegangan AC (4 rentang). Perhatikan skala resistansi logaritmik terbalik di atas, sementara yang lain linier, meningkat dari kiri ke kanan.

Beruntung bagi kami, meter digital baru jauh lebih mudah dipahami dan dibaca. Sebagian besar secara otomatis memilih rentang yang benar untuk banyak pembacaan.

Harga bervariasi dari sekitar Rp.140.000 hingga ribuan untuk model laboratorium presisi tinggi dan dikalibrasi secara akurat. Untuk tujuan kami, multimeter dengan harga sekitar Rp 350.000 akan melakukan pekerjaan dengan sempurna.

Menggunakan Multimeter Digital

Untuk artikel ini, saya akan menggunakan AstroAI Digital Multimeter DT132A, yang saya temukan di Amazon dengan harga sekitar £21. Itu dapat melakukan semua hal penting: membaca tegangan, arus, hambatan, dan memeriksa kontinuitas.

Dengan multimeter, Kalian menerima dua probe yang diisolasi dengan sangat baik berwarna merah dan hitam. Ini dicolokkan ke meteran dengan kabel hitam di COM (umum) dan probe merah di INPUT. Keduanya hanya kabel dengan perlindungan/isolasi pengguna dan akan berfungsi dengan baik dicolokkan ke soket yang berlawanan. Probe HITAM biasanya terhubung ke GND dan MERAH digunakan untuk membaca tegangan yang lebih tinggi.

Ujung probe ini dapat diekspos lebih lanjut dengan melepas tutup isolasinya. Ini tidak disarankan saat bekerja dengan tegangan tinggi (berbahaya) atau komponen yang dikemas rapat dengan ketinggian berbeda, untuk mengurangi kemungkinan korsleting. Kalian mungkin harus memindahkan probe MERAH ke port yang berbeda saat melakukan pembacaan tertentu. (Dengan meteran ini untuk mengukur arus > 200mA, port A harus digunakan. Selalu baca manualnya)

Kami akan menggunakan meteran dengan tegangan sangat rendah, biasanya 5V atau 3,3V, dan dengan arus yang sangat kecil, biasanya miliampere. Resistansi bisa berupa apa saja dari 0 hingga Mega Ohm.

Tampilan dimulai dengan tampilan yang sangat singkat dari semua simbol yang tersedia. Merek dan model multimeter lainnya menggunakan simbol yang sama.

Tombol ketiga dari kiri dapat digunakan untuk menghidupkan/mematikan lampu latar layar.

Tampilan pada layar multimeter

Mulai dari kiri bawah kita memiliki:

• indikator baterai untuk baterai internal, digunakan untuk menyalakan instrumen, mengukur hambatan, dan menggerakkan layar LCD.
• AC dan garis bergelombang menunjukkan Arus Bolak-balik (dari stopkontak listrik utama – Berbahaya).
• Tanda minus untuk nilai negatif.
• DC dengan garis lurus dan putus-putus menunjukkan Arus Langsung (dari baterai).
• APO – Auto Power OFF – menghemat baterai internal – sekitar 15 menit.
• AUTO – rentang otomatis – penskalaan unit – volt atau milivolt, dll – sangat berguna
• MAX dan MIN – nilai maksimum atau minimum dari waktu ke waktu
• H – tahan nilai saat ini di layar
• Tes Dioda
• Uji Kontinuitas – dengan bunyi bip
• Tes Relatif
• Indikator baterai lemah – ganti baterai.

Ukuran satuan

Di sepanjang bagian bawah kami memiliki unit yang diukur - kiri ke kanan

• Suhu dalam C dan F, kilo, Mega, Ohm, Hz, % dan mikro, mili, Amps, Volt, nano dan Farad.
• Model ini juga menyertakan termokopel tipe K untuk mengukur suhu. Tanpa probe atau termokopel dipasang, ini akan menampilkan suhu sekitar dalam °C atau °F.

Perbedaan Antara DC dan AC

DC berasal dari baterai, port USB, atau catu daya yang diperbaiki (arus searah – selalu mengalir dalam arah yang sama dari positif ke negatif). AC berasal dari dinamo atau power point dinding (arus bolak-balik yang berubah arah 50 atau 60 kali per detik). Ini bisa sangat berbahaya karena tegangannya sangat tinggi dan dapat memberikan arus yang tinggi.

Mengukur Tegangan Baterai

Kami memutar sakelar pemilih satu klik searah jarum jam dari OFF ke tegangan DC (V dengan garis lurus). Probe MERAH ditekan ke ujung positif baterai dan probe HITAM ke ujung negatif. Tegangan ditampilkan, secara otomatis diskalakan untuk menunjukkan baterai ini hanya memasok 1.199 volt dan harus diganti.

Untuk membaca tegangan kita menempatkan meteran secara paralel dengan objek yang kita ukur perbedaan tegangan.

Jika kita mencoba baterai yang berbeda, tetapi meletakkan probe di ujung yang salah, kita mendapatkan pembacaan negatif tetapi nilai absolutnya benar.

Mencoba dengan baterai 9V lama

Saya memilih terminal yang salah lagi tetapi nilai yang tidak ditkaliantangani sudah benar.

Perhatikan AUTO di sudut kiri atas yang menunjukkan bahwa rentang otomatis AKTIF. Layar menunjukkan milivolt saat start-up tetapi dengan cepat mengubah jangkauan secara otomatis.

Dengan rentang otomatis, mungkin perlu waktu singkat agar tampilan selesai. Ini sepadan dengan penundaan singkat dan lebih cepat dan lebih mudah daripada harus secara manual memilih rentang yang berbeda. APO menunjukkan menunjukkan bahwa itu akan Auto Power OFF, untuk menghemat baterai internal meteran jika saya lupa mematikannya. Ini memakan waktu sekitar 15 menit jadi praktik yang baik untuk mengubah sakelar pemilih kembali ke OFF segera setelah Kalian membaca.

Membaca tegangan AC

Putar selektor putar sekali klik searah jarum jam untuk memilih Arus Bolak-balik (V dengan garis bergelombang). Ini juga auto-ranging tetapi dimulai dengan Volts.

Jika Kalian benar-benar perlu memeriksa tegangan AC di stopkontak (ini berbahaya jadi saya tidak merekomendasikannya) cukup putar sakelar pemilih ke posisi kedua (HzV~) dan gunakan probe dengan sangat hati-hati pada soket aktif dan netral. Jauhkan jari Kalian dari ujung logam probe

Mengukur Resistansi

Matikan dan putuskan sirkuit sebelum memeriksa

Di masa lalu saya telah menemukan sepasang kabel croc-clip terisolasi sangat berguna, terutama ketika membaca nilai resistor. Jika Kalian buta warna, atau tidak percaya diri untuk mengingat kode warna, sangat mudah untuk menemukan nilai resistor dengan meteran Kalian. Putar sakelar pemilih ke posisi – Omega – Ohm. Nilai akan muncul di layar. Yang ini ditunjukkan sebagai 0,665 K Ohm = 665 Ohm. Warnanya biru, abu-abu, coklat – 680 Ohm – dalam toleransi yang dinyatakan.

Jika Kalian tidak memiliki kabel croc-clip, cukup gunakan jari dan ibu jari untuk menjepit probe ke setiap ujung kabel resistor. Jika Kalian mengukur resistor yang sudah ada dalam rangkaian, Kalian harus mematikan daya sebelum mengukur.

Memeriksa Kontinuitas

Matikan dan putuskan sirkuit sebelum memeriksa

Hal ini berkaitan dengan resistensi. Kontinuitas yang baik memiliki resistansi yang sangat rendah hingga nol – arus mengalir tanpa hambatan. Jika Kalian memutar pemilih ke posisi resistensi (4 klik dari mati) tampilan akan menunjukkan 0.L M (Overload), menunjukkan resistensi besar atau tidak ada koneksi.

Jika Kalian kemudian menyentuh ujung probe bersama-sama, tampilan akan berubah menjadi nol atau 0,1 Ohm yang menunjukkan tidak ada hambatan atau kontinuitas yang sangat baik – koneksi yang baik. Untuk menghindari Kalian harus terus melihat layar saat Kalian memeriksa papan sirkuit, memeriksa apakah pin tertentu terhubung dengan benar, Kalian bisa membuat meteran berbunyi bip jika ada kontinuitas yang baik. Pilih resistansi dengan sakelar putar dan tekan tombol pilih hingga simbol kontinuitas muncul di layar dan meteran berbunyi bip.

Periksa dengan menyentuh ujung probe bersama-sama untuk mendapatkan bunyi bip. Pegang probe pada ujung yang berlawanan dari panjang kawat yang dicurigai. Jika Kalian mendapatkan bunyi bip, kontinuitasnya bagus. Jika meteran tetap diam, kabel putus di beberapa titik. (Pengukur ini akan berbunyi bip jika resistansinya kurang dari sekitar 30 Ohm. Jika Kalian ingin indikasi yang benar-benar bagus, baca resistansi daripada mendengarkan bunyi bip. Saya memiliki meteran lain yang memiliki ambang bunyi bip 120 Ohm. Periksa manual Kalian untuk temukan nilai ambang untuk instrumen Kalian.)

Fasilitas ini sangat berguna jika Kalian baru saja menyolder satu set pin ke papan mikrokontroler baru seperti ESP 32 atau papan Arduino kecil. Kalian perlu memeriksa bahwa tidak ada kontinuitas antara pin yang berdekatan karena terlalu banyak solder yang mengalir dan Kalian telah menjembataninya. Di sini Kalian mengatur meteran untuk kontinuitas dan menekan probe di bagian atas setiap pasangan pin yang berdekatan secara bergantian. Jika Kalian telah melakukan pekerjaan dengan baik, Kalian seharusnya tidak mendapatkan bunyi bip.

Dengan cara yang sama Kalian dapat memeriksa koneksi yang baik yang diperlukan antara pin pada mikrokontroler Kalian dan kaki komponen pada papan sirkuit. (Mungkin ada sambungan kering atau potongan jalur tembaga yang salah posisi di papan Kalian yang mengganggu sambungan.)

Strip tembaga yang berdekatan pada sirkuit stripboard biasanya tidak boleh dihubungkan. Kalian dapat menggunakan kontinuitas untuk memeriksa gumpalan solder yang menjembatani strip yang berdekatan atau kerusakan yang dibuat dengan buruk pada strip, memungkinkan arus mengalir di tempat yang salah.

Membaca Arus

Untuk membaca arus tegangan Kalian harus dimasukkan ke dalam rangkaian secara seri bukan paralel. Meteran Kalian menjadi bagian dari sirkuit, menggantikan kabel koneksi. Pada sirkuit papan tempat memotong roti, ini cukup mudah dilakukan dengan mengganti kabel jumper tunggal dengan dua dan memasukkan meteran ke dalam sambungan. Pada papan strip atau papan sirkuit tercetak, Kalian harus memotong jalur dan memasukkan pin titik uji untuk meteran, yang nantinya dapat digabungkan dengan sambungan jumper setelah meteran dilepas.

Saat menghubungkan meteran, Kalian harus mempertimbangkan arah aliran arus. Probe MERAH biasanya akan terhubung ke potensial yang lebih tinggi. Misalnya, untuk membaca arus total yang mengalir melalui suatu rangkaian, putuskan kabel balik GND, dan hubungkan probe HITAM lebih dekat ke pin GND pada Arduino dan probe MERAH ke papan sirkuit. Jika Kalian mendapatkan polaritas yang salah Kalian akan mendapatkan pembacaan negatif.

Meter saya memiliki tiga posisi pilihan pada dial untuk membaca arus, A, mA dan A. Jika Kalian mengharapkan arus lebih besar dari 200 mA, probe MERAH harus dipindahkan dari soket INPUT normal ke soket A, yang memiliki sekering berperingkat lebih tinggi, dan gunakan pilihan A pada putaran. Kami akan mengharapkan kurang dari 200 mA, jadi kami dapat membiarkannya di soket INPUT dan memilih mA. Periksa apakah default ke DC.

15+ Simulator Untuk Belajar Arduino

Keuntungan dari mensimulasikan proyek sebelum diterapkan pada keadaan sebenarnya sangat penting bagi banyak industri. Selama bertahun-tahun, beberapa keuntungan besar dari simulasi telah menjadi bidang aeronautika dan penerbangan. Saat ini, simulator Arduino sekarang memungkinkan siapa saja—pemula dan desainer sirkuit profesional—untuk belajar, memprogram, dan menguji ide tanpa rasa takut kehilangan modal dan energi yang terbuang.

Simulator Arduino adalah platform yang bagus untuk programmer dan desainer yang ingin mempelajari dasar-dasar desain sirkuit dan skema. Kehebatannya berasal dari fakta bahwa ia memberi Kalian jalan untuk belajar tanpa takut merusak papan dan peralatan desain Kalian. Selain itu, siswa yang mungkin memiliki beberapa tantangan dalam membeli peralatan listrik tanpa mengetahui bagaimana mereka akan berfungsi dapat menggunakan simulator Arduino. Ini akan menghemat banyak uang dan waktu.

Keuntungan besar lainnya dari simulator Arduino adalah mendukung debugging baris ke baris sehingga pengguna tahu persis di mana atau baris mana yang salah. Simulator Arduino ada dalam berbagai bentuk dan telah dikembangkan agar kompatibel dengan sistem operasi utama — Windows, Linux, dan Mac OS — di luar sana. Oleh karena itu untuk menyederhanakan pencarian Kalian akan simulator Arduino, berikut adalah beberapa simulator yang telah kami rangkum untuk kalian.

Simulator Arduino PaulWare

Seperti namanya, simulator Arduino ini dibuat oleh seorang developer bernama Paul. Simulator ini open source dan telah mengumpulkan cukup banyak pengikut yang keduanya menambah sumber dayanya dan membuat tutorial tentang cara menggunakan simulator. Produk gratis ini dibuat terutama untuk Windows dan menyediakan dukungan yang cukup untuk simulasi yang ingin dijalankan oleh pemula.

Komponen utama yang disediakan untuk mendukung proyek Kalian termasuk sakelar, LED, keypad matriks 4*4, keypad matriks 4*4 dengan layar LCD, potensio, dll.

Simduino: Simulator Arduino iPad

Simulator Arduino ini adalah simulator berbayar yang dikembangkan untuk digunakan pada perangkat pintar Apple. Ini adalah simulator komprehensif yang memungkinkan Kalian belajar tentang pemrograman dan elektronik di platform Arduino. Ini memberikan dukungan yang cukup untuk sebagian besar bahasa pemrograman Arduino C dan dapat digunakan untuk menjalankan beberapa proyek sesuai dengan kebutuhan pengguna.

Opsi ini dinilai tinggi dan ulasannya dari toko iTunes sangat tinggi. Ada sistem pendukung yang baik untuk membantu penggunanya memahami detail dokumentasi dan sumber daya yang tersedia bagi penggunanya di situs resminya. Dengan sekitar Rp 30.000, Kalian mendapatkan simulator Arduino solid yang kompatibel dengan iPad Kalian.

ArduinoSim

Sekarang, inilah simulator Arduino lintas platform yang melakukan apa yang dijanjikannya; menyediakan platform yang bagus untuk belajar pemrograman dan desain sirkuit. Meskipun bukan open source, simulator ini sepenuhnya gratis dan memberi Kalian kemampuan untuk bekerja di sistem operasi Windows dan Linux dengan mudah. ArduinoSim dibuat dengan Python dan dibangun untuk mengintegrasikan dirinya secara mulus dengan lingkungan Arduino.

ArduinoSim dibangun untuk audiens ilmiah dan teknik. Dan basis penggunanya telah memastikan bahwa bahan pendukung yang cukup tersedia di luar sana yang mudah dijangkau untuk penggunaan pribadi Kalian. Oleh karena itu, proyek yang didukungnya umumnya masuk ke dalam ranah teknik elektro.

Simulator Arduino untuk PC

Ini juga salah satu simulator Arduino terbaik di luar sana karena beberapa alasan. Alasan ini termasuk fitur lintas platform, desain sketsa, sketsa debug, dan mengembangkan ide rumit dengan mudah. Ini memiliki basis pada Windows dan Linux. Pengguna juga dapat memilih jenis Arduino—Mega, Nano, dan Leonardo—yang ingin mereka gunakan serta layar LCD.

Penting untuk dicatat bahwa itu bukan open source dan fitur-fiturnya dikembangkan dan diluncurkan oleh pengembangnya. Ada juga banyak dokumentasi pendukung dan contoh proyek di luar sana untuk mendorong Kalian menggunakannya. Sayangnya, itu datang dengan biaya yang relatif mahal Rp 200.000 jika dibandingkan dengan lainnya di luar sana. Tetapi dengan multi-fungsi dan alat debugging yang sangat baik, simulator Arduino untuk PC adalah pilihan tepat untuk pertimbangan dalam pembelian simulator arduino.

Simulator For Arduino

Simulator For Arduino yang dikembangkan oleh virtronics, adalah simulator berfitur lengkap yang tersedia untuk siswa dan pemula di dunia elektronik yang mencari simulator Arduino yang sangat baik. Ini adalah simulator lintas platform yang didukung oleh sistem operasi Linux dan Windows.

Fitur simulator ini dan beberapa manfaatnya antara lain; kemampuannya untuk berfungsi sebagai alat pengajaran yang mencakup dasar-dasar sketsa di Arduino, menguji ide-ide sketsa untuk melihat pola kerja, Debug baris Kalian dan mengembangkan presentasi virtual untuk klien baru. Penting juga untuk dicatat bahwa simulator untuk Arduino bukanlah penawaran open source tetapi datang tanpa biaya.

Simulator Arduino Emulare

Tertarik untuk multi-tasking dengan tugas Arduino Kalian? Maka Emulare adalah taruhan terbaik Kalian. Simulator inovatif ini memberi penggunanya kemampuan untuk mensimulasikan beberapa proyek Arduino secara bersamaan tanpa hambatan apa pun. Ini juga disebut sebagai simulator lintas platform karena mendukung sistem operasi Linux dan Windows.

Emulare dibuat untuk sebagian besar proyek elektronik listrik dan dilengkapi dengan perpustakaan objek yang kaya. Emulare menempatkan fokusnya pada mikrokontroler ATMega yang memungkinkan Kalian membangun sirkuit lengkap dengan elemen memori AVR, tombol tekan, sakelar, pengatur waktu, LED, dan komponen lainnya. Anehnya, Emulare dengan semua fitur dan komponennya benar-benar gratis dan dilengkapi dengan dukungan yang cukup untuk membantu penggunanya memahami fitur-fiturnya.

Tinkercad

Peran Autodesk dalam mengembangkan sirkuit listrik selama bertahun-tahun adalah salah satu yang tidak dapat terlalu ditekankan. Sirkuit Tinkercad hanyalah salah satu dari penawaran Autodesk tetapi kompatibilitasnya dengan Arduino memberinya tempat di daftar ini. Pertama, penting untuk dicatat bahwa Tinkercad adalah aplikasi CAD yang memiliki fitur khusus untuk mendesain sirkuit. Oleh karena itu, saat mengunduh aplikasi gratis, Kalian akan mendapatkan aplikasi CAD dan simulator Arduino.

Seperti simulator lain yang disebutkan di atas, Tinkercad adalah aplikasi yang sangat bagus untuk mempelajari dasar-dasar pemrograman Arduino dan desain sirkuit. Aplikasi ini bekerja pada Windows dan Android. Ini juga memiliki sumber daya atau basis dukungan yang sangat besar seperti kebanyakan produk Autodesk yang memberi Kalian semua dukungan yang Kalian perlukan untuk mengembangkan sirkuit atau belajar dari awal. Aplikasi ini sangat direkomendasikan oleh penggunanya seperti yang dapat dilihat dari ulasan online-nya.

Yenka For Arduino

Yenka adalah simulator Arduino yang solid yang dapat digunakan oleh siswa, serta pengguna Arduino yang berpengalaman untuk belajar serta mengajarkan dasar-dasar pemrograman dan desain sirkuit. Seperti kebanyakan simulator dalam daftar ini, simulator ini dilengkapi dengan semua fitur yang diperlukan untuk menguji sketsa/ide, men-debug proyek Kalian, dan mengembangkan proyek rumit tanpa input perangkat keras apa pun.

Yenka telah banyak digunakan oleh para pendidik yang mengajarkan dasar-dasar elektronika elektrik dan harganya mungkin tidak terjangkau oleh siswa. Ini adalah simulator lintas platform yang berjalan di sistem operasi Linux dan Windows yang jelas merupakan pro dalam buku saya. Terlepas dari biayanya, itu mungkin saja simulator Arduino yang sempurna untuk penggunaan pribadi Kalian.

Ppice For Arduino

Saya percaya setiap siswa listrik dan elektronik pasti pernah menemukan PSpice selama berbulan-bulan mempelajari dasar-dasar desain sirkuit dan pemrograman. Namun bagi yang belum mengetahui apa itu PSpice, ini adalah simulator intuitif yang dapat digunakan untuk simulasi Arduino karena banyaknya fitur yang terintegrasi ke dalam aplikasi. PSpice didukung oleh sistem operasi Windows dan Linux dan hadir dalam modul atau tipe yang berbeda.

Siswa dapat menggunakan PSpice Lite yang benar-benar gratis untuk mempelajari dasar-dasar pemrograman Arduino sementara perusahaan, guru, dan pakar lainnya dapat menggunakan PSpice berbayar. PSpice saat ini telah digunakan di berbagai industri otomotif, pendidikan, pasokan energi, dll. Ada komunitas yang benar-benar bersemangat di sekitar PSpice banyak penawaran yang berarti bahwa mempelajari fitur-fiturnya atau menerima bantuan saat mengerjakan proyek pribadi Kalian akan mudah didapat.

LTSpice Arduino Simulator

LTSpice adalah simulator sirkuit serbaguna dan akurat gratis dengan kemampuan untuk mensimulasikan program dan desain yang dikembangkan untuk Arduino. Simulator dilengkapi dengan banyak fitur yang dirancang untuk membuat simulasi menjadi mudah dan termasuk atribut penangkap skema dan penampil bentuk gelombang.

Ini adalah salah satu dari sedikit simulator di luar sana yang didukung oleh platform Windows dan Mac OS. Itu sangat direkomendasikan dan dengan banyak sumber daya online untuk memudahkan proses belajar Kalian. Seperti yang dinyatakan sebelumnya, simulator ini benar-benar gratis dan dapat ditemukan untuk penggunaan pribadi

Simulator EasyEDA

Ini adalah salah satu favorit pribadi saya karena fitur, kegunaan, dan dukungan luas untuk sistem operasi utama yang digunakan siapa pun. EasyEDA bagus untuk mempelajari pemrograman dan desain sirkuit di Windows, Linux, Mac OS, dan Android, suatu prestasi yang hanya bisa dibanggakan oleh sedikit orang lain.

Itu datang dengan biaya yang mungkin tidak menyenangkan bagi sebagian orang. Selain itu, ada banyak materi pembelajaran serta komunitas online yang didedikasikan untuk membahas semua hal yang berkaitan dengan EasyEDA.

Circuit Lab Arduino Simulator

Lab sirkuit dibuat sebagai alat simulasi skematis dan kuat yang mudah dan benar-benar meninggalkan penagihan ini. Simulator ini dirancang mengikuti model PSpice dan dibuat terutama untuk digunakan oleh insinyur listrik dan elektronik. Fitur-fiturnya memungkinkan pengguna untuk; pelajari cara kerja bagian dalam sketsa Arduino, proyek debug, dan skema desain/pratinjau.

Aplikasi Circuit Lab tidak gratis dan ini mungkin menjadi faktor pembatas bagi siswa yang mencari simulator Arduino untuk digunakan. Aplikasi ini berjalan pada sistem operasi Windows dan Linux. Itu juga berbasis komunitas dan dilengkapi dengan bahan pendukung yang cukup, studi kasus dan contoh yang mengajarkan Kalian tentang fitur dan penggunaannya.

Circuits-cloud Simulator

Sepanjang daftar, kami belum menawarkan opsi simulasi dalam browser. Jadi inilah Circuits-cloud, simulator Arduino luar biasa yang dapat digunakan oleh siapa saja untuk mempelajari dasar-dasar desain sirkuit. Ini dirancang hanya dengan fitur desain dasar untuk membuat sketsa dan simulasi menjadi menyenangkan dan mudah dipahami oleh pemula. Aplikasi ini juga gratis yang membuatnya mendapat tempat di daftar ini.

Systemvision Simulator

Systemvision adalah simulator berbasis cloud brilian lainnya yang harus Kalian pertimbangkan untuk menjalankan simulasi Arduino dan desain sirkuit Kalian. Ini adalah alat online gratis dengan fitur yang Kalian butuhkan untuk mempelajari, membuat, dan berbagi ide dengan rekan atau klien Kalian untuk menerima umpan balik instan. Muncul dengan komunitas yang dinamis dan dukungan luar biasa dari perusahaan induknya yang pasti akan menyederhanakan proyek Kalian.

Arduino IO Simulator 1.5

Simulator Arduino IO dirancang untuk memberi Kalian kemampuan untuk mensimulasikan IO (masuk dan keluar) proyek Kalian hanya dengan menghubungkan papan Kalian ke komputer (Kalian hanya memerlukan papan Arduino UNO Kalian). Perangkat lunak simulasi akan berkomunikasi dengan papan Arduino Kalian melalui perpustakaan simulator Arduino dan komunikasi serial (port USB).

Untuk memanfaatkan perpustakaan simulator, Kalian perlu mengubah baris kode yang mengontrol input dan output. Kami membuat instruksi yang mirip dengan yang digunakan Arduino, kami mengubah instruksi digitalWrite, analogWrite,… menjadi yang menggunakan huruf kapital seperti DigitalWrite, AnalogWrite. Semua instruksi yang mungkin dapat ditemukan di manual penggunanya.

Ada 2 versi yang tersedia. Versi gratis dan versi berbayar baik untuk pengguna Windows dan Mac. Kalian dapat mempelajari lebih lanjut tentang simulator ini di sini.

Proteus oleh Labcenter

Ini adalah simulator luar biasa yang menggabungkan kesederhanaan dengan banyak fiturnya untuk membuat simulasi Arduino berjalan-jalan di taman. Simulator telah membuat terobosan di berbagai industri termasuk; otomotif, IoT, dan pendidikan. Ini kompatibel dengan Windows dan Linux dan dikenakan biaya. Kalian dapat mempelajari lebih lanjut tentang komunitas dan penawarannya yang dinamis di sini.

Di sini kita sampai pada akhir daftar simulator Arduino yang dapat Kalian pertimbangkan untuk dimanfaatkan. Untuk memberi Kalian lebih banyak opsi, simulator gratis dan berbayar.