Translate

ARDUINO Monitor Suhu MLX90614 dan ADC Penampil DMD Panel Led P10

ARDUINO Monitor Suhu MLX90614 dan ADC Penampil DMD Panel Led P10


        Pada kesempatan kali ini saya akan menjelaskan mengenai bagaimana cara membuat sebuah alat untuk mengukur suhu dengan penampil adalah DMD Led Panel P10. alat ini menggunakan arduino sebagai procesornya, jadi yang ditampilkan adalah dua buah sensor yaitu sensor analog dan digital, sebagai contoh yang dipakai adalah nilai ADC dan sensor MLX90614. untuk lebih jelasnya berikut adalah skema dan programnya.   



a. Arduino Uno




b. DMD Panel Led P10




c. Sensor Suhu MLX90614





d. Program Arduino IDE 

#include <Wire.h>
#include <SPI.h>        //SPI.h must be included as DMD is written by SPI (the IDE complains otherwise)
#include <DMD.h>        //Library DMD yang menyediakan fungsi penampilan teks, gambar dsb
#include <TimerOne.h>   //Library peripheral Timer1 untuk menjalankan prosedur pindai panel DMD
#include <Time.h>     //Library waktu yang menyediakan tipe data, struktur, dan obyek waktu
#include <DS1307RTC.h>  // Library RTC
#include "Arial_black_16.h"
#include "Arial_Black_16_ISO_8859_1.h"
#include "Arial14.h"
#include "DejaVuSans9.h"
#include "DejaVuSansBold9.h"
#include "DejaVuSansItalic9.h"
#include "Droid_Sans_12.h"
#include "Droid_Sans_16.h"
#include "Mono5x7.h"
#include "SystemFont5x7.h"

#define WAKTU_TAMPIL_JAM      10    //detik
#define WAKTU_TAMPIL_KALENDAR 5     //detik

#define DISPLAY_COLUMN_COUNT  2
#define DISPLAY_ROW_COUNT     1

#define PIXELS_PER_COLUMN  32
#define PIXELS_PER_ROW    16

#include <Adafruit_MLX90614.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

DMD dmd(DISPLAY_COLUMN_COUNT, DISPLAY_ROW_COUNT);
unsigned char show = 0;

unsigned int suhu;
unsigned int suhux;
unsigned int dataadc;

char lineBuff[20];
char lineBuffx[20];
  
void ScanDMD()
{
  dmd.scanDisplayBySPI();
}


void setup(void)
{
  mlx.begin(); 
  dmd.clearScreen( true );   //true is normal (all pixels off), false is negative (all pixels on)
  Serial.begin(9600);
   //initialize TimerOne's interrupt/CPU usage used to scan and refresh the display
  Timer1.initialize( 1000 );           //period in microseconds to call ScanDMD. Anything longer than 5000 (5ms) and you can see flicker.
  Timer1.attachInterrupt( ScanDMD );   //attach the Timer1 interrupt to ScanDMD which goes to dmd.scanDisplayBySPI()

  //clear/init the DMD pixels held in RAM
  dmd.clearScreen( true ); 
 
}


void loop(void)
{
      suhu = mlx.readAmbientTempC();
      suhux = mlx.readObjectTempC();
      dataadc = analogRead(A0);
     
      sprintf(lineBuff, "%d|%d", suhu, suhux);
      sprintf(lineBuffx, "%d ", dataadc);

      dmd.selectFont(DejaVuSans9);
      dmd.selectFont(Mono5x7);
      dmd.drawString( 33,  0, lineBuff, strlen(lineBuff), GRAPHICS_NORMAL);  
      dmd.drawString( 33,  8, lineBuffx, strlen(lineBuffx), GRAPHICS_NORMAL);  


delay(1000);
}




e. Konfigurasi Arduino ke Panel Led P10 DMD





f. VIDEO HASILNYA








Membuat Jam Digital Menggunakan ARDUINO dan DMD PANEL LED P10

Membuat Jam & Kalender Digital Menggunakan ARDUINO dan DMD PANEL LED P10


        Pada kesempatan kali ini saya akan menjelaskan mengenai bagaimana cara membuat sebuah jam digital yang dilengkapi dengan kalender, alat ini menggunakan DMD led panel P10 sebagai media penampil jam dan kalendernya sehingga terlihat jelas meskipun dari kejauhan. alat ini menggunakan arduino uno dan RTC ds1307. untuk lebih jelasnya berikut adalah skema dan programnya.



a. Arduino Uno




b. DMD Panel Led P10




c. RTC DS1307






d. Program Arduino IDE

#include <SPI.h>        //SPI.h must be included as DMD is written by SPI (the IDE complains otherwise)
#include <DMD.h>        //Library DMD yang menyediakan fungsi penampilan teks, gambar dsb
#include <TimerOne.h>   //Library peripheral Timer1 untuk menjalankan prosedur pindai panel DMD
#include <Time.h>     //Library waktu yang menyediakan tipe data, struktur, dan obyek waktu
#include <DS1307RTC.h>  // Library RTC
// Font yang digunakan
#include <SPI.h>       
#include <DMD.h>       
#include <TimerOne.h>  
#include "Arial_black_16.h"
#include "Arial_Black_16_ISO_8859_1.h"
#include "Arial14.h"
#include "DejaVuSans9.h"
#include "DejaVuSansBold9.h"
#include "DejaVuSansItalic9.h"
#include "Droid_Sans_12.h"
#include "Droid_Sans_16.h"
#include "Mono5x7.h"
#include "SystemFont5x7.h"

#define WAKTU_TAMPIL_JAM      10    //detik
#define WAKTU_TAMPIL_KALENDAR 5     //detik

#define DISPLAY_COLUMN_COUNT  2
#define DISPLAY_ROW_COUNT     1

#define PIXELS_PER_COLUMN  32
#define PIXELS_PER_ROW    16

int cacah;

DMD dmd(DISPLAY_COLUMN_COUNT, DISPLAY_ROW_COUNT);
unsigned char show = 0;

const char namaHari[7][7] PROGMEM = { "MINGGU", "SENIN", "SELASA",
                                      "RABU", "KAMIS", "JUMAT", "SABTU"
                                    };
const char namaBulan[12][10] PROGMEM = { "01", "02", "03",
                                        "04", "05", "06", "07",
                                        "08", "09", "10",
                                        "11", "12"
                                      };

void AturWaktuRTC();
void (*restart)(void) = 0x00;
void print2digits(int number);

unsigned char DetikTerakhir, MenitTerakhir, JamTerakhir,
         HariTerakhir, TanggalTerakhir, BulanTerakhir;
unsigned int TahunTerakhir;
tmElements_t wkt;
unsigned char SecCount = 0;
bool Mode = false; // false = tampilan Jam, true = tampilan hari,tanggal,bulan,tahun

//Fire up the DMD library as dmd
//DMD dmd(2, 1);

/*--------------------------------------------------------------------------------------
  Interrupt handler for Timer1 (TimerOne) driven DMD refresh scanning, this gets
  called at the period set in Timer1.initialize();
  --------------------------------------------------------------------------------------*/
void ScanDMD()
{
  dmd.scanDisplayBySPI();
}

/*--------------------------------------------------------------------------------------
  Show clock numerals on the screen from a 4 digit time value, and select whether the
  flashing colon is on or off
  --------------------------------------------------------------------------------------*/
void DisplayHour(unsigned char Hour)
{
  dmd.drawChar(  34,  2, ' ', GRAPHICS_NORMAL );
  dmd.drawChar(  34,  2, '0' + (Hour / 10), GRAPHICS_NORMAL );
  dmd.drawChar(  40,  2, ' ', GRAPHICS_NORMAL );
  dmd.drawChar(  40,  2, '0' + (Hour % 10), GRAPHICS_NORMAL );
}

void DisplayMinute(unsigned char Minute)
{
  dmd.drawChar( 49,  2, ' ', GRAPHICS_NORMAL );
  dmd.drawChar( 49,  2, '0' + (Minute / 10), GRAPHICS_NORMAL );
  dmd.drawChar( 55,  2, ' ', GRAPHICS_NORMAL );
  dmd.drawChar( 55,  2, '0' + (Minute % 10), GRAPHICS_NORMAL );
}

void DisplayDate(unsigned char DayOfWeek,
                 unsigned char Day,
                 unsigned char Month,
                 unsigned int Year)
{
  char DayName[7];
  char MonthName[10];

  memset(DayName, 0, 7);
  memset(MonthName, 0, 10);
  strcpy_P(DayName, namaHari[DayOfWeek - 1]);
  strcpy_P(MonthName, namaBulan[Month - 1]);
  char lineBuff[20];
 
  //dmd.drawString(32, 3, lineBuff, strlen(lineBuff), GRAPHICS_NORMAL);
  //dmd.drawString(0, 3, DayName, strlen(DayName), GRAPHICS_NORMAL);
  sprintf(lineBuff, "%s %02d/%s/%d", DayName, Day, MonthName, Year - 2000);
 

  ShowMarquee(lineBuff,false);
}

void ShowDateTime(unsigned char Day,
                  unsigned char Date,
                  unsigned char Month,
                  unsigned int Year,
                  unsigned char Hour,
                  unsigned char Minute,
                  bool bColonOn)
{
  dmd.clearScreen(true);

  // units

}

/*--------------------------------------------------------------------------------------
  setup
  Called by the Arduino architecture before the main loop begins
  --------------------------------------------------------------------------------------*/
void setup(void)
{
  bool aturRTC = false;

  // Inisialisai komunikasi serial dengan PC
  Serial.begin(9600);
  delay(1000);
  if ((!(RTC.read(wkt))) || (aturRTC)) { // Jika fresh run
    AturWaktuRTC();
  }
  else {
    Serial.println("Ketik 'ATUR' Untuk mengatur ulang waktu RTC");
  }

  // inisialisasi awal nilai waktu
  DetikTerakhir = 99;
  MenitTerakhir = 99;
  JamTerakhir = 99;
  HariTerakhir = 99;
  TanggalTerakhir = 99;
  BulanTerakhir = 99;
  TahunTerakhir = 99999;

  //initialize TimerOne's interrupt/CPU usage used to scan and refresh the display
  Timer1.initialize( 1000 );           //period in microseconds to call ScanDMD. Anything longer than 5000 (5ms) and you can see flicker.
  Timer1.attachInterrupt( ScanDMD );   //attach the Timer1 interrupt to ScanDMD which goes to dmd.scanDisplayBySPI()

  //clear/init the DMD pixels held in RAM
  dmd.clearScreen( true );   //true is normal (all pixels off), false is negative (all pixels on)
  //delay(1500);
}

/*--------------------------------------------------------------------------------------
  loop
  Arduino architecture main loop
  --------------------------------------------------------------------------------------*/
void loop(void)
{
  int i;
  unsigned char DetikSekarang, MenitSekarang, JamSekarang,
           HariSekarang, TanggalSekarang, BulanSekarang;
  unsigned int TahunSekarang;

  // Lihat apakah input serial dari pengguna
  // lebih besar atau sama dg 4 byte
  if (Serial.available() >= 4) {
    char buff[5];

    Serial.readBytes(buff, 4);
    // Jika input serial dari pengguna adalah ATUR, maka lakukan prosedur
    // pengaturan waktru RTC
    if ((buff[0] == 'A') && (buff[1] == 'T') && (buff[2] == 'U') && (buff[3] == 'R')) {
      AturWaktuRTC();
    }
  }

  if (!RTC.read(wkt)) {
    Serial.println("RTC error!");
    delay(500);
    restart();
  }

  DetikSekarang = wkt.Second;

    MenitSekarang = wkt.Minute;
    JamSekarang = wkt.Hour;

      dmd.selectFont(DejaVuSansBold9);
      DisplayMinute(MenitSekarang);


      dmd.selectFont(DejaVuSansBold9);
      DisplayHour(JamSekarang);

    if ( DetikSekarang % 2 == 0 )
      dmd.drawChar( 46,  2, ':', GRAPHICS_OR);   // clock colon overlay on
    else
      dmd.drawChar( 46,  2, ':', GRAPHICS_NOR);   // clock colon overlay off

    HariSekarang = wkt.Wday;
    TanggalSekarang = wkt.Day;
    BulanSekarang = wkt.Month;
    TahunSekarang = wkt.Year;

    
  cacah++;   
  delay(200);
 
if(cacah > 150){
      dmd.selectFont(DejaVuSans9);
      dmd.selectFont(Mono5x7);
      DisplayDate(HariSekarang, TanggalSekarang,
                  BulanSekarang, tmYearToCalendar(TahunSekarang));
     cacah = 0; 
  }

}

void AturWaktuRTC()
{
  int input;
  char buff[10];
  tmElements_t wkt;

  Serial.println(F("-------------------------\nAtur ulang waktu RTC"));

  // Minta pengguna memasukan hari
  Serial.println(F("\nMasukkan 2 digit kode hari\n01: Minggu\n02: Senin\n03: " \
                   "Selasa\n04: Rabu\n05: Kamis\n06: Jumat\n07: Sabtu\n>>>"));
  while (Serial.available() < 2);
  Serial.readBytes(buff, 2);
  sscanf(buff, "%02d", &input);
  if ((input >= 1) && (input <= 7)) {
    wkt.Wday = input;
    Serial.print("Sekarang hari: ");
    strcpy_P(buff, (const char*)namaHari[wkt.Wday - 1]);
    Serial.println(buff);
  }
  else {
    Serial.print("Input salah! Restarting...");
    restart();
  }

  // Minta pengguna memasukan tanggal
  Serial.println(F("\nMasukkan 2 digit tanggal (01-31)\n>>>"));
  while (Serial.available() < 2);
  Serial.readBytes(buff, 2);
  sscanf(buff, "%02d", &input);
  if ((input >= 1) && (input <= 31)) {
    wkt.Day = input;
    Serial.print("Sekarang tanggal: ");
    Serial.println(wkt.Day, DEC);
  }
  else {
    Serial.print("Input salah! Restarting...");
    restart();
  }

  // Minta pengguna memasukan bulan
  Serial.println(F("\nMasukkan 2 digit kode bulan\n01: Jan\n02: Feb\n03: " \
                   "Mar\n04: Apr\n05: Mei\n06: Jun\n07: Jul\n08: Ags\n09: Sep\n10: Okt\n"
                   "11: Nov\n12: Des\n>>>"));
  while (Serial.available() < 2);
  Serial.readBytes(buff, 2);
  sscanf(buff, "%02d", &input);
  if ((input >= 1) && (input <= 12)) {
    wkt.Month = input;
    Serial.print("Sekarang bulan: ");
    strcpy_P(buff, (const char*)namaBulan[wkt.Month - 1]);
    Serial.println(buff);
  }
  else {
    Serial.print("Input salah! Restarting...");
    restart();
  }

  // Minta pengguna memasukan tahun
  Serial.println(F("\nMasukkan 4 digit tahun (2000-2100)\n>>>"));
  while (Serial.available() < 4);
  Serial.readBytes(buff, 4);
  sscanf(buff, "%4d", &input);
  if (input >= 2000 && input <= 2100) {
    wkt.Year = CalendarYrToTm(input);
    Serial.print("Sekarang tahun: ");
    Serial.println(tmYearToCalendar(wkt.Year), DEC);
  }
  else {
    Serial.print(F("Input salah!, tahun akan diatur ke 2015 secara default"));
    wkt.Year = CalendarYrToTm(2015);
  }

  // Minta pengguna memasukan jam
  Serial.println(F("\nMasukkan 2 digit jam (00-23)\n>>>"));
  while (Serial.available() < 2);
  Serial.readBytes(buff, 2);
  sscanf(buff, "%02d", &input);
  wkt.Hour = input;
  Serial.println(F("\nMasukkan 2 digit menit (00-59)\n>>>"));
  while (Serial.available() < 2);
  Serial.readBytes(buff, 2);
  sscanf(buff, "%02d", &input);
  wkt.Minute = input;
  Serial.print(F("Sekarang pukul "));
  sprintf(buff, "%02d:%02d", wkt.Hour, wkt.Minute);
  Serial.println(buff);

  Serial.print(F("\nMengkonfigurasi waktu RTC..."));
  if (RTC.write(wkt)) {
    Serial.println(F("OK"));
    Serial.print(F("Membaca waktu RTC..."));
    if (RTC.read(wkt)) {
      Serial.println(F("OK"));
      Serial.print("Pukul = ");
      print2digits(wkt.Hour);
      Serial.write(':');
      print2digits(wkt.Minute);
      Serial.write(':');
      print2digits(wkt.Second);
      Serial.print(", Date (D/M/Y) = ");
      Serial.print(wkt.Day);
      Serial.write('/');
      Serial.print(wkt.Month);
      Serial.write('/');
      Serial.print(tmYearToCalendar(wkt.Year));
      Serial.println();
    }
    else {
      Serial.println(F("FAILED"));
    }

  }
  else {
    Serial.println(F("FAILED"));
  }
  Serial.println(F("-------------------------"));
}

void print2digits(int number) {
  if (number >= 0 && number < 10) {
    Serial.write('0');
  }
  Serial.print(number);
}


void ShowMarquee(char *Text, bool LeftToRight)
{
  long start=millis();
  long timer=start;
  boolean ret=false;
 
  if (LeftToRight) {
    dmd.drawMarquee(Text,strlen(Text),
          -(dmd.fontWidth()*(strlen(Text)-1)),3);
  }
  else
    dmd.drawMarquee(Text,strlen(Text),
          (PIXELS_PER_COLUMN*DISPLAY_COLUMN_COUNT)-1,3);  
 
  while(!ret){
   if ((timer+100) < millis()) {
     if (LeftToRight)
        ret=dmd.stepMarquee(1,0); // Geser 1 karakter ke kiri
     else
        ret=dmd.stepMarquee(-1,0); // Geser 1 karakter ke kanan
     timer=millis();
   }
  }       
}



f. Cara Menyambungkan Arduino ke Panel LED P10






g. VIDEO HASILNYA









Membuat Moving Teks dan Moving Sign Menggunakan DMD Panel Led P10 Arduino (Teks Berjalan)

Membuat Moving Teks dan Moving Sign Menggunakan DMD Panel Led P10 Arduino (Teks Berjalan)


         Pada kesempatan kali ini saya akan menjelaskan mengenai bagaimana cara membuat sebuah alat yang menggunakan panel LED P10 sebagai media penampil teks, alat ini menggunakan arduino sebagai kontrollernya dan I2C untuk menampilkan jam dan tanggal. yang perlu diperhatikan yaitu power supply untuk panel P10 ini adalah 5v 3A sehingga jangan sampai kurang dari itu. untuk lebih jelasnya berikut adalah program dan skemanya.  



a. Arduino Uno




b. Led panel P10






c. Program Arduino Teks Berjalan

#include <SPI.h>       
#include <DMD.h>       
#include <TimerOne.h>  
#include "SystemFont5x7.h"
#include "Arial_black_16.h"

//Isi dengan jumlah panel DMD yang di susun dalam kolom dan baris
#define DISPLAY_COLUMN_COUNT  2
#define DISPLAY_ROW_COUNT     1

#define PIXELS_PER_COLUMN    32
#define PIXELS_PER_ROW        16


DMD dmd(DISPLAY_COLUMN_COUNT, DISPLAY_ROW_COUNT);
char Text[] = "Selamat Datang di DigiWare Unlimited Innovations";
/*--------------------------------------------------------------------------------------
  Interrupt handler for Timer1 (TimerOne) driven DMD refresh scanning, this gets
  called at the period set in Timer1.initialize();
--------------------------------------------------------------------------------------*/
void ScanDMD()
{
  dmd.scanDisplayBySPI();
}

void setup(void)
{
   //inisialisasi Timer1 untuk menginterupsi pengeksekusian prosedur pindai DMD secara periodik
   Timer1.initialize( 1000 );           //perioda eksekusi pindai DMD selama 1 ms. Nilai yang lebih besar dapat menimbulkan efek flicker.
   Timer1.attachInterrupt( ScanDMD );   //terapkan prosedur interupsi pindai DMD
   dmd.clearScreen( true );   //normalnya true (semua piksel dalam keadaan mati), false (semua piksel dalam keadaan hidup)
}

void loop(void)
{  
   dmd.clearScreen( true );
   dmd.selectFont(Arial_Black_16);
  
   dmd.drawMarquee(Text,strlen(Text),
          (PIXELS_PER_COLUMN*DISPLAY_COLUMN_COUNT)-1,0);
   long start=millis();
   long timer=start;
   boolean ret=false;
   while(!ret){
     if ((timer+30) < millis()) {
       ret=dmd.stepMarquee(-1,0); // Geser 1 karakter ke kiri
       timer=millis();
     }
   }     
}




d. Program Arduino Moving Sign / Stikman

#include <SPI.h>       
#include <DMD.h>       
#include <TimerOne.h> 

//Isi dengan jumlah panel DMD yang di susun dalam kolom dan baris
#define DISPLAY_COLUMN_COUNT  2
#define DISPLAY_ROW_COUNT     1

#define PIXELS_PER_COLUMN  32
#define PIXELS_PER_ROW    16


DMD dmd(DISPLAY_COLUMN_COUNT, DISPLAY_ROW_COUNT);

// Running stick figure pictures are loosely based on those from this tutorial:
// http://www.fluidanims.com/FAelite/phpBB3/viewtopic.php?f=10&t=102

byte const run1[] PROGMEM = {
    16, 16,
    B00000000, B00001100,
    B00000000, B00011110,
    B00000111, B11111110,
    B00001111, B11111110,
    B00011100, B11111100,
    B00000001, B11111100,
    B00000001, B11110000,
    B00000011, B11111000,
    B00000111, B00011000,
    B00001110, B01110000,
    B00011100, B01100000,
    B00111000, B00000000,
    B01110000, B00000000,
    B01100000, B00000000,
    B01000000, B00000000,
    B00000000, B00000000
};

byte const run2[] PROGMEM = {
    18, 16,
    B00000000, B01110011, B10000000,
    B00000000, B11111111, B10000000,
    B00000000, B00011111, B10000000,
    B00000000, B00111111, B11000000,
    B00000000, B01111011, B11000000,
    B00000000, B11110011, B10000000,
    B00000001, B11100000, B00000000,
    B00000011, B11100000, B00000000,
    B00000111, B01110000, B00000000,
    B01111110, B00111000, B00000000,
    B11111100, B00011100, B00000000,
    B00000000, B00001110, B00000000,
    B00000000, B00000111, B00000000,
    B00000000, B00000011, B10000000,
    B00000000, B00000001, B00000000,
    B00000000, B00000000, B00000000
};

byte const run3[] PROGMEM = {
    18, 16,
    B00000000, B00110000, B00000000,
    B00000000, B01111000, B00000000,
    B00000000, B00011111, B00000000,
    B00000000, B00011111, B00000000,
    B00000000, B00111111, B10000000,
    B00000000, B01111111, B11000000,
    B00000000, B11100011, B10000000,
    B00000001, B11000000, B00000000,
    B00000011, B11100000, B00000000,
    B11111111, B01110000, B00000000,
    B11111110, B00111000, B00000000,
    B00000000, B00011000, B00000000,
    B00000000, B00011100, B00000000,
    B00000000, B00001110, B00000000,
    B00000000, B00000100, B00000000,
    B00000000, B00000000, B00000000
};

byte const run4[] PROGMEM = {
    16, 16,
    B00000001, B11100000,
    B00000011, B11111100,
    B00000000, B00111110,
    B00000000, B01111110,
    B00000000, B11111100,
    B00000001, B10011111,
    B00000011, B00001110,
    B00000011, B00000000,
    B00000011, B10000000,
    B11111111, B10000000,
    B11111000, B11000000,
    B00000001, B11000000,
    B00000011, B10000000,
    B00000111, B00000000,
    B00000110, B00000000,
    B00000100, B00000000
};

byte const run5[] PROGMEM = {
    13, 16,
    B00000000, B00000000,
    B00000000, B00110000,
    B00000111, B11111000,
    B00000111, B11111000,
    B00000111, B11110000,
    B00001111, B11100000,
    B00000111, B00000000,
    B00001111, B00000000,
    B00001111, B00000000,
    B00001111, B10000000,
    B00011100, B00000000,
    B00111000, B00000000,
    B01110000, B00000000,
    B11100000, B00000000,
    B11000000, B00000000,
    B10000000, B00000000
};

byte const run6[] PROGMEM = {
    16, 16,
    B00000000, B00000000,
    B00000000, B00011100,
    B00000000, B00111110,
    B00000001, B11111110,
    B00000000, B11100000,
    B00000001, B11100000,
    B00000001, B11111000,
    B00000011, B00011100,
    B00000110, B00111000,
    B00000110, B01110000,
    B00001100, B00100000,
    B00111000, B00000000,
    B01100000, B00000000,
    B11000000, B00000000,
    B10000000, B00000000,
    B10000000, B00000000
};

byte const run7[] PROGMEM = {
    18, 16,
    B00000000, B00000011, B10000000,
    B00000000, B01111011, B10000000,
    B00000000, B01111111, B10000000,
    B00000000, B00001111, B00100000,
    B00000000, B00011001, B11000000,
    B00000000, B00110000, B11000000,
    B00000000, B01110000, B00000000,
    B00000001, B11110000, B00000000,
    B11111111, B10111000, B00000000,
    B11111111, B00011100, B00000000,
    B00000000, B00001110, B00000000,
    B00000000, B00000111, B00000000,
    B00000000, B00000011, B10000000,
    B00000000, B00000001, B11000000,
    B00000000, B00000000, B01000000,
    B00000000, B00000000, B00000000
};

byte const run8[] PROGMEM = {
    18, 16,
    B00000000, B00000110, B00000000,
    B00000001, B11101111, B00000000,
    B00000001, B11111111, B00000000,
    B00000000, B00111110, B00000000,
    B00000000, B01111111, B11000000,
    B00000000, B11100011, B10000000,
    B00000001, B11000000, B00000000,
    B00000011, B11100000, B00000000,
    B11111111, B01110000, B00000000,
    B11111110, B00111000, B00000000,
    B00000000, B00011100, B00000000,
    B00000000, B00000110, B00000000,
    B00000000, B00000110, B00000000,
    B00000000, B00000111, B00000000,
    B00000000, B00000011, B00000000,
    B00000000, B00000001, B00000000
};

byte const run9[] PROGMEM = {
    16, 16,
    B00000000, B00000000,
    B00000000, B01001110,
    B00000001, B11101110,
    B00000011, B11111110,
    B00000011, B11111110,
    B00000001, B10111100,
    B00000011, B00000000,
    B00000111, B00000000,
    B11111111, B10000000,
    B11111100, B11000000,
    B00000000, B11000000,
    B00000000, B11000000,
    B00000000, B11000000,
    B00000000, B11000000,
    B00000000, B11000000,
    B00000000, B11000000
};

byte const run10[] PROGMEM = {
    13, 16,
    B00000000, B00000000,
    B00000000, B00110000,
    B00000000, B01111000,
    B00000111, B11111000,
    B00001111, B11111000,
    B00000111, B11000000,
    B00001110, B00000000,
    B00001100, B00000000,
    B00001100, B00000000,
    B01111100, B00000000,
    B11111100, B00000000,
    B00011000, B00000000,
    B00110000, B00000000,
    B01110000, B00000000,
    B01100000, B00000000,
    B01000000, B00000000
};

PGM_VOID_P frames[] = {
    run1,
    run2,
    run3,
    run4,
    run5,
    run6,
    run7,
    run8,
    run9,
    run10
};
#define NUM_FRAMES  (sizeof(frames) / sizeof(frames[0]))
unsigned int frame = 0;

#define ADVANCE_MS  (1000 / NUM_FRAMES)
unsigned long lastFrame;
int runStep, runStepMax;

void ScanDMD()
{
  dmd.scanDisplayBySPI();
}

void setup() {
    //inisialisasi Timer1 untuk menginterupsi pengeksekusian prosedur pindai DMD secara periodik
   Timer1.initialize( 2000 );           //perioda eksekusi pindai DMD selama 2 ms. Nilai yang lebih besar dari 5ms (5000) dapat menimbulkan efek flicker.
   Timer1.attachInterrupt( ScanDMD );   //terapkan prosedur interupsi pindai DMD
   dmd.clearScreen( true );   //normalnya true (semua piksel dalam keadaan mati), false (semua piksel dalam keadaan hidup)
   lastFrame = millis() - ADVANCE_MS;
   runStepMax = PIXELS_PER_COLUMN * 5;
   runStep = -13;
}

void loop() {
    if ((millis() - lastFrame) >= ADVANCE_MS) {
        dmd.clearScreen( true );
        int x = (runStep - pgm_read_byte(frames[frame])) / 2;
        runStep+=4;
        if (runStep > runStepMax)
          runStep = -PIXELS_PER_COLUMN; 
        dmd.drawBitmap(x, 0, frames[frame],1);
        lastFrame += ADVANCE_MS;
        frame = (frame + 1) % NUM_FRAMES;
    }
}





e. Cara Menyambungkan Arduino ke Led Panel P10








f. VIDEO HASILNYA










Membuat Alat Pengukur Kecepatan Angin (Anemometer) wind speed dan Pengukur Suhu DS18B20 ARDUINO

Membuat Alat Pengukur Kecepatan Angin (Anemometer) wind speed dan Pengukur Suhu DS18B20 ARDUINO


          Pada kesempatan kali ini saya akan menjelaskan mengenai bagaimana caranya membuat sebuah alat yang dapat mengukur kecepatan angin dan suhu secara realtime menggunakan arduino, jadi alat ini terdapat dua buah sensor yaitu sensor anemometer dan sensor suhu ds18b20 dengan output lcd 16x2, selain itu juga terdapat indikator berupa led dan buzzer. untuk lebih jelasnya berikut adalah skema dan programnya. 



a. Arduino Uno



b. Sensor Kecepatan Angin




c. Sensor Suhu ds18b20




d. LCD 16x2






e. Program Arduino IDE

#include <OneWire.h>
#include <Wire.h>  // i2C Conection Library
#include <LiquidCrystal_I2C.h>  //i2C LCD Library

//LiquidCrystal_I2C lcd(0x27, 16, 2);
LiquidCrystal_I2C lcd(0x3F, 16, 2);

OneWire  ds(4);  // on pin 10 (a 4.7K resistor is necessary)


volatile byte half_revolutions; //variabel tipe data byte
unsigned int rpmku; //variabel tipe data integer
unsigned long timeold; //variabel tipe data long

int kalibrasi; //variabel tipe data integer

int ledsuhum = A2;
int ledsuhuk = A1;
int ledsuhuh = A0;

int ledrpmm = 5;
int ledrpmk = 6;
int ledrpmh = 7;
int buzp = 8;
int buzm = 11;


void setup() {
 
  pinMode(ledsuhum,OUTPUT);
  pinMode(ledsuhuk,OUTPUT);
  pinMode(ledsuhuh,OUTPUT);
 
  pinMode(ledrpmm,OUTPUT);
  pinMode(ledrpmk,OUTPUT);
  pinMode(ledrpmh,OUTPUT);
 
  pinMode(buzp,OUTPUT);
  pinMode(buzm,OUTPUT);
 
   attachInterrupt(0, rpm_fun, RISING); //mengambil sinyal high pada pin 2
   half_revolutions = 0; //memberikan nilai 0 pada viariabel
   rpmku = 0;
   timeold = 0;
   kalibrasi = 0;
 
  Serial.begin(9600);
  lcd.begin();
  lcd.clear();
  lcd.noCursor();

}

void loop() {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;

  if ( !ds.search(addr)) {
    ds.reset_search();
    delay(250);
    return;
  }

  for( i = 0; i < 8; i++) {

  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      return;
  }

  switch (addr[0]) {
    case 0x10:
      type_s = 1;
      break;
    case 0x28:
      type_s = 0;
      break;
    case 0x22:
      type_s = 0;
      break;
    default:
      return;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end

  delay(1000);     // maybe 750ms is enough, maybe not

  present = ds.reset();
  ds.select(addr); 
  ds.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }

  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms

  }
 
  celsius = (float)raw / 16.0;
  fahrenheit = celsius * 1.8 + 32.0;

  rpmku = 30*1000/(millis() - timeold)*half_revolutions; //mengaktifkan counter millis
  timeold = millis(); //hasil counter dimasukkan ke variabel timeold
  half_revolutions = 0; //reset variabel
 
  kalibrasi = (rpmku - 150)/109;  //rumus kalibrasi
 
  if(kalibrasi == 599){
  kalibrasi = 0;
  }
  if(kalibrasi == 600){
  kalibrasi = 0;
  }
 
  lcd.setCursor(0, 0);
  lcd.print("Suhu=");
  lcd.print(celsius);
  lcd.print("      ");

  lcd.setCursor(0, 1);
  lcd.print("Kec=");
  lcd.print(kalibrasi);
  lcd.print(" m/s ");


if(celsius > 35){
digitalWrite(ledsuhum,LOW);
digitalWrite(ledsuhuk,HIGH);
digitalWrite(ledsuhuh,HIGH);
  lcd.setCursor(12, 0);
  lcd.print("HIGH ");
}
if((celsius >= 30)&&(celsius <= 35)){
digitalWrite(ledsuhum,HIGH);
digitalWrite(ledsuhuk,LOW);
digitalWrite(ledsuhuh,HIGH);
  lcd.setCursor(12, 0);
  lcd.print("LOW  ");
}
if(celsius < 30){
digitalWrite(ledsuhum,HIGH);
digitalWrite(ledsuhuk,HIGH);
digitalWrite(ledsuhuh,LOW);
  lcd.setCursor(12, 0);
  lcd.print("LOW  ");
}


if(kalibrasi > 20){
digitalWrite(ledrpmm,LOW);
digitalWrite(ledrpmk,HIGH);
digitalWrite(ledrpmh,HIGH);
digitalWrite(buzp,HIGH);
digitalWrite(buzm,LOW);
  lcd.setCursor(12, 1);
  lcd.print("HIGH");

}
if((kalibrasi >= 10)&&(kalibrasi <= 20)){
digitalWrite(ledrpmm,HIGH);
digitalWrite(ledrpmk,LOW);
digitalWrite(ledrpmh,HIGH);
digitalWrite(buzp,LOW);
digitalWrite(buzm,LOW);
  lcd.setCursor(12, 1);
  lcd.print("LOW  ");
}
if(kalibrasi < 10){
digitalWrite(ledrpmm,HIGH);
digitalWrite(ledrpmk,HIGH);
digitalWrite(ledrpmh,LOW);
digitalWrite(buzp,LOW);
digitalWrite(buzm,LOW);
  lcd.setCursor(12, 1);
  lcd.print("LOW  ");
}

}


void rpm_fun(){
   half_revolutions++; //counter interupt
}





f. VIDEO HASILNYA












Arduino Simulasi Traffic Light Sensor PIR Komunikasi Wireless NRF24L01

Arduino Simulasi Traffic Light Sensor PIR Komunikasi Wireless NRF24L01


         Pada kesempatan kali ini saya akan menjelaskan mengenai bagaimana cara membuat sebuah alat yang dapat mendeteksi pergerakan orang dan akan menghidupkan lampu traffic light secara otomatis, jadi terdapat dua buah tiang yang mana jika tiang 1 aktif maka setelah tiang 1 selesai, tiang 2 akan aktif, begitu sebaliknya. komunikasi antar tiang menggunakan wireless modul NRF24L01. untuk lebih jelasnya berikut adalah skema dan programnya.  



a. Arduino Uno




b. Modul Wireless NRF24L01




c. Sensor PIR






d. Program Arduino IDE

#include  <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include <Wire.h>

int msg[1];
int datain;
int counter;
int ledhijau = A1;
int ledkuning = A2;
int ledmerah = A3;
int z;
int y;

RF24 radio(9,10);

const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(void){

 Serial.begin(9600);
 radio.begin();
 radio.openWritingPipe(pipe);
 pinMode(13,OUTPUT);
 radio.startListening();

  pinMode(ledhijau,OUTPUT);
  pinMode(ledkuning,OUTPUT);
  pinMode(ledmerah,OUTPUT);
 }


void loop(void){
terima();
z = 0;
//kirim();

int dataadc = analogRead(A0);
//Serial.println(dataadc);
delay(200);

  digitalWrite(ledhijau,LOW);
  digitalWrite(ledkuning,HIGH);
  digitalWrite(ledmerah,HIGH);
  
if(dataadc > 100){
  digitalWrite(ledhijau,HIGH);
  digitalWrite(ledkuning,LOW);
  digitalWrite(ledmerah,HIGH);
  delay(1000);
  digitalWrite(ledhijau,HIGH);
  digitalWrite(ledkuning,HIGH);
  digitalWrite(ledmerah,LOW);
  delay(3000);
  z = 1;
  kirim(); 
  }


if( y == 1){
  digitalWrite(ledhijau,HIGH);
  digitalWrite(ledkuning,LOW);
  digitalWrite(ledmerah,HIGH);
  delay(1000);
  digitalWrite(ledhijau,HIGH);
  digitalWrite(ledkuning,HIGH);
  digitalWrite(ledmerah,LOW);
  delay(3000);
  y = 0;
  }

 }


void kirim(){
counter++;
 msg[0] = z;
 radio.write(msg, 1);
 Serial.println(msg[0]);

 if(counter > 300){
 counter = 0;
 return;
 }
 kirim();
}


void terima(){

if (radio.available()){
   bool done = false;  
   while (!done){
     done = radio.read(msg, 1);    
     Serial.println(msg[0]);
     if (msg[0] == 1){
      y = 1;
     }  
     delay(10);
   }
  
 }
 else{
 Serial.println("No radio available");
 }
 return;
}



e. VIDEO HASILNYA