Blue Spinning Frozen Snowflake Vidi Fitriansyah Hidarlan's Blog: Agustus 2019
WELCOME TO MY BLOG :: Share Tips & Trik Tutorial Gadget dan Tugas Kuliah :: "Indahnya Berbagi"

Sabtu, 31 Agustus 2019

Cara Mengetahui Kapasitas Baterai HP Android

        Assalamu'alaikum Wr. Wb. di kesempatan ini saya akan memposting seputar gadget yaitu cara untuk mengetahui kapasitas baterai HP Android yang sebenarnya (dalam mAh). Sobat hanya perlu mengunduh aplikasi AccuBattery di Google Play Store. Berikut tampilan antarmukanya.
Screenshot saat discharging
        Screenshot dari aplikasi AccuBattery menampilkan beberapa informasi seperti estimasi waktu pemakaian saat kondisi layar aktif, layar mati, dan kombinasi keduanya.
Screenshot rata-rata penggunaan baterai dalam persen (%)
        Untuk mengetahui estimasi kapasitas real baterai dalam mAh dapat dilihat pada bagian "Health". Agar dapat diketahui estimasi/perkiraan kapasitasnya maka anda perlu memasukkan nilai kapasitas baterai hp anda yang tercantum dalam body baterai/spesifikasi hp pada dusbox/lihat di internet sesuai tipe hp yang anda gunakan. Setelah itu perlu juga dilakukan dengan mengosongkan baterai anda sampai 1% lalu di-charge kembali sampai 100% dengan ponsel dalam keadaan menyala/standby dan jangan menutup aplikasi AccuBattery  agar dapat menghitung nilai kapasitas sebenarnya. Supaya lebih akurat hasil perhitungannya maka diusahakan hpnya untuk tidak dipakai saat pengisian daya.
Screenshot estimasi kapasitas real baterai HP Android

Screenshot kurva kapasitas baterai setelah dilakukannya beberapa kali pemakaian dan pengisian daya
        Selain itu juga aplikasi ini dapat digunakan sebagai indikator arus pada saat pengisian daya (charging) dan pengosongan (discharging) daya baterai.
Notifikasi AccuBattery ketika discharging
Terima kasih atas kunjungannya...
Sampai jumpa di postingan selanjutnya yaa

Noise Cancellation dengan Algoritma Adaptive LMS (Least Mean Squared) pada MATLAB

       Assalamu'alaikum Wr. Wb. pada kesempatan ini saya akan berbagi cara membuat program noise cancellation dengan menggunakan algoritma LMS (Least Mean Squared) pada MATLAB.
        Pada program noise cancellation ini hanya akan meredam noise yang ada dari suara yang sudah direkam yang bercampur dengan suara-suara lain di sekitarnya yang tidak diinginkan jadi tidak untuk real time noise cancellation dikarenakan simulasi ini hanya digunakan pada laptop yang menggunakan satu mikrofon saja. Sehingga suara yang diinputkan menjadi harus bergantian. Suara yang sudah difilter dengan algoritma LMS ini akan menjadi lebih jernih dari suara yang masih bercampur dengan noise-nya. Cara menggunakannya yaitu dengan merekam terlebih dahulu suara yang bercampur dengan noise, kemudian direkam kembali hanya suara noise-nya saja. Noise cancellation ini banyak digunakan pada ponsel (ponsel yang sudah memiliki dedicated mic noise cancellation, biasanya terdapat lubang mic kecil di bagian atas ponsel/hp) untuk menghilangkan suara dari luar saat kita sedang melakukan panggilan suara.
N-tap Filter Adaptive Tranversal

        Langsung saja kita eksekusi langkah-langkahnya sebagai berikut :
  1. Langkah pertama buka program MATLAB dan klik ikon "New M-File" seperti pada gambar di bawah. Langkah ini dilakukan untuk membuat dan menyimpan program  "Perekam_Suara.m" pada MATLAB.
  2. Mengetik program berikut pada jendela "Editor" MATLAB.
    1. %Program perekam suara dan menyimpannya dalam bentuk file.wav

    2. function [suara_normal,a] = Perekam_Suara(sampel_frekuensi)
    3. pilihan = 'n';
    4. pilih_merekam = 'n';
    5. waktu_rekaman = 5;         %waktu perekaman (lamanya merekam) dalam detik
    6. sampel_frekuensi = 8192;     %frekuensi sampling dalam Hertz (8KHz)
    7. sampling_waktu = sampel_frekuensi* waktu_rekaman;

    8. 'Aplikasi Perekam Suara dengan MATLAB';
    9. nama_file = input('Ketik nama file hasil rekaman yang akan disimpan: ','s');
    10. nama_file_wav = sprintf('%s.wav',nama_file);
    11. pilih_merekam = input('tekan y untuk mulai merekam: ','s');
    12. if pilih_merekam=='y'
    13. while pilihan=='n',
    14. input('Tekan Enter untuk mulai merekam --> ');
    15. rekaman = wavrecord(sampling_waktu, sampel_frekuensi);       %merekam suara dari sound card dengan sampling rate yang sudah ditentukan
    16. input('Tekan Enter untuk mendengar hasil rekamannya --> ');
    17. sound(rekaman, sampel_frekuensi);
    18. pilihan = input('tekan y untuk menyimpan atau n untuk merekam kembali: ','s');
    19. end
    20. wavwrite(rekaman, sampel_frekuensi, nama_file_wav);  %menyimpan data yang telah direkam dalam format ".wav"
    21. end
  3. Simpan program tersebut dengan menekan ikon "Save" atau menekan tombol Ctrl+S pada keyboard.
  4. Pilih direktori/tempat file sesuai keinginan, dan simpan dengan nama yang sama persis pada program.
  5. Klik tombol Run untuk menjalankan program noise cancellation yang sudah disimpan sebelumnya.
  6. Setelah dijalankan dan disimpan nama file .wav-nya maka akan tersimpad di direktori default MATLAB. kalo di laptop saya letaknya di C:\Users\Vidi Fitriansyah H\Documents\MATLAB.
  7. Selanjutnya memasukkan sintaks  berikut pada "Command Window". Program di bawah ini merupakan program Noise Cancellation dengan algoritma LMS. Dalam program ini menggunakan filter 5-tap (delay sebanyak 5) yaitu Bobot.0 sampai Bobot.4 dengan panjang filter n sebanyak 40960. Semakin banyak n-tap-nya semakin jernih dan lebih mendekati suara asli yang dihasilkan, namun membutuhkan sumber daya (memori) yang banyak juga.
    1. %Program menentukan output sinyal asli berdasarkan pemfilteran antara sinyal noise dan sinyal asli+noise
    2. disp('Program LMS Noise Cancelation')
    3. disp('  ')
    4. disp('Parameter :')
    5. mu=1;%nilai mu dipilih 1 (bebas)
    6. Bobot0=0.1;%nilai inisialisasi w0 (masukkan bebas antara 0,1-0,9)
    7. Bobot1=0.2;%nilai inisialisasi w1 (masukkan bebas antara 0,1-0,9)
    8. Bobot2=0.3;%nilai inisialisasi w2 (masukkan bebas antara 0,1-0,9)
    9. Bobot3=0.4;%nilai inisialisasi w3 (masukkan bebas antara 0,1-0,9)
    10. Bobot4=0.6;%nilai inisialisasi w4 (masukkan bebas antara 0,1-0,9)
    11. n=40960;%panjang filter (sesuai nilai sampling suara)
    12. sn=wavread('Suara_Masuk.wav');%suara asli+noise/campuran
    13. noise=wavread('Suara_Noise.wav');%hanya suara noise
    14. disp('Input : Sound 1')
    15. disp('Desired Output : d(n)= Sound 2')
    16. disp('Output Adaptif : y1(n)=w0*x(n)+w1*x(n-1)w2*x(n-2)+w3*x(n-3)+w4*x(n-4)')
    17. disp('Update Nilai : w(n+1)=w(n)+2*mu*e(n)*x(n)') %algoritma LMS
    18. x=(noise');
    19. y1=[zeros(1,n)];%membuat matriks kosong dengan banyak baris 0 dan kolom n yang digunakan sebagai tempat hasil matriks y1
    20. w0=[zeros(1,n)];%membuat matriks kosong dengan banyak baris 0 dan kolom n yang digunakan sebagai tempat hasil matriks w0 (bobot 1)
    21. w1=[zeros(1,n)];%membuat matriks kosong dengan banyak baris 0 dan kolom n yang digunakan sebagai tempat hasil matriks w1 (bobot 2)
    22. w2=[zeros(1,n)];%membuat matriks kosong dengan banyak baris 0 dan kolom n yang digunakan sebagai tempat hasil matriks w2 (bobot 3)
    23. w3=[zeros(1,n)];%membuat matriks kosong dengan banyak baris 0 dan kolom n yang digunakan sebagai tempat hasil matriks w3 (bobot 4)
    24. w4=[zeros(1,n)];%membuat matriks kosong dengan banyak baris 0 dan kolom n yang digunakan sebagai tempat hasil matriks w4 (bobot 5)
    25. w0(1)=Bobot0;%nilai inisialisasi untuk w0
    26. w1(1)=Bobot1;%nilai inisialisasi untuk w1
    27. w2(1)=Bobot2;%nilai inisialisasi untuk w2
    28. w3(1)=Bobot3;%nilai inisialisasi untuk w3
    29. w4(1)=Bobot4;%nilai inisialisasi untuk w4
    30. for i=1:n-4 %nilai untuk elemen array i dari 1 sampai dengan n-4 karena nilai n=0 sampai n=4 sudah diisi oleh w0 sampai w1
    31. d=(sn');
    32. y1(i+4)=w0(i+4)*x(i+4)+w1(i+4)*x(i+3)+w2(i+4)*x(i+2)+w3(i+4)*x(i+1)+w4(i+4)*x(i);%output adaptif
    33. e(i+4)=d(i+4)-y1(i+4);%nilai error=nilai suara bersih
    34. w0(i+5)=w0(i+4)+2*mu*e(i+4)*x(i+4);%rumus algoritma LMS tap 1 
    35. w1(i+5)=w1(i+4)+2*mu*e(i+4)*x(i+3);%rumus algoritma LMS tap 2 
    36. w2(i+5)=w1(i+4)+2*mu*e(i+4)*x(i+2);%rumus algoritma LMS tap 3 
    37. w3(i+5)=w1(i+4)+2*mu*e(i+4)*x(i+1);%rumus algoritma LMS tap 4 
    38. w4(i+5)=w1(i+4)+2*mu*e(i+4)*x(i);%rumus algoritma LMS tap 5 
    39. end
    40. %disp('s+n    noise    w0       w1       w2      w3      w4        s+n-noise         y1')
    41. %disp('================================================================================')
    42. %fprintf(' %1.d   %.2f  %.5f  %.5f  %.5f  %.5f  %.5f   %.5f   %.5f\n',x,d,w0,w1,w2,w3,w4,e,y1)
    43. figure;
    44. subplot(3,3,1); plot(1:n,x),grid;xlabel('noise');ylabel('n'); %gambar sinyal noise
    45. subplot(3,3,2); plot(1:n,d),grid;xlabel('s+n'); ylabel('n'); %gambar sinyal s+n
    46. subplot(3,3,3); plot(1:n+1,w0),grid;xlabel('w0'); ylabel('n'); %gambar sinyal bobot 1
    47. subplot(3,3,4); plot(1:n+1,w1),grid;xlabel('w1'); ylabel('n'); %gambar sinyal bobot 2
    48. subplot(3,3,5); plot(1:n+1,w2),grid;xlabel('w2'); ylabel('n'); %gambar sinyal bobot 3
    49. subplot(3,3,6); plot(1:n+1,w3),grid;xlabel('w3'); ylabel('n'); %gambar sinyal bobot 4
    50. subplot(3,3,7); plot(1:n+1,w4),grid;xlabel('w4'); ylabel('n'); %gambar sinyal bobot 5
    51. subplot(3,3,8); plot(1:n,e),grid;xlabel('s+n-noise'); ylabel('n'); %gambar sinyal suara terfilter
    52. subplot(3,3,9); plot(1:n,y1),grid;xlabel('y1'); ylabel('n'); %gambar sinyal learning value
    53. fprintf('\n\nNilai w0 yang didapat adalah : %.5f\n',w0(i)) %nilai w0 akhir (sebenarnya)
    54. fprintf('Nilai w1 yang didapat adalah : %.5f\n',w1(i)) %nilai w1 akhir (sebenarnya)
    55. fprintf('Nilai w2 yang didapat adalah : %.5f\n',w2(i)) %nilai w2 akhir (sebenarnya)
    56. fprintf('Nilai w3 yang didapat adalah : %.5f\n',w3(i)) %nilai w3 akhir (sebenarnya)
    57. fprintf('Nilai w4 yang didapat adalah : %.5f\n',w4(i)) %nilai w4 akhir (sebenarnya)
  8. Untuk nama file suara sn dan noise disesuaikan dengan file audio yang sudah direkam sebelumnya.
  9. Setelah itu didapatkan nilai hasil masing-masing bobot yang sebenarnya pada screenshot di bawah.
  10. Dapat dilihat juga grafik sinyalnya pada jendela "Figure 1" di MATLAB.
  11. Karena perbedaan hasil sinyal suara+noise dan suara yang sudah difilter sangat sedikit maka untuk mengetahui perbedaan hasilnya sinyal-sinyal tersebut dari ranah waktu ditransformasikan ke ranah frekuensi dengan menggunakan fungsi fft (fast fourier transform) yang sudah ada pada MATLAB.  Agar dapat diubah ke ranah frekuensi maka dilanjutkan memasukkan program FFT-nya.
    1. A = fft(d);
    2. B = fft(e);
    3. C = fft(x);
    4. figure;
    5. N = length(e);
    6. T = 1/N;
    7. mag = abs(A);
    8. freq = (0:(N/2)-1)/(N*T);
    9. subplot(2,2,1),plot(freq,mag(1:N/2)),grid;
    10. xlabel('frekuensi');
    11. ylabel('magnitude');
    12. title('s+n');
    13. mag = abs(B);
    14. freq = (0:(N/2)-1)/(N*T);
    15. subplot(2,2,2),plot(freq,mag(1:N/2)),grid;
    16. xlabel('frekuensi');
    17. ylabel('magnitude');
    18. title('s+n-noise');
    19. mag = abs(C);
    20. freq = (0:(N/2)-1)/(N*T);
    21. subplot(2,2,3),plot(freq,mag(1:N/2)),grid;
    22. xlabel('frekuensi');
    23. ylabel('magnitude');
    24. title('Noise');
    25. sound(e);
  12. Maka hasil dari sinyal suara+noise, suara+noise-noise dan noise-nya seperti berikut.

        Dari sinyal tersebut terlihat sekilas bahwa suara+noise dan suara yang telah difilter (s+n-n) sama hal itu dikarenakan sinyal noise-nya yang diberikan sangat kecil. Namun jika diperbesar tampilannya maka akan terlihat perbedaan antara keduanya.
Sekian & terima kasih atas kunjungannya...
Semoga bermanfaat ;)

Jumat, 30 Agustus 2019

Cara Mengetahui Kapasitas Baterai Laptop

        Assalamu'alaikum Wr. Wb. Di kesempatan ini saya ingin berbagi tips bagaimana cara mengetahui kapasitas baterai laptop yang sebenarnya.
        Untuk mengetahuinya diperlukan software CPUID (HWMonitor) untuk Sistem Operasi berbasis Windows. Ada versi installer dan juga versi portable-nya juga. Untuk versi portable tidak perlu menginstalnya, cukup ekstrak file yg sudah didownload dan langsung bisa dijalankan.
        Setelah men-download software CPUID (HWMonitor) maka tampilannya akan terlihat seperti gambar di bawah.
Screenshot Aplikasi CPUID HWMonitor
        Untuk melihat kapasitas baterai, scroll ke bawah sampai terlihat tipe baterai yang digunakan pada laptop anda. Pada aplikasi ini anda dapat melihat besarnya kapasitas baterai yang didesain oleh pabrik laptop, kapasitas saat baterai penuh, dan kapasitas sekarang secara realtime dalam satuan miliwatthours (nilai dalam energi listrik).
        Selain itu juga dapat diketahui tingkat pemakaian baterai laptop dalam persentase beserta tingkat pengisian baterainya. Jika nilai kapasitas pengisian penuhnya sudah jauh di bawah kapasitas yang didesainnya atau level pemakaiannya sudah lebih dari 70%, dapat dipastikan bahwa baterai laptop anda sudah mulai drop dan harus diganti.
        Sekian & terimakasih atas kunjungannya ;)

Membuat Rangkaian Sensor Suhu LM35 dengan Tampilan Indikator LED dan Dot Matrix

        Assalamu'alaikum Wr. Wb. pada kesempatan ini saya akan memberi tutorial cara membuat rangkaian sensor suhu LM35 dengan Mikrokontroler ATmega16 yang dikombinasikan dengan tampilan indikator LED dan dot matrix.
        Pada rangkaian ini ATMEGA 16 digunakan untuk membaca data dari sensor suhu LM35 menggunakan ADC yang sudah built-in pada ATmega16, kemudian ditampilkan indikator suhunya ke LED dan nilai suhunya pada dot matrix (dalam celsius). ADC pada ATmega berfungsi untuk mengubah nilai tegangan analog dari sensor LM35 menjadi data digital.
     Langsung saja ke topik pembahasan yang akan kita lakukan, tools yang digunakan sama seperti pada postingan sebelumnya yaitu software Code Vision AVR untuk membuat dan meng-compile programnya dan ISIS Proteus untuk membuat desain sistem dan melakukan simulasi.
        Oke mari kita ikuti langkah-langkahnya sebagai berikut :
  1. Membuat project baru, kemudian pilih jenis chip dan clock speed-nya seperti pada gambar.
  2. Pada bagian tab "ADC", aktifkan pin ADCnya pada PORT A dengan mencentang "ADC Enabled".
  3. Kemudian pada bagian menu "Ports" di tab Port A dari pin 0 sampai 3 diatur sebagai keluaran active low. Port ini digunakan sebagai indikator tanda warna dengan lampu LED. Warna biru untuk nilai suhu di bawah 11 derajat, warna hijau untuk nilai suhu di bawah 21 derajat, warna kuning untuk nilai suhu dibawah 31 derajat dan warna merah untuk nilai suhu di atas 40 derajat celsius.
  4. Selanjutnya ke tab Port C dan Port D diatur sebagai keluaran ke pin-pin pada IC 74HC595. Konfigurasi keluaran active lownya pada Port C dari pin 0-7 dan pada Port D dari pin 0-5 seperti pada gambar berikut.

  5. Setelah program di "Generate, Save, and Exit" pada menu "Program" maka lengkapi programnya dengan memasukan source code program .c CV AVR di bawah ini.
    1. /*****************************************************
    2. This program was produced by the
    3. CodeWizardAVR V2.05.3 Standard
    4. Automatic Program Generator
    5. © Copyright 1998-2011 Pavel Haiduc, HP InfoTech s.r.l.
    6. http://www.hpinfotech.com

    7. Project : Sensor Suhu V2
    8. Version : 2.0
    9. Date    : 29/08/2019
    10. Author  : Vidi Fitriansyah Hidarlan
    11. Company : Personal
    12. Comments: 


    13. Chip type               : ATmega16
    14. Program type            : Application
    15. AVR Core Clock frequency: 8,000000 MHz
    16. Memory model            : Small
    17. External RAM size       : 0
    18. Data Stack size         : 256
    19. *****************************************************/

    20. #include <mega16.h>
    21. #include <stdlib.h>
    22. #include <delay.h>
    23. #define data_hi1    PORTD.0=1//pendefinisian data high untuk IC 74HC595 1 pada PORTD.0
    24. #define data_lo1    PORTD.0=0//pendefinisian data low untuk IC 74HC595 1 pada PORTD.0
    25. #define data_hi2    PORTD.3=1//pendefinisian data high untuk IC 74HC595 2 pada PORTD.3
    26. #define data_lo2    PORTD.3=0//pendefinisian data low untuk IC 74HC595 2 pada PORTD.3

    27. #define ADC_VREF_TYPE 0x00

    28. // Read the AD conversion result
    29. unsigned int read_adc(unsigned char adc_input)
    30. {
    31. ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
    32. // Delay needed for the stabilization of the ADC input voltage
    33. delay_us(10);
    34. // Start the AD conversion
    35. ADCSRA|=0x40;
    36. // Wait for the AD conversion to complete
    37. while ((ADCSRA & 0x10)==0);
    38. ADCSRA|=0x10;
    39. return ADCW;
    40. }

    41. // Declare your global variables here
    42.     int SUHU;
    43.     //char temp[8];
    44.     int suhu_celcius,puluhan,satuan;
    45. void clock1()
    46. {
    47.     PORTD.1=0; //clock1
    48.     PORTD.2=1; //Latch
    49.     PORTD.1=1; //clock1
    50.     PORTD.2=0; //Latch
    51.     delay_us(1);
    52. }
    53. void clock2()
    54. {
    55.     PORTD.4=0; //clock2
    56.     PORTD.5=1; //Latch
    57.     PORTD.4=1; //clock2
    58.     PORTD.5=0; //Latch
    59.     delay_us(1);
    60. }
    61. void indikator(void)
    62. {
    63.     if (suhu_celcius<=10)
    64.     {
    65.         PORTA=0b00000001;//nilai PORTA yang aktif untuk indikator suhu <=10
    66.     }
    67.     else if (suhu_celcius<=20)
    68.     {
    69.         PORTA=0b00000011;//nilai PORTA yang aktif untuk indikator suhu <=20
    70.     }
    71.     else if (suhu_celcius<=30)
    72.     {
    73.         PORTA=0b00000111;//nilai PORTA yang aktif untuk indikator suhu <=30
    74.     }
    75.     else if (suhu_celcius>30)
    76.     {
    77.         PORTA=0b00001111;//nilai PORTA yang aktif untuk indikator suhu >30
    78.     }
    79. }
    80. void main(void)
    81. {
    82. // Declare your local variables here
    83.     unsigned char kosong[8]={0,0,0,0,0,0,0,0};
    84.     unsigned char angka0[8]={0,0b01111110,0b11111111,0b11000011,0b11000011,0b11111111,0b01111110,0};
    85.     unsigned char angka1[8]={0,0b00100011,0b01100011,0b11111111,0b11111111,0b00000011,0b00000011,0};
    86.     unsigned char angka2[8]={0,0b01100011,0b11100111,0b11001111,0b11011011,0b11110011,0b01100011,0};
    87.     unsigned char angka3[8]={0,0b01100110,0b11000011,0b11011011,0b11011011,0b11111111,0b01100110,0};
    88.     unsigned char angka4[8]={0,0b00011100,0b00111100,0b01100100,0b11111111,0b11111111,0b00000100,0};
    89.     unsigned char angka5[8]={0,0b11110110,0b11111011,0b11011011,0b11011011,0b11011111,0b10001110,0};
    90.     unsigned char angka6[8]={0,0b01111110,0b11111111,0b11011011,0b11011011,0b11011111,0b01001110,0};
    91.     unsigned char angka7[8]={0,0b11000000,0b11000111,0b11001111,0b11011000,0b11110000,0b11100000,0};
    92.     unsigned char angka8[8]={0,0b01100110,0b11111111,0b11011011,0b11011011,0b11111111,0b01100110,0};
    93.     unsigned char angka9[8]={0,0b01110010,0b11111011,0b11011011,0b11011011,0b11111111,0b01111110,0};
    94.     unsigned char angka10[8]={0,0b01110010,0b11111011,0b11011011,0b11011011,0b11111111,0b01111110,0};
    95.     unsigned char derajat[8]={0,0,0,0,0b11100000,0b10100000,0b11100000,0};
    96.     unsigned char celcius[8]={0,0b0111110,0b11111111,0b11000011,0b11000011,0b11000011,0b01000010,0};
    97.    //char data_angka[30]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    98.    //char data2[6]={derajat,celcius};
    99.    //char PORT[8] = {1,2,4,8,16,32,64,128}; //pin values of a port 2^0,2^1,2^2……2^7
    100.         int x,y,a,b,i,j;

    101. // Input/Output Ports initialization
    102. // Port A initialization
    103. // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=Out Func1=Out Func0=Out 
    104. // State7=T State6=T State5=T State4=T State3=T State2=0 State1=0 State0=0 
    105. PORTA=0x00;
    106. DDRA=0x0F;

    107. // Port B initialization
    108. // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
    109. // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
    110. PORTB=0x00;
    111. DDRB=0x00;

    112. // Port C initialization
    113. // Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out 
    114. // State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0 
    115. PORTC=0x00;
    116. DDRC=0xFF;

    117. // Port D initialization
    118. // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=Out Func1=Out Func0=Out 
    119. // State7=T State6=T State5=T State4=T State3=T State2=0 State1=0 State0=0 
    120. PORTD=0x00;
    121. DDRD=0x3F;

    122. // Timer/Counter 0 initialization
    123. // clock1 source: System clock1
    124. // clock1 value: Timer 0 Stopped
    125. // Mode: Normal top=0xFF
    126. // OC0 output: Disconnected
    127. TCCR0=0x00;
    128. TCNT0=0x00;
    129. OCR0=0x00;

    130. // Timer/Counter 1 initialization
    131. // clock1 source: System clock1
    132. // clock1 value: Timer1 Stopped
    133. // Mode: Normal top=0xFFFF
    134. // OC1A output: Discon.
    135. // OC1B output: Discon.
    136. // Noise Canceler: Off
    137. // Input Capture on Falling Edge
    138. // Timer1 Overflow Interrupt: Off
    139. // Input Capture Interrupt: Off
    140. // Compare A Match Interrupt: Off
    141. // Compare B Match Interrupt: Off
    142. TCCR1A=0x00;
    143. TCCR1B=0x00;
    144. TCNT1H=0x00;
    145. TCNT1L=0x00;
    146. ICR1H=0x00;
    147. ICR1L=0x00;
    148. OCR1AH=0x00;
    149. OCR1AL=0x00;
    150. OCR1BH=0x00;
    151. OCR1BL=0x00;

    152. // Timer/Counter 2 initialization
    153. // clock1 source: System clock1
    154. // clock1 value: Timer2 Stopped
    155. // Mode: Normal top=0xFF
    156. // OC2 output: Disconnected
    157. ASSR=0x00;
    158. TCCR2=0x00;
    159. TCNT2=0x00;
    160. OCR2=0x00;

    161. // External Interrupt(s) initialization
    162. // INT0: Off
    163. // INT1: Off
    164. // INT2: Off
    165. MCUCR=0x00;
    166. MCUCSR=0x00;

    167. // Timer(s)/Counter(s) Interrupt(s) initialization
    168. TIMSK=0x00;

    169. // USART initialization
    170. // USART disabled
    171. UCSRB=0x00;

    172. // Analog Comparator initialization
    173. // Analog Comparator: Off
    174. // Analog Comparator Input Capture by Timer/Counter 1: Off
    175. ACSR=0x80;
    176. SFIOR=0x00;

    177. // ADC initialization
    178. // ADC clock1 frequency: 1000,000 kHz
    179. // ADC Voltage Reference: AREF pin
    180. // ADC Auto Trigger Source: ADC Stopped
    181. ADMUX=ADC_VREF_TYPE & 0xff;
    182. ADCSRA=0x83;

    183. // SPI initialization
    184. // SPI disabled
    185. SPCR=0x00;

    186. // TWI initialization
    187. // TWI disabled
    188. TWCR=0x00;

    189. while (1)
    190.       {
    191.       // Place your code here
    192.         SUHU = read_adc(7);//membaca data ADC dari PORTA.7
    193.         suhu_celcius = (int)(SUHU-1)/10;//rumus konversi ke derajat celcius
    194.         if (suhu_celcius>35)
    195.         {
    196.             suhu_celcius = suhu_celcius-1;//untuk kalibrasi sensor suhu (lihat datasheet LM35)
    197.         }
    198.         //ftoa(suhu_celcius,0,temp);
    199.         satuan = suhu_celcius%10;//rumus modulo untuk mengambil nilai data satuan
    200.         puluhan = (suhu_celcius/10)%10;//rumus modulo untuk mengambil nilai data puluhan
    201.         indikator();
    202.         if (puluhan==0)
    203.         {
    204.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    205.             {
    206.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    207.                 {
    208.                     
    209.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    210.                     {
    211.                         clock1();
    212.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    213.                         if(i==1)
    214.                         data_hi1;
    215.                         else
    216.                         data_lo1;
    217.                         PORTC = ~kosong[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    218.                         delay_us(50);//waktu tunda 50 microseconds
    219.                     }
    220.                     
    221.                 }
    222.             }
    223.         }
    224.         else if (puluhan==1)
    225.         {
    226.          for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    227.             {
    228.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    229.                 {
    230.                     
    231.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    232.                     {
    233.                         clock1();
    234.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    235.                         if(i==1)
    236.                         data_hi1;
    237.                         else
    238.                         data_lo1;
    239.                         PORTC = ~angka1[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    240.                         delay_us(50);//waktu tunda 50 microseconds
    241.                     }
    242.                     
    243.                 }
    244.             }
    245.         }
    246.         else if (puluhan==2)
    247.         {
    248.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    249.             {
    250.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    251.                 {
    252.                     
    253.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    254.                     {
    255.                         clock1();
    256.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    257.                         if(i==1)
    258.                         data_hi1;
    259.                         else
    260.                         data_lo1;
    261.                         PORTC = ~angka2[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    262.                         delay_us(50);//waktu tunda 50 microseconds
    263.                     }
    264.                     
    265.                 }
    266.             }
    267.         }
    268.         else if (puluhan==3)
    269.         {
    270.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    271.             {
    272.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    273.                 {
    274.                     
    275.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    276.                     {
    277.                         clock1();
    278.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    279.                         if(i==1)
    280.                         data_hi1;
    281.                         else
    282.                         data_lo1;
    283.                         PORTC = ~angka3[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    284.                         delay_us(50);//waktu tunda 50 microseconds
    285.                     }
    286.                     
    287.                 }
    288.             }
    289.         }
    290.         else if (puluhan==4)
    291.         {
    292.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    293.             {
    294.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    295.                 {
    296.                     
    297.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    298.                     {
    299.                         clock1();
    300.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    301.                         if(i==1)
    302.                         data_hi1;
    303.                         else
    304.                         data_lo1;
    305.                         PORTC = ~angka4[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    306.                         delay_us(50);//waktu tunda 50 microseconds
    307.                     }
    308.                     
    309.                 }
    310.             }
    311.         }
    312.         else if (puluhan==5)
    313.         {
    314.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    315.             {
    316.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    317.                 {
    318.                     
    319.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    320.                     {
    321.                         clock1();
    322.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    323.                         if(i==1)
    324.                         data_hi1;
    325.                         else
    326.                         data_lo1;
    327.                         PORTC = ~angka5[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    328.                         delay_us(50);//waktu tunda 50 microseconds
    329.                     }
    330.                     
    331.                 }
    332.             }
    333.         }
    334.         else if (puluhan==6)
    335.         {
    336.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    337.             {
    338.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    339.                 {
    340.                     
    341.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    342.                     {
    343.                         clock1();
    344.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    345.                         if(i==1)
    346.                         data_hi1;
    347.                         else
    348.                         data_lo1;
    349.                         PORTC = ~angka6[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    350.                         delay_us(50);//waktu tunda 50 microseconds
    351.                     }
    352.                     
    353.                 }
    354.             }
    355.         }
    356.         else if (puluhan==7)
    357.         {
    358.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    359.             {
    360.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    361.                 {
    362.                     
    363.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    364.                     {
    365.                         clock1();
    366.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    367.                         if(i==1)
    368.                         data_hi1;
    369.                         else
    370.                         data_lo1;
    371.                         PORTC = ~angka7[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    372.                         delay_us(50);//waktu tunda 50 microseconds
    373.                     }
    374.                     
    375.                 }
    376.             }
    377.         }
    378.         else if (puluhan==8)
    379.         {
    380.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    381.             {
    382.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    383.                 {
    384.                     
    385.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    386.                     {
    387.                         clock1();
    388.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    389.                         if(i==1)
    390.                         data_hi1;
    391.                         else
    392.                         data_lo1;
    393.                         PORTC = ~angka8[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    394.                         delay_us(50);//waktu tunda 50 microseconds
    395.                     }
    396.                     
    397.                 }
    398.             }
    399.         }
    400.         else if (puluhan==9)
    401.         {
    402.           for(x=0;x<1;x++)//mengulang pergeseran baris dot matrix
    403.             {
    404.                 for(a=0;a<5;a++)//mengulang baris dot matrix
    405.                 {
    406.                     
    407.                     for (i=0;i<=8;i++)//menggeser kolom dot matrix
    408.                     {
    409.                         clock1();
    410.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    411.                         if(i==1)
    412.                         data_hi1;
    413.                         else
    414.                         data_lo1;
    415.                         PORTC = ~angka9[i+x];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    416.                         delay_us(50);//waktu tunda 50 microseconds
    417.                     }
    418.                     
    419.                 }
    420.             }
    421.         }
    422.         else
    423.         {
    424.             PORTB=0x00;
    425.             PORTC=0x00;
    426.             PORTD=0x00;
    427.         }
    428.         if (satuan==0)
    429.         {
    430.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    431.             {
    432.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    433.                 {
    434.                     
    435.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    436.                     {
    437.                         clock2();
    438.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    439.                         if(j==1)
    440.                         data_hi2;
    441.                         else
    442.                         data_lo2;
    443.                         PORTC = ~angka1[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    444.                         delay_us(50);//waktu tunda 50 microseconds
    445.                     }
    446.                     
    447.                 }
    448.             }
    449.         }
    450.         else if (satuan==1)
    451.         {
    452.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    453.             {
    454.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    455.                 {
    456.                     
    457.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    458.                     {
    459.                         clock2();
    460.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    461.                         if(j==1)
    462.                         data_hi2;
    463.                         else
    464.                         data_lo2;
    465.                         PORTC = ~angka2[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    466.                         delay_us(50);//waktu tunda 50 microseconds
    467.                     }
    468.                     
    469.                 }
    470.             }
    471.         }
    472.         else if (satuan==2)
    473.         {
    474.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    475.             {
    476.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    477.                 {
    478.                     
    479.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    480.                     {
    481.                         clock2();
    482.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    483.                         if(j==1)
    484.                         data_hi2;
    485.                         else
    486.                         data_lo2;
    487.                         PORTC = ~angka3[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    488.                         delay_us(50);//waktu tunda 50 microseconds
    489.                     }
    490.                     
    491.                 }
    492.             }
    493.         }
    494.         else if (satuan==3)
    495.         {
    496.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    497.             {
    498.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    499.                 {
    500.                     
    501.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    502.                     {
    503.                         clock2();
    504.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    505.                         if(j==1)
    506.                         data_hi2;
    507.                         else
    508.                         data_lo2;
    509.                         PORTC = ~angka4[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    510.                         delay_us(50);//waktu tunda 50 microseconds
    511.                     }
    512.                     
    513.                 }
    514.             }
    515.         }
    516.         else if (satuan==4)
    517.         {
    518.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    519.             {
    520.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    521.                 {
    522.                     
    523.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    524.                     {
    525.                         clock2();
    526.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    527.                         if(j==1)
    528.                         data_hi2;
    529.                         else
    530.                         data_lo2;
    531.                         PORTC = ~angka5[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    532.                         delay_us(50);//waktu tunda 50 microseconds
    533.                     }
    534.                     
    535.                 }
    536.             }
    537.         }
    538.         else if (satuan==5)
    539.         {
    540.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    541.             {
    542.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    543.                 {
    544.                     
    545.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    546.                     {
    547.                         clock2();
    548.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    549.                         if(j==1)
    550.                         data_hi2;
    551.                         else
    552.                         data_lo2;
    553.                         PORTC = ~angka6[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    554.                         delay_us(50);//waktu tunda 50 microseconds
    555.                     }
    556.                     
    557.                 }
    558.             }
    559.         }
    560.         else if (satuan==6)
    561.         {
    562.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    563.             {
    564.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    565.                 {
    566.                     
    567.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    568.                     {
    569.                         clock2();
    570.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    571.                         if(j==1)
    572.                         data_hi2;
    573.                         else
    574.                         data_lo2;
    575.                         PORTC = ~angka7[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    576.                         delay_us(50);//waktu tunda 50 microseconds
    577.                     }
    578.                     
    579.                 }
    580.             }
    581.         }
    582.         else if (satuan==7)
    583.         {
    584.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    585.             {
    586.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    587.                 {
    588.                     
    589.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    590.                     {
    591.                         clock2();
    592.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    593.                         if(j==1)
    594.                         data_hi2;
    595.                         else
    596.                         data_lo2;
    597.                         PORTC = ~angka8[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    598.                         delay_us(50);//waktu tunda 50 microseconds
    599.                     }
    600.                     
    601.                 }
    602.             }
    603.         }
    604.         else if (satuan==8)
    605.         {
    606.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    607.             {
    608.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    609.                 {
    610.                     
    611.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    612.                     {
    613.                         clock2();
    614.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    615.                         if(j==1)
    616.                         data_hi2;
    617.                         else
    618.                         data_lo2;
    619.                         PORTC = ~angka9[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    620.                         delay_us(50);//waktu tunda 50 microseconds
    621.                     }
    622.                     
    623.                 }
    624.             }
    625.         }
    626.         else 
    627.         {
    628.             for(y=0;y<1;y++)//mengulang pergeseran baris dot matrix
    629.             {
    630.                 for(b=0;b<5;b++)//mengulang baris dot matrix
    631.                 {
    632.                     
    633.                     for (j=0;j<=8;j++)//menggeser kolom dot matrix
    634.                     {
    635.                         clock2();
    636.                         //PORTD = PORT[i];//inisialisasi keluaran PORT D = PORT dengan array i
    637.                         if(j==1)
    638.                         data_hi2;
    639.                         else
    640.                         data_lo2;
    641.                         PORTC = ~angka10[j+x+8];//inisialisasi PORT C sebagai negasi data1 dengan array i 
    642.                         delay_us(50);//waktu tunda 50 microseconds
    643.                     }
    644.                     
    645.                 }
    646.             }
    647.         }
    648.       }
    649. }
  6. Setelah dibuat programnya maka dilanjutkan ke perancangan rangkaiannya pada Proteus. Untuk komponen yang diperlukan dan desain rangkaiannya bisa dilihat pada gambar di bawah.
  7. Double kill pada ATmega16 untuk memasukan file programnya (*.coff atau *.hex).
  8. Jadi deh setelah diklik tombol play-nya.

Selamat mencoba... ;)
Semoga bermanfaat
Atas