SISTEM EMBEDDED

JAM DIGITAL

Oleh:
Dian Neipa P.

1110155002

Dosen Pengampu:
Akhmad Hendriawan, S.T., M.T.

PROGRAM STUDI D4 TEKNIK ELEKTRONIKA

DEPARTEMEN TEKNIK ELEKTRO
POLITEKNIK ELEKTRONIK NEGERI SURABAYA

Pendahuluan
Waktu sangat penting bagi kehidupan sehari-hari. Untuk dapat mengetahui waktu,
kita dapat menggunakan alam sekitar, dengan cara melihat arah dan posisi matahari. Namun
pada zaman yang modern ini, sudah ditemukan jam untuk mengetahui kapan waktu bekerja,
waktu pulang, waktu beribadah dan juga waktu untuk istirahat. Model jam ada dua yaitu,
jam analog dan jam digital. Jenisnya pun ada dua yaitu jam tangan dan jam dinding.
Jam adalah alat elektronika yang tidak asing untuk, karena sebagai alat penghitung
waktu yang telah di gunakan pada abad ke 14 atau sekitar 700 tahun yang lalu. Nama
tersebut berasal dari bahasa latin yang namanyaclocca. Cara orang dulu untuk
mengetahui waktu dengan menggunakan matahari dan mambagi dalam dua waktu, yang
pertama jika matahari tepat diatas kepala berarti tengah hari atau, dan ketika matahari
dekat dengan kaki langit berarti sudah waktunya dekat pagi atau malam. Jam tertua
bernama jam sundial atau biasanya disebut dengan jam matahari, pertama kali digunakan
sekitar 3.500 sebelum masehi, Ibnu Al-Shatir, Ahli Astronomi (777H atau 1375M)
menciptakan sebuah jam matahari untuk Masjid Jamik Umayyah di Damsyik. Ia dianggap
sebagai pencapaian tertinggi bagi penciptaan jam matahari.
Dengan begitu pentingnya waktu, maka dibutuhkan sebuah pengingat yang dapat
berfungsi secara otomatis dan terkontrol untuk mendukung aktivitas sehari-hari. Oleh sebab
itu dengan adanya jam digital mikrokontroler ini, diharapkan mampu mendukung aktivitas
sehari-hari, karena jam digital ini prinsip kerjanya otomatis, terkontrol dan terprogram
untuk berfungsi sebagai pengingat. Jam digital ini diatur oleh sebuah mikrokontroler yang
di dalamnya sudah terprogram menggunakan bahasa C++ dan hasilnya ditampilkan dalam
LCD.

Dasar Teori
1. ATmega 16
ATmega 16 merupakan seri mikrokontroler CMOS 8-bit buatan Atmel, berbasis
arsitektur RISC (Reduced Instruction Set Computer). Hampir semua instruksi dieksekusi
dalam satu siklus clock. ATMega16 mempunyai 32 register general-purpose,
timer/counter fleksibel dengan mode compare, interrupt internal dan eksternal, serial
UART, programmable Watchdog Timer, dan mode power saving, ADC dan PWM

internal. ATMega16 juga mempunyai In-System Programmable Flash on-chip yang

mengijinkan memori program untuk diprogram ulang dalam sistem menggunakan
hubungan serial SPI. ATMega16 mempunyai throughput mendekati 1 MIPS. Beberapa
fitur yang terdapat pada mikrokontroler Atmega16 antara lain:
1. High-performance, Low-power Atmel AVR 8-bit Microcontroller
2. Advanced RISC Architecture
-

131 Powerful Instructions Most Single-clock Cycle Execution

32 x 8 General Purpose Working Registers

Fully Static Operation

Up to 16MIPS Throughput at 16MHz

On-chip 2-cycle Multiplier

3. High Endurance Non-volatile Memory segments

-

16KBytes of In-System Self-programmable Flash program memory

512Bytes EEPROM

1KByte Internal SRAM

Write/Erase Cycles: 10,000 Flash/100,000 EEPROM

Data retention: 20 years at 85C/100 years at 25C

Optional Boot Code Section with Independent Lock Bits

In-System Programming by On-chip Boot Program

True Read-While-Write Operation

Programming Lock for Software Security

4. JTAG (IEEE std. 1149.1 Compliant) Interface

-

Boundary-scan Capabilities According to the JTAG Standard

Extensive On-chip Debug Support

Programming of Flash, EEPROM, Fuses, and Lock Bits through the JTAG Interface

5. Peripheral Features
-

Two 8-bit Timer/Counters with Separate Prescalers and Compare Modes

One 16-bit Timer/Counter with Separate Prescaler, Compare Mode, and Capture
Mode

Real Time Counter with Separate Oscillator

Four PWM Channels

8-channel, 10-bit ADC

8 Single-ended Channels

7 Differential Channels in TQFP Package Only

2 Differential Channels with Programmable Gain at 1x, 10x, or 200x

Byte-oriented Two-wire Serial Interface

Programmable Serial USART

Master/Slave SPI Serial Interface

Programmable Watchdog Timer with Separate On-chip Oscillator

On-chip Analog Comparator

6. Special Microcontroller Features

-

Power-on Reset and Programmable Brown-out Detection

Internal Calibrated RC Oscillator

External and Internal Interrupt Sources

Six Sleep Modes: Idle, ADC Noise Reduction, Power-save, Power-down, Standby
and Extended Standby

7. I/O and Packages

-

32 Programmable I/O Lines

40-pin PDIP, 44-lead TQFP, and 44-pad QFN/MLF

8. Operating Voltages
-

2.7 - 5.5V

9. Speed Grades
-

0 - 16MHz

10. Power Consumption @ 1MHz, 3V, and 25C

-

Active: 0.6mA

Idle Mode: 0.2mA

Power-down Mode: < 1A

Mikrokontroler yang digunakan pada project kali ini adalah ATmega 16A-AU

model TQFP. ATmega 16A-AU ini memiliki kaki sebanyak 44. Konfigurasi pin pada
ATmega16A-AU dapat dilihat pada gambar berikut.

Gambar 1. Konfigurasi Pin ATmega16A-AU

2. Timer
Timer/counter adalah fasilitas dari ATMega16 yang digunakan untuk perhitungan
pewaktuan. Beberapa fasilitas channel dari timer counter antara lain: counter channel
tunggal, pengosongan data timer sesuai dengan data pembanding, glitch-free, Pulse
Width Modulation (PWM), pembangkit frekuensi, event counter external. Jenis timer
yang diberikan oleh ATMega16 ada dua yaitu timer dengan resolusi 8-bit dan 16-bit.
Dalam project ini, digunakan timer0 yang memiliki resolusi 8 bit sebagai scanning seven
segment dan timer1 yang memiliki resolusi 16 bit sebagai sumber pewaktunya. Fiturfitur pada timer0 adalah sebagai berikut:
1. Single Compare Unit Counter
2. Clear Timer on Compare Match (Auto Reload)
3. Glitch-free, Phase Correct Pulse Width Modulator (PWM)
4. Frequency Generator
5. External Event Counter
6. 10-bit Clock Prescaler
7. Overflow and Compare Match Interrupt Sources (TOV0 and OCF0)
Diagram blok dari Timer/counter 8 bit ini terlihat seperti pada gambar berikut.

Gambar 2. Diagram Blok Timer/Counter 8 Bit

Sedangkan fitur-fitur pada timer1 adalah sebagai berikut:
1. True 16-bit Design (i.e., Allows 16-bit PWM)
2. Two Independent Output Compare Units
3. Double Buffered Output Compare Registers
4. One Input Capture Unit
5. Input Capture Noise Canceler
6. Clear Timer on Compare Match (Auto Reload)
7. Glitch-free, Phase Correct Pulse Width Modulator (PWM)
8. Variable PWM Period
9. Frequency Generator
10. External Event Counter
11. Four Independent Interrupt Sources (TOV1, OCF1A, OCF1B, and ICF1)
Diagram blok dari Timer/counter 16 bit ini terlihat seperti pada gambar berikut.

Gambar 3. Diagram Blok Timer/Counter 16 Bit

3. LCD (Liquid Crystal Display)
Liquid Crystal Display (LCD) adalah sebuah peralatan elektronik yang berfungsi
untuk menampilkan output sebuah sistem dengan cara membentuk suatu citra atau
gambaran pada sebuah layar. Secara garis besar komponen penyusun LCD terdiri dari
kristal cair (liquid crystal) yang diapit oleh 2 buah elektroda transparan dan 2 buah
filter polarisasi (polarizing filter). Sebuah citra dibentuk dengan mengkombinasikan
kondisi nyala dan mati dari pixel-pixel yang menyusun layar sebuah LCD. Pada
umumnya LCD yang dijual di pasaran sudah memiliki integrated circuit tersendiri
sehingga para pemakai dapat mengontrol tampilan LCD dengan mudah dengan
menggunakan mikrokontroler untuk mengirimkan data melalui pin-pin input yang
sudah tersedia.LCD yang ada dipasaran dikategorikan menurut jumlah baris yang dapat
digunakan pada LCD yaitu 1 baris , 2 baris , dan 4 baris yang dapat digunakan hingga
80 karakter. Umumnya LCD yang digunakan adalah LCD dengan 1 controller yang
memiliki 14 pin.
Perancangan dan Analisa Program
Pada makalah ini akan membahas mengenai analisis dan implementasi dari
algoritma jam digital menggunakan Atmega16 untuk membuat sebuah alarm menggunakan

kombinasi dua buah push button. Digunakan dua buah pushbutton sebagai tombol mode
dan tombol advance. Fitur yang disediakan pada jam digital yang akan dibuat adalah ubah
jam, ubah menit, ubah detik, dan alarm. Untuk membangkitkan jam digital berupa jam,
menit dan detik digunakan sebuah timer dengan konfigurasi seperti berikut:
void SCH_init(unsigned int periode)
{
TCNT1=0;
// reset counter
OCR1A=(unsigned long) periode*1000/64; // delayms
TCCR1B |=(1<<WGM12); //mode ctc
TCCR1B |=(1<<CS12)|(1<<CS10); //prescaller 1024
TIMSK |= (1<<OCIE1A);
//enable interupt timer
Task_Init();
}

Konfigurasi timer menggunakan mode CTC dengan clock select pada prescaller
1024. Parameter TCNT disetting 0 sebagai reset counter. Agar user dapat sewaktu-waktu
mengganti tampilan jam menit maupun detik maka pada parameter OC1E1A diberi logika 1
untuk mengaktifkan interrupt timer.
case tampil:
{
_jam();
lcd_gotoxy(1,0); lcd_putstr(" ");
//button Mode ditekan
if (!isCheckPIN(btnMode))
debounceMode=(debounceMode<<1);
else debounceMode= (debounceMode<<1)|1;
if (debounceMode==0b11111100)
state=ubah_jam;
break;
}
case ubah_jam:
{
unsigned int da=0;
display_jam();
lcd_gotoxy(1,0); lcd_putstr("Ubah Jam");
//button Mode ditekan
if (!isCheckPIN(btnMode))
debounceMode=(debounceMode<<1);
else debounceMode= (debounceMode<<1)|1;
if (debounceMode==0b11111100)
state=ubah_menit;
//button Advance ditekan
if (!isCheckPIN(btnAdvance))
{debounceAdvance=(debounceAdvance<<1);}
else debounceAdvance= (debounceAdvance<<1)|1;
if (debounceAdvance==0b11111100) update_jam1();
if (debounceAdvance==0b00000011) update_jam10();
break;
}

Secara keseluruhan cara kerja program jam digital dapat dilihat dalam listing
program diatas, ketika pertama kali dinyalakan program akan menuju state tampil dan akan
menampilkan jam dengan tampilan 0:0:0. Selanjutnya user dapat mengatur jam menit
maupun detik dengan menekan tombol mode. Ketika tombol mode ditekan, program akan
menuju state ubah jam dan pada LCD akan muncul tampilan Ubah Jam. Untuk mengubah
pengaturan jam digunakan tombol advance untuk menambahkan jam sesuai keinginan. Jika
tombol advance ditekan satu kali maka menambahkan jam sebanyak 1 jam, sedangkan jika
tombol advance ditekan lebih lama maka program akan menambahkan jam dengan
kelipatan 10 untuk mempermudah user melakukan pengaturan jam. Untuk mengganti
pengaturan pada state ubah menit maka user hanya perlu menekan tombol mode sekali,
begitupun dengan ubah menit.
Daftar Pustaka
https://mnurudin47.wordpress.com/2014/12/16/jam-digital/ (diakses 12 Juni 2016)

Lampiran
sEOS.h
#ifndef _SEOS_H
#define _SEOS_H
void
void
void
void
void
void
void
void
void

SCH_init(unsigned int periode);

system_update (void);
display_jam (void);
update_jam1 (void);
update_jam10 (void);
update_menit1 (void);
update_menit10 (void);
update_detik1 (void);
update_detik10 (void);

#endif

sEOS.c
#include "sEOS.h"
#include "task.h"
#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>
#include "device.h"
#include "utility.h"
#include "lcd.h"
#include "stdio.h"
//#include "button.h"
// global variable
volatile uint8_t jam = 0;
volatile uint8_t menit = 0;
volatile uint8_t detik = 0;
volatile uint8_t count = 0;
unsigned char buff[50];
ISR (TIMER1_COMPA_vect)
{
Task_Run();
system_update();
}
void SCH_init(unsigned int periode)
{
TCNT1=0;
// reset counter
OCR1A=(unsigned long) periode*1000/64; // delayms
TCCR1B |=(1<<WGM12); //mode ctc
TCCR1B |=(1<<CS12)|(1<<CS10); //prescaller 1024
TIMSK |= (1<<OCIE1A);
//enable interupt timer
Task_Init();
}
void system_update (void)
{
if (++count>6)
{
count =0;

if (++detik>=60)

{detik=0; ++menit;lcd_clear();}

if (menit>=60)

{menit=0; ++jam;lcd_clear();}

if (jam>=24)

{jam=0;lcd_clear();}

}
void update_jam1 (void)
{jam++; if (jam>=24){jam=0;lcd_clear();} }
void update_jam10 (void)
{jam+=10; if (jam>=24){jam=0;lcd_clear();}}
void update_menit1 (void)
{menit++; if (menit>=60) {menit=0; ++jam;lcd_clear();}}
void update_menit10 (void)
{menit += 10; if (menit>=60) {menit=0;++jam;lcd_clear();}}
void update_detik1 (void)
{detik++; if (++detik>=60) {detik=0;++menit;lcd_clear();}}
void update_detik10 (void)
{detik +=10; if (++detik>=60) {detik=0;++menit;lcd_clear();}}
void display_jam (void)
{
lcd_gotoxy(0,0);
sprintf (buff,"%d:%d:%d",jam,menit,detik);
lcd_putstr(buff);
// lcd_putstr("HELLO");
}

LCD.h
#ifndef _LCD_H
#define _LCD_H
#include <avr/io.h>
#include <util/delay.h>
//LCD interface
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define

PORT_LCD
PORTB
DDR_LCD
DDRB
RS
PB0
RW
PB1
EN
PB2
DB4
PB4
DB5
PB5
DB6
PB6
DB7
PB7
SETBIT(address,bit) (address |= (1<<bit))
CLRBIT(address,bit) (address &= ~(1<<bit))
SET_EN SETBIT(PORT_LCD,EN)
CLR_EN CLRBIT(PORT_LCD,EN)
SET_RS SETBIT(PORT_LCD,RS)
CLR_RS CLRBIT(PORT_LCD,RS)
SET_RW SETBIT(PORT_LCD,RW)
CLR_RW CLRBIT(PORT_LCD,RW)

// prototipe fungsi
void enable(void);
// enable fulse for LCD
void lcd_init(void);
// intialization LCD
void lcd_putchar(unsigned char c); // send character to LCD
void lcd_putstr(char *s);
// send string to LCD
void lcd_clear(void);
// clear display
void lcd_gotoxy(unsigned char i,unsigned char j); //move LCD cursor
position
#endif

LCD.c
#include "lcd.h"
/********************************************************************/
/* Function
: void enable(void)
*/
/*------------------------------------------------------------------*/
/* Description : This subroutine send Pulse to activate LCD
*/
/*------------------------------------------------------------------*/
/* Author
: Akhmad Hendriawan
*/
/*------------------------------------------------------------------*/
/* Input
:
*/
/*------------------------------------------------------------------*/
/* Returnvalue :
*/
/*------------------------------------------------------------------*/
/* History
: 2 December 2008
*/
/*
*/
/********************************************************************/
void enable(void) {
SET_EN;
_delay_ms(3);
CLR_EN;
}

// minimal 2ms don't follow databook ;((450ns)<--

/********************************************************************/
/* Function
: void lcd_init(void)
*/
/*------------------------------------------------------------------*/
/* Description : This subroutine initialization LCD
*/
/*------------------------------------------------------------------*/
/* Author
: Akhmad Hendriawan
*/
/*------------------------------------------------------------------*/
/* Input
:
*/
/*------------------------------------------------------------------*/
/* Returnvalue :
*/
/*------------------------------------------------------------------*/
/* History
: 2 December 2008
*/
/*
*/
/********************************************************************/
void lcd_init(void)
{
DDR_LCD=0xFF;
// enable output for LCD
CLR_EN;
_delay_ms(15);
//step1
PORT_LCD=0x30;CLR_RS;CLR_RW;enable();
_delay_ms(5);
// step2

PORT_LCD=0x30;CLR_RS;CLR_RW;enable();
_delay_ms(1);
// step3
PORT_LCD=0x30;CLR_RS;CLR_RW;enable();
//next init
PORT_LCD=0x20;CLR_RS;CLR_RW;enable();
PORT_LCD=0x20;CLR_RS;CLR_RW;enable();
PORT_LCD=0x80;CLR_RS;CLR_RW;enable();
PORT_LCD=0x00;CLR_RS;CLR_RW;enable();
PORT_LCD=0xE0;CLR_RS;CLR_RW;enable();
PORT_LCD=0x00;CLR_RS;CLR_RW;enable();
cursor shift right
PORT_LCD=0x60;CLR_RS;CLR_RW;enable();
PORT_LCD=0x00;CLR_RS;CLR_RW;enable();
PORT_LCD=0x10;CLR_RS;CLR_RW;enable();
}

// display on
// entry mode address inc and
// display clear
// display clear

/********************************************************************/
/* Function
: void lcd_putchar(unsigned char kar)
*/
/*------------------------------------------------------------------*/
/* Description : This subroutine send character to LCD
*/
/*------------------------------------------------------------------*/
/* Author
: Akhmad Hendriawan
*/
/*------------------------------------------------------------------*/
/* Input
: character
*/
/*------------------------------------------------------------------*/
/* Returnvalue :
*/
/*------------------------------------------------------------------*/
/* History
: 3 December 2008
*/
/*
*/
/********************************************************************/
void lcd_putchar(unsigned char kar)
{
unsigned char kar2;
//kar2=(kar|(PORT_LCD&0x0F))& (PORT_LCD|0xF0); //save control in bit
0-3
//kar2= (kar & 0xF0) + (PORT_LCD &0x0F);
//CLRBIT(kar2,EN);
kar2=kar & 0xF0;
PORT_LCD=kar2;SET_RS;CLR_RW;enable(); //
kar=(kar<<4|kar>>4);
kar2 = kar & 0xF0;
PORT_LCD=kar2;SET_RS;CLR_RW;enable(); // display clear
}
/********************************************************************/
/* Function
: void lcd_putstr(char *s)
*/
/*------------------------------------------------------------------*/
/* Description : This subroutine send string to LCD
*/
/*------------------------------------------------------------------*/
/* Author
: Akhmad Hendriawan
*/
/*------------------------------------------------------------------*/
/* Input
: String
*/
/*------------------------------------------------------------------*/
/* Returnvalue :
*/
/*------------------------------------------------------------------*/
/* History
: 2 December 2008
*/
/*
*/
/********************************************************************/

void lcd_putstr(char *s)

{
char i=0;
char c;
while((c=*(s+(i++)))!=0)
lcd_putchar(c);
}
/********************************************************************/
/* Function
: void lcd_clear(void)
*/
/*------------------------------------------------------------------*/
/* Description : This subroutine clear LCD display
*/
/*------------------------------------------------------------------*/
/* Author
: Akhmad Hendriawan
*/
/*------------------------------------------------------------------*/
/* Input
:
*/
/*------------------------------------------------------------------*/
/* Returnvalue :
*/
/*------------------------------------------------------------------*/
/* History
: 2 December 2008
*/
/*
*/
/********************************************************************/
void lcd_clear(void)
{
PORT_LCD=0x00;CLR_RS;CLR_RW;enable(); // display clear
PORT_LCD=0x10;CLR_RS;CLR_RW;enable(); //
}
/********************************************************************/
/* Function
: void lcd_gotoxy(unsigned char i,unsigned char j)
*/
/*------------------------------------------------------------------*/
/* Description : This subroutine set address for write LCD
*/
/*------------------------------------------------------------------*/
/* Author
: Akhmad Hendriawan
*/
/*------------------------------------------------------------------*/
/* Input
: row,coloumn
*/
/*------------------------------------------------------------------*/
/* Returnvalue :
*/
/*------------------------------------------------------------------*/
/* History
: 3 December 2008
*/
/*
*/
/********************************************************************/
void lcd_gotoxy(unsigned char i,unsigned char j)
{
unsigned char posisi,kar2;
posisi=(i*0x40)+j;
//posisi=(i>0?0x40+j:j);
kar2= posisi & 0xF0;
PORT_LCD=kar2;SETBIT(PORT_LCD,DB7);
CLR_RS;CLR_RW;enable();
posisi= (posisi<<4)|(posisi>>4);
// swap temp
kar2= posisi & 0xF0;
PORT_LCD=kar2;
CLR_RS;CLR_RW;enable();
}

Task.h

#ifndef _TASK_H
#define _TASK_H
#include "device.h"
#include <avr/io.h>
#define YES
#define NO
0
void Task_Init(void);
void Task_Run(void);
#endif

Task.c
#include <util/delay.h>
#include <avr/io.h>
#include "task.h"
#include "device.h"
#include "utility.h"
#include "lcd.h"
#include "sEOS.h"
//#include "button.h"
//Private variable----------------------enum state {tampil, ubah_jam, ubah_menit, ubah_detik} state;
unsigned char debounceMode=0xFF;
unsigned char debounceAdvance=0xFF;
unsigned char buff[50];
//Private task ----------------------void Task_Init(void)
{
SETInputPullup(btnMode);
SETInputPullup(btnAdvance);
state=tampil;
}
void Task_Run(void)
{
switch(state)
{
case tampil:
{
display_jam();
lcd_gotoxy(1,0); lcd_putstr("
//button Mode ditekan
if (!isCheckPIN(btnMode))
debounceMode=(debounceMode<<1);
else debounceMode= (debounceMode<<1)|1;
if (debounceMode==0b11111100) state=ubah_jam;

");

break;
}
case ubah_jam:
{
unsigned int da=0;
display_jam();
lcd_gotoxy(1,0); lcd_putstr("Ubah Jam");
//button Mode ditekan

if (!isCheckPIN(btnMode))
debounceMode=(debounceMode<<1);
else debounceMode= (debounceMode<<1)|1;
if (debounceMode==0b11111100) state=ubah_menit;
//button Advance ditekan
if
(!isCheckPIN(btnAdvance))
{debounceAdvance=(debounceAdvance<<1);}
else
debounceAdvance= (debounceAdvance<<1)|1;
if
(debounceAdvance==0b11111100)
update_jam1();
if
(debounceAdvance==0b00000011)
update_jam10();
}

break;

case ubah_menit:
{
display_jam();
lcd_gotoxy(1,0); lcd_putstr("Ubah Menit");
//button Mode ditekan
if (!isCheckPIN(btnMode))
debounceMode=(debounceMode<<1);
else debounceMode= (debounceMode<<1)|1;
if (debounceMode==0b11111100) state=ubah_detik;
//button Advance ditekan
if
(!isCheckPIN(btnAdvance))
{debounceAdvance=(debounceAdvance<<1);}
else
debounceAdvance= (debounceAdvance<<1)|1;
if
(debounceAdvance==0b11111100)
update_menit1();
if
(debounceAdvance==0b00000011)
update_menit10();
break;
}
case ubah_detik:
{
display_jam();
lcd_gotoxy(1,0); lcd_putstr("Ubah Detik");
//button Mode ditekan
if (!isCheckPIN(btnMode))
debounceMode=(debounceMode<<1);
else debounceMode= (debounceMode<<1)|1;
if (debounceMode==0b11111100) state=tampil;
//button Advance ditekan
if
(!isCheckPIN(btnAdvance))
{debounceAdvance=(debounceAdvance<<1);}
else
debounceAdvance= (debounceAdvance<<1)|1;
if
(debounceAdvance==0b11111100)
update_detik1();
if
(debounceAdvance==0b00000011)
update_detik10();

}
}

break;

Device.h
#ifndef DEVICE_H_
#define DEVICE_H_
//DeviceIO
#define ledBar PORTA
#define pushButton1 C,0
#define pushButton2 C,1
#define pushButton3 C,2
#define pushButton4 C,3
#define ledDebug
C,4
#define ledHijau
C,5
#define buzzer
C,6
//custom
#define
#define
#define
#define
#define

btnMode
pushButton1
btnAdvance pushButton2
ledRED
A,0
ledYellow
A,2
ledGreen
A,4

#endif /* DEVICE_H_ */

Utility.h
#ifndef UTILITY_H_
#define UTILITY_H_
//utility
#define checkbit(address,bit) (address & (1<<bit))
#define setbit(address,bit) (address |=(1<<bit))
#define clrbit(address,bit) (address &=~(1<<bit))
#define flipbit(address,bit) (address ^=(1<<bit))
//temporary
#define _set(address,bit) (PORT##address |=(1<<bit))
#define _clr(address,bit) (PORT##address &=~(1<<bit))
#define _flip(address,bit) (PORT##address ^=(1<<bit))
#define _setInputPullup(address,bit) (DDR##address &=~(1<<bit));
(PORT##address |=(1<<bit))
#define _setOutput(address,bit) (DDR##address |=(1<<bit))
#define _Checkbit2(address,bit) (PIN##address &(1<<bit))
//final
#define SET(address) _set(address)
#define CLR(address) _clr(address)
#define FLIP(address) _flip(address)
#define SETInputPullup(address) _setInputPullup(address)
#define SETOutput(address)_setOutput(address)
#define isCheckPIN(x) _Checkbit2(x)
//end utility
#endif /* UTILITY_H_ */

Main.c
#include <avr/interrupt.h>

#include <avr/sleep.h>
#include "task.h"
#include "sEOS.h"
#include "lcd.h"
#include "device.h"
#include "utility.h"
//#include "button.h"
int main(void)
{
Task_Init();
// button_init();
SCH_init(10);
lcd_init();
sei();
while(1)
{sleep_mode();}
return 0;
}