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

Jumat, 30 Agustus 2019

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