6-Digit 7-Segment Display ์ง๋ ์๊ฐ์ ์๋์ด๋ ธ ์๊ณ๋ฅผ ์ ์ํ์ฌ ๊ฐ์ ์คํ์ ํ์์ต๋๋ค. ๊ทธ๋ฐ๋ฐ ์๋์ด๋ ธ ์๊ณ์ ์ด๊ธฐ๊ฐ์ PC ์๋ฆฌ์ผ๋ชจ๋ํฐ์์ ์๊ฐ์ ์ ๋ ฅํ๋๊ฒ ์ข ๋ถํธํด ๋ณด์ฌ์ ๋ค๋ฅธ ์ธ๋ถ ์ฅ์น๋ก ์๊ฐ์ ์ ๋ ฅํ๋ ๋ฐฉ๋ฒ์ด ์์๊น ๊ณ ๋ฏผํ๋ค๊ฐ ๋ฌด์ ์ผ๋ก ์๊ฐ๊ฐ์ ์ ๋ ฅํ๋ ๋ฐฉ๋ฒ์ ์์ํ๋ค๊ฐ ๋ช๊ฐ์ง ์์ํ ๋ฐฉ๋ฒ ์ค์ ๋ฆฌ๋ชจ์ฝ์ผ๋ก ์๊ฐ์ ์ ๋ ฅํด๋ณผ๊น ํ๋ ํธ๊ธฐ์ฌ์ด ์๊ฒจ์ ์ข์ ํ์ต ์๋ฃ๊ฐ ๋ ๊ฒ ๊ฐ์์ ๋ฆฌ๋ชจ์ฝ์ผ๋ก ์๋์ด๋ ธ ์๊ฐ๊ฐ์ ์ ๋ ฅํ๋ ์คํํ๊ฒ ๋์๋ค์. ๋ฆฌ๋ชจ์ฝ์ผ๋ก ์๊ฐ์ ์ ๋ ฅํ๋๋ฐ ๊ทธ ์ ๋ ฅ๋ ์๊ฐ์ ๋ฆฌ๋ชจ์ฝ์ด ๋๋ฅผ๋ ์ซ์๊ฐ ๋ณ๊ฒฝ๋๊ณ ๊ทธ ๊ฐ์ด 6-Digit 7-Segment Display ๋ถํ์ ์ถ๋ ฅ๋๊ฒ ํด์ผ ํ๋๋ฐ 6๊ฐ์ 7-Segment Display์ ๊ฐ๊ฐ ๊ฐ๋ณ์ ์ผ๋ก 6๊ฐ์ ์ซ์๋ฅผ ๊ฐฑ์ ํ๊ฒ ํ ์ง ์๋๋ฉด ์/๋ถ/์ด ๋จ์๋ก 3๊ฐ์ ์ซ์๋ก ๋ฆฌ๋ชจ์ฝ์ผ๋ก ์ ์ดํด์ 3๊ฐ์ ์ซ์๊ฐ์ ์ถ๋ ฅํด์ผ ํ ์ง ์๋๋ฉด ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ์๊ฐ ์ซ์๋ฅผ ์ ์ดํ ์ง ์ฌ๋ฌ๊ฐ๋ฅผ ๊ณ ๋ฏผํ๊ณ ์คํํด ๋ณด์์ต๋๋ค. ๊ทธ์ค ํ๋๋ฅผ ์ ํํ์ฌ post๋ก ์๊ฐ ํฉ๋๋ค.
์ง๋ ์๊ฐ์ ํ๋ก๋์์ ์ค์์น๋ฒํดํ์ผ๋ก ์ฌ์ฉํ 2๋ฒํ์ IR Sensorํ์ผ๋ก ์ฌ์ฉํ์ต๋๋ค. ์์ ๋ถ๋ถ์ IR Sensor ํ๋ง ๋ณ๊ฒฝํด์ฃผ์๋ฉด ๋ฉ๋๋ค.
๋ฆฌ๋ชจ์ฝ ์ ์ด๋ฅผ ๊ฐ๋จํ ๋ณต์ต์ ํด ๋ณผ๊น์.
[IRemote]
#include
int IRpin = 2; // IR Sensor Pin
IRrecv irrecv(IRpin);
decode_results results;
void setup(){
irrecv.enableIRIn(); // ๋ฆฌ๋ชจ์ฝ ์์
}
void loop(){
if (irrecv.decode(&results)){ //๋ฆฌ๋ชจ์ฝ ๋๋ฅธ๊ฐ์ด ์๋ค๋ฉด ํจ์ค
//results.value ๋ก ๋ฆฌ๋ชจ์ฝ์ด ๋๋ฆฐ ๊ฐ์ด ๋ค์ด ์์.
irrecv.resume(); // ๋ค์๊ฐ
}
}
๋ช๋ฌ ์ post์ ๋ด์ฉ์ธ๋ฐ ์ค๋ซ๋ง์ ๋ฆฌ๋ชจ์ฝ์ ์๋์ด๋ ธ ์๊ณ์ ์ ์ฉํฉ๋๋ค. ์ฐธ๊ณ ๋ก IRremote ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น๋ ์ฌ์ ํ์ต์ ๊ฐ์๋ฉด ๋์ ์์ผ๋๊น ๋ณด์๊ณ ์ค์นํ ๋ค์ ์ฌ์ฉํ์ธ์. ํน์ ์์ ๊ฐ์ด ์ฝ๋ฉํ๋๋ฐ ์๋์ ์ํ๋ฉด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ธํ์๊ณ ์ค์นํ์๋ฉด ๋ฉ๋๋ค.
์ ๊ทธ๋ฆผ์ ๋ฆฌ๋ชจ์ฝ์ ๋ฒํด 4๊ฐ๋ฅผ ์ฌ์ฉํ ์์ ์ ๋๋ค.
๊ฐ์์๋ฎฌ๋ ์ดํฐ๋ก ์ฌ์ ํ์ต์ ํ๋ก๋์ ํค๊ฐ ํ์ธ ์์ค๋ฅผ ๋๋ฅด์๋ฉด ํด๋น results.value์ ํ์ธ ํ ์ ์์ต๋๋ค.
์ ์ฝ๋ฉ์์
Serial.println(results.value);
์ด๋ ๊ฒ ํด์ ๋ฆฌ๋ชจ์ฝ์ ํด๋น ํค๊ฐ์ ์๋ฆฌ์ผ๋ชจ๋ํฐ๋ก ํ์ธ ํ ๋ค์ ๊ธฐ๋กํด ์ฃผ์ธ์.
#define STATE 16597183 //FUNC/STOP
#define SELECT_TIME 16609423 //ST/REPT
#define TIME_UP 16601263 //์ธ๋ชจ UP
#define TIME_DOWN 16584943 //์ธ๋ชจ DOWN
์ฐธ๊ณ ๋ก, ์ค์ ๋ก ์คํํ์ค ๋๋ ๋ฆฌ๋ชจ์ฝ ํค๊ฐ์ ์ง์ ๋๋ฅด์๊ณ ํด๋น ํค ๊ฐ์ ๋ฉ๋ชจ์ฅ์ ๊ธฐ๋กํ๋ค๊ฐ ์์ฒ๋ผ ํํํ์๋ฉด ๋ฉ๋๋ค. ๋ฆฌ๋ชจ์ฝ ์ข ๋ฅ์ ๋ฐ๋ผ ํค ๊ฐ์ด ๋ค๋ฅผ ์ ์์์ผ๋ก ๊ผญ ์ฌ์ ์ ํค๊ฐ์ ํ์ธํ์๊ณ ์ฝ๋ฉํด ์ฃผ์ธ์.
์๊ฐ์ ์ ๋ ฅ๋ฐ์์ง ๊ฒฐ์ ํด์ผ ํฉ๋๋ค. ์ํ๋ณ์๋ฅผ ํ๋ ๋ง๋ค์ด์ ์๋์ ๊ฐ์ด IF ์กฐ๊ฑด๋ฌธ์ ๋ง๋ค๋ฉด ๋ฉ๋๋ค.
if (irrecv.decode(&results)) //๋ฆฌ๋ชจ์ฝ ๋๋ฅธ๊ฐ์ด ์๋ค๋ฉด ํจ์ค
{
if(results.value==STATE){
output=!output;
}
}
FUNC/STOP ๋ฆฌ๋ชจ์ฝ ๋ฒํด์ ๋๋ฅด๋ฉด output๊ฐ true or false ๊ต๋๋ก ์ํ๊ฐ์ ๊ฐ๊ฒ ๋ฉ๋๋ค. output๊ฐ true๋ฉด ์๊ฐ ์ ๋ ฅ์ด๊ณ false๋ฉด ์ ๋ ฅ๋ ์๊ฐ์ด ํ๋ฌ๊ฐ๊ฒ ํ๋ ์ฝ๋ฉ์ ํ๊ฒ ์ต๋๋ค.
if(๋ฆฌ๋ชจ์ฝํค๊ฐ==STATE){
output=!output;
if(output==false){
timer0_millis ์๊ฐ ์ค์ ;
}
else{
์๊ฐ ์ ์
๋ ฅ ์ด๊ธฐํ;
}
}
if(output==true){
์๊ฐ ์
๋ ฅ;
}
์ฝ๋ฉ์ ํ๋ฉด,
if (irrecv.decode(&results)) //๋ฆฌ๋ชจ์ฝ ๋๋ฅธ๊ฐ์ด ์๋ค๋ฉด ํจ์ค
{
if(results.value==STATE){ //์๊ฐ ์
๋ ฅ ๊ฒฐ์
output=!output;
if(output==false){ //๋ฆฌ๋ชจ์ฝ์ผ๋ก ์/๋ถ/์ด ์
๋ ฅํ ๊ฐ์ ํ์ด๋จธ๋ณ์์ ์ ์ฅ;
hour = clockVal[2];
min = clockVal[1];
sec = clockVal[0];
timer0_millis = ((long)hour*3600+min*60+sec)*1000;
}
else{ //์๊ฐ ์
๋ ฅ ์ ์
๋ ฅ ๋ณ์์ ์ด๊ธฐํ
selectVal=0;
for(int i=0;i<3;i++){
clockVal[i]=0;
}
}
}
if(output==true){ //์๊ฐ ์
๋ ฅ ์ ์ด
์๊ฐ์
๋ ฅ;
}
irrecv.resume(); // ๋ค์๊ฐ
}
}
clockVal[3]์ hour, min, sec์ ๊ฐ์ ์ ์ฅํ๊ฒ ๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ selectVal์ ์/๋ถ/์ด์ ์์น๋ฅผ ๋ํ๋ ๋๋ค.
if(results.value==SELECT_TIME){ //์/๋ถ/์ด ์์น ์ ํ
selectVal++;
if(selectVal==3)selectVal=0;
}
ST/REPT๋ฅผ ๋๋ฅผ ๋ ์/๋ถ/์ด๊ฐ selectVal์ด 0์ด๋ฉด sec์ด๊ณ , 1์ด๋ฉด min, 2์ด๋ฉด hour๋ฅผ ๊ฐ๋ฆฌํต๋๋ค. selectVal๊ฐ 3์ด ๋๋ฉด ๋ค์ 0์ผ๋ก ์ด๊ธฐํ๋ฉ๋๋ค. ํด๋น ๋ฆฌ๋ชจ์ฝ์ ํค ๋ฒํด์ ํตํด ์/๋ถ/์ด ์์น๊ฐ์ ์ง์ ํ ์ ์๊ฒ ๋ฉ๋๋ค.
์ด์ ์ธ๋ชจ UP/DOWN ๋ฒํด์ ํตํด์ ์๊ฐ๊ฐ์ ์ฆ๊ฐ/๊ฐ์๋ฅผ ์ ์ด๋ฅผ ํด ๋ณผ๊น์.
if(results.value==TIME_UP) clockVal[selectVal]++; //์๊ฐ๊ฐ ์ฆ๊ฐ
else if(results.value==TIME_DOWN) clockVal[selectVal]--; //์๊ฐ๊ฐ ๊ฐ์
"clockVal[selectVal]++" or "clockVal[selectVal]--"๋ก ์/๋ถ/์ด ๊ฐ์ ์ฆ๊ฐ/๊ฐ์๋ฅผ ์ํค๊ฒ ๋ฉ๋๋ค. ์ฌ๊ธฐ์, ์๊ฐ์ 24์, ๋ถ์ 60๋ถ, ์ด๋ 60์ด๊ฐ max ๊ฐ์ ๋๋ค. ๊ทธ๋์ ์ฆ๊ฐํ ๋ ์ซ์๋ ์๊ฐ์ 24์๋ฅผ ๋์ง ๋ง์์ผ ํ๊ณ ๋ถ/์ด๋ 60์ ๋์ง ๋ง์์ผ ํฉ๋๋ค.
๊ทธ ๋ถ๋ถ์ IF๋ฌธ์ผ๋ก ํํ์ ํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
if(selectVal==2){ //hour ์ผ๋
if(clockVal[selectVal]==24)clockVal[selectVal]=0;
else if(clockVal[selectVal]==-1)clockVal[selectVal]=23;
}
else{ //min, sec ์ผ๋
if(clockVal[selectVal]==60)clockVal[selectVal]=0;
else if(clockVal[selectVal]==-1)clockVal[selectVal]=59;
}
selectVal๊ฐ 2์ด๋ฉด ์๊ฐ์ด๋๊น IF๋ฌธ์์ 24๊ฐ ๋๋ฉด clockVal[selectVal]์ผ๋ก 0์ผ๋ก ๋ง๋ค๊ณ ๊ฐ์ํ ๋ -1์ด ๋๋ฉด 23์ผ๋ก ๋ง๋ค์ด ์ฃผ๋ฉด 0~23์๊ฐ ์กฐ์ ํ๋ฉด ๋ฉ๋๋ค
๊ทธ๋ฆฌ๊ณ ๊ทธ์ธ 0~1์ด๋ฉด ๋ถ/์ด๋ก 60์ด max์ด๋๊น IF๋ฌธ์ผ๋ก 60์ด๋ฉด clockVal[selectVal]์ผ๋ก 0์ผ๋ก ๋ง๋ค๊ณ ๊ฐ์ํ ๋ -1์ด ๋๋ฉด 59์ผ๋ก ๋ง๋ค์ด ์ฃผ๋ฉด 0~59๋ถ/์ด๋ฅผ ์กฐ์ ํ๋ฉด ๋ฉ๋๋ค
if(output==false){ //์๊ฐ ์ถ๋ ฅ
readTime = millis()/1000;
if(millis()>=86400000){
timer0_millis=0;
}
sec = readTime%60;
min = (readTime/60)%60;
hour = (readTime/(60*60))%24;
segOutput(5,sec%10,0); //sec 1์ ์๋ฆฌ
segOutput(4,sec/10,0); //sec 10์ ์๋ฆฌ
segOutput(3,min%10,1); //min 1์ ์๋ฆฌ
segOutput(2,min/10,0); //min 10์ ์๋ฆฌ
segOutput(1,hour%10,1); //hour 1์ ์๋ฆฌ
segOutput(0,hour/10,0); //hour 10์ ์๋ฆฌ
}
else{ //์๊ฐ ์กฐ์
segOutput(5,clockVal[0]%10,0); //sec 1์ ์๋ฆฌ
segOutput(4,clockVal[0]/10,0); //sec 10์ ์๋ฆฌ
segOutput(3,clockVal[1]%10,1); //min 1์ ์๋ฆฌ
segOutput(2,clockVal[1]/10,0); //min 10์ ์๋ฆฌ
segOutput(1,clockVal[2]%10,1); //hour 1์ ์๋ฆฌ
segOutput(0,clockVal[2]/10,0); //hour 10์ ์๋ฆฌ
}
output๊ฐ false์ด๋ฉด ์๊ฐ์ ์ถ๋ ฅํ๋๊น ํ์ด๋จธ๋ณ์๋ฅผ ์ธํ ํ๋ฉด millis()ํจ์ ํ์ฌ ์๊ฐ์ ๊ตฌํ์ฌ ์ถ๋ ฅํ๋ฉด ๋ฉ๋๋ค. ์ง๋์๊ฐ์ ์ถ๋ ฅ ๋ถ๋ถํ๊ณ ๊ฐ๊ธฐ ๋๋ฌธ์ ๊ทธ๋๋ก ์ ์ฉํฉ๋๋ค. ํ์ง๋ง ์๊ฐ์ ์ ๋ ฅํ ๋๋ 6-Digit 7-Segment Display ์ถ๋ ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ output๊ฐ true์ผ๋๋ ์ ๋ ฅ์ํฉ์ด๋๊น ๊ทธ ์ ๋ ฅ์ ๋ํ ์ถ๋ ฅ๋ถ๋ถ๋ ์ฝ๋ฉํด์ผ ํฉ๋๋ค. ์ ๋ ฅ์๊ฐ์ clockVal[3] ๋ฐฐ์ด๋ณ์์ ์ ์ฅ๋๊ธฐ ๋๋ฌธ์ 10์ ์๋ฆฌ์ 1์ ์๋ฆฌ๋ฅผ ์ชผ๊ฐ์ ๊ฐ ์ซ์๋ฅผ ํด๋น ์์น์ ๋ง๊ฒ ์ถ๋ ฅ์ํค๋ฉด ๋ฉ๋๋ค.
์์ ํํํ ์ฝ๋ฉ์ ์ง๋์๊ฐ์ ์๋์ด๋ ธ ์๊ณ์ ํฉ์ณ ๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
#include
#define STATE 16597183
#define SELECT_TIME 16609423
#define TIME_UP 16601263
#define TIME_DOWN 16584943
const byte IRpin = 2;
IRrecv irrecv(IRpin);
decode_results results;
//a,b,c,d,e,f,g ์ํ๊ฐ
byte segValue[10][7] = {
{1,1,1,1,1,1,0}, //0
{0,1,1,0,0,0,0}, //1
{1,1,0,1,1,0,1}, //2
{1,1,1,1,0,0,1}, //3
{0,1,1,0,0,1,1}, //4
{1,0,1,1,0,1,1}, //5
{1,0,1,1,1,1,1}, //6
{1,1,1,0,0,0,0}, //7
{1,1,1,1,1,1,1}, //8
{1,1,1,1,0,1,1} //9
};
const byte segPin[8]={3,4,5,6,7,8,9,10}; //์ฌ์ฉํ{a,b,c,d,e,f,g,dp} ์์๋๋ก์
const byte digitPin[6] = {A0,A1,A2,A3,A4,A5}; //segment ์์น ํ
boolean output = false;//์๊ฐ ์ถ๋ ฅํ์ ์ง์
byte selectVal = 0;
int clockVal[3]={0,0,0};
extern volatile unsigned long timer0_millis; //ํ์ด๋จธ๋ณ์
unsigned long readTime; //ํ์ฌํ์ด๋จธ์๊ฐ
int hour, min, sec;
void setup() {
Serial.begin(9600);
irrecv.enableIRIn(); // ๋ฆฌ๋ชจ์ฝ ์์
for(int i=0;i<10;i++){
pinMode(segPin[i], OUTPUT);
}
for(int j=0;j<6;j++){
pinMode(digitPin[j], OUTPUT);
digitalWrite(digitPin[j], HIGH);
}
}
void loop() {
IRremoteRead(); //๋ฆฌ๋ชจ์ฝ ์ฝ๊ธฐ
if(output==false){ //์๊ฐ ์ถ๋ ฅ
readTime = millis()/1000;
if(millis()>=86400000){
timer0_millis=0;
}
sec = readTime%60;
min = (readTime/60)%60;
hour = (readTime/(60*60))%24;
segOutput(5,sec%10,0); //sec 1์ ์๋ฆฌ
segOutput(4,sec/10,0); //sec 10์ ์๋ฆฌ
segOutput(3,min%10,1); //min 1์ ์๋ฆฌ
segOutput(2,min/10,0); //min 10์ ์๋ฆฌ
segOutput(1,hour%10,1); //hour 1์ ์๋ฆฌ
segOutput(0,hour/10,0); //hour 10์ ์๋ฆฌ
}
else{ //์๊ฐ ์กฐ์
segOutput(5,clockVal[0]%10,0); //sec 1์ ์๋ฆฌ
segOutput(4,clockVal[0]/10,0); //sec 10์ ์๋ฆฌ
segOutput(3,clockVal[1]%10,1); //min 1์ ์๋ฆฌ
segOutput(2,clockVal[1]/10,0); //min 10์ ์๋ฆฌ
segOutput(1,clockVal[2]%10,1); //hour 1์ ์๋ฆฌ
segOutput(0,clockVal[2]/10,0); //hour 10์ ์๋ฆฌ
}
}
void IRremoteRead(){
if (irrecv.decode(&results)) //๋ฆฌ๋ชจ์ฝ ๋๋ฅธ๊ฐ์ด ์๋ค๋ฉด ํจ์ค
{
if(results.value==STATE){ //์๊ฐ ์
๋ ฅ ๊ฒฐ์
output=!output;
if(output==false){ //๋ฆฌ๋ชจ์ฝ์ผ๋ก ์/๋ถ/์ด ์
๋ ฅํ ๊ฐ์ ํ์ด๋จธ๋ณ์์ ์ ์ฅ;
hour = clockVal[2];
min = clockVal[1];
sec = clockVal[0];
timer0_millis = ((long)hour*3600+min*60+sec)*1000;
}
else{ //์๊ฐ ์
๋ ฅ ์ ์
๋ ฅ ๋ณ์์ ์ด๊ธฐํ
selectVal=0;
for(int i=0;i<3;i++){
clockVal[i]=0;
}
}
}
if(output==true){ //์๊ฐ ์
๋ ฅ ์ ์ด
if(results.value==SELECT_TIME){ //์/๋ถ/์ด ์์น ์ ํ
selectVal++;
if(selectVal==3)selectVal=0;
}
if(results.value==TIME_UP)clockVal[selectVal]++; //์๊ฐ๊ฐ ์ฆ๊ฐ
else if(results.value==TIME_DOWN) clockVal[selectVal]--; //์๊ฐ๊ฐ ๊ฐ์
if(selectVal==2){ //hour ์ผ๋
if(clockVal[selectVal]==24)clockVal[selectVal]=0;
else if(clockVal[selectVal]==-1)clockVal[selectVal]=23;
}
else{ //min, sec ์ผ๋
if(clockVal[selectVal]==60)clockVal[selectVal]=0;
else if(clockVal[selectVal]==-1)clockVal[selectVal]=59;
}
}
irrecv.resume(); // ๋ค์๊ฐ
}
}
//LED ์ด๊ธฐํ
void segClear(){
for(int i=0;i<8;i++){
digitalWrite(segPin[i], LOW);
}
}
//LED ์ถ๋ ฅ
void segOutput(int d, int Number, int dp){
segClear();
digitalWrite(digitPin[d], LOW);
for(int i=0;i<7;i++){
digitalWrite(segPin[i], segValue[Number][i]);
}
digitalWrite(segPin[7], dp);
delayMicroseconds(1000);
digitalWrite(digitPin[d], HIGH);
}
์ง๋์๊ฐ์ ์๋์ด๋ ธ ์๊ณ ์์ค๋ฅผ ์ดํด ํ์ ์ผ ์ค๋ ๋ฆฌ๋ชจ์ฝ ์ ์ด ๋ถ๋ถ์ ์ดํดํ ์ ์์ต๋๋ค. ๋จํธ์ ์ผ๋ก ์ค๋ช ํ๋ค ๋ณด๋ ์๋์ด๋ ธ์๊ณ ์์ค๋ฅผ ๋ชจ๋ฅธ ์ํ์์ ์ดํดํ์๊ธฐ๊ฐ ์ข ์ด๋ ค์ธ ์ ์๊ฒ ๋ค์. ์ฌ์ ํ์ต์ ๋ฏธ๋ฆฌ ํ์๊ณ post๋ฅผ ์ฝ์ด ์ฃผ์๊ธฐ ๋ฐ๋๋๋ค.
FUNC/STOP ๋ฒํด์ ๋๋ฅด๋ฉด ์๊ฐ์ ์ ๋ ฅ ํ ์ค๋น ์ํ๊ฐ ๋ฉ๋๋ค. ์ธ๋ชจ ์/์๋ ๋ฐ๋ก ๋๋ฅด๋ฉด sec๊ฐ ์์ง์ ๋๋ค. ST/REPT๋ฅผ ๋๋ฅด๋ฉด min ์์น๋ก ์ด๋ํ๊ณ ๋ค์ ์ธ๋ชจ ์/์๋๋ฅผ ๋๋ฅด๋ฉด min์ด ์์ง์ ๋๋ค. ๋, ST/REPT๋ฅผ ๋๋ฅด๋ฉด hour ์์น๋ก ์ด๋ํ๊ณ ๋ค์ ์ธ๋ชจ ์/์๋๋ฅผ ๋๋ฅด๋ฉด hour์ด ์์ง์ ๋๋ค. ์ ๋ ฅ ํ ์๊ฐ ์ธํ ์ด ๋๋๋ฉด FUNC/STOP ๋ฒํด์ ๋๋ฅด๋ฉด ์ ๋ ฅ๋ ์๊ฐ์ด ํ์ด๋จธ๋ณ์์ ์ธํ ์ด ๋๊ณ ๊ทธ๋๋ถํฐ ์๊ฐ์ด ํ๋ฌ๊ฐ๊ณ 6-Digit 7-Segment Display์ ํ์ฌ ์๊ฐ์ ์ถ๋ ฅํ๊ฒ ๋ฉ๋๋ค.
ํ๋ฒ ์์ ์์๋๋ก ์๊ฐ์ ์ ๋ ฅํด ๋ณด์ธ์.
์๋ ๋์์์ ํ๋ก๋๊ฐ ๋ณต์กํด์ ๊ฐ์์๋ฎฌ๋ ์ดํฐ๋ฅผ ์คํํ๋ฉด ์ง์ฐ ๋ ์ด ๋ฐ์ํฉ๋๋ค. ๊ทธ๋์ 1์ด๊ฐ ์์ง์ด๋๋ฐ ์ข ์ค๋ ๊ฑธ๋ฆฌ๋๋ฐ ์ด๊ฒ ์๋ชป๋ ์ฝ๋ฉ์ ์๋๊ณ ์ง์ฐ ๋ ์ด๋๊น ๊ฐ์ํ์๊ณ ๋ณด์ธ์.
์ค๋์ ๊ฐ์์๋ฎฌ๋ ์ดํฐ์์ ๊ฐ์์ผ๋ก ์๋์ด๋ ธ ์๊ณ๋ฅผ ๋ง๋ค์๋๋ฐ ๊ฑฐ๊ธฐ์๋ค๊ฐ ๋ฆฌ๋ชจ์ฝ์ ์ฐ๊ฒฐํ์ฌ ์๊ฐ ์ ๋ ฅ์ ์คํ ํ์์ต๋๋ค. ์ฝ๊ฐ ์๊ฐ์ ์ ๋ ฅํ๋ ๋ก์ง์ด ์ข ๋ณต์กํ ์ ์์ต๋๋ค. ํน์ ์ post ์ดํด๊ฐ ์๊ฐ์ง๋ฉด if๋ฌธ ๋จ์๋ก ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด์ ์ด๋ค ๋์์ ํ๋์ง ์ฒดํฌํ์๋ฉด์ ํ ์คํธ ํด๋ณด์๊ธฐ ๋ฐ๋๋๋ค.
์ฐธ๊ณ ๋ก, ์ค์ ๊ตฌํ ํ๊ฒ๋ post์ ์ฌ๋ฆด๋ ค๊ณ ํ๋๋ฐ IR Sensor๋ฅผ ์ฐพ์ง ๋ชปํด์ ์ค์ ๋ก๋ ๊ตฌํ์ ๋ชปํด ๋ดค๋ค์. ๋ง์ฝ ์ฐพ๊ฒ ๋๋ฉด์ 4-Digit 7-Segment Display ๋ถํ์ IR Sensor๋ฅผ ์ฐ๊ฒฐํ์ฌ ์ค์ ๋ก ์คํํ post๋ฅผ ์ฌ๋ฆฌ๊ฒ ์ต๋๋ค.