J 창고

[Atmega128] Stopwatch 본문

컴퓨터/Firmware

[Atmega128] Stopwatch

JSFamily 2015. 1. 4. 23:47




8Bit Timer/Counter Interrupt

Externel Interrupt

74HC595 8Bit Shift Register


를 사용하여 분단위 Stop Watch를 제작


뭐 제대로 만든건지는 확실하게 모르겠지만 ㅎㅎㅎㅎㅎ;;;




4 Digit FND와 74HC595 회로는 

http://wjs890204.tistory.com/755

에 포스팅 되어 있으니 참고




이건 외부 인터럽트를 위한 스위치 회로인데


C1은 채터링 현상 방지를 위해서 하나 낑굼



검색해보니 소자 끼는 것 보단 소프트웨어로 처리하는게 좋다고 하는데

나는 외부 인터럽트를 사용하려고 했기 때문에

그건 아무래도 힘들 것 같아서 하드웨어적으로 처리했다.

소프트웨어적으로 처리하는 방법으로는 약간의 미세한 딜레이를 주는 방법과

아니면 채터링이 생기는 것보다 빨리 인터럽트 방식이 아닌 폴링 방식으로 처리 하는데

이를 채터링 발생 시간보다 빠르게 처리하면 채터링 현상이 없다고 함

http://cafe.naver.com/carroty/150549















1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/*
 * StopWatch.c
 *
 * Created: 2015-01-04 오후 1:46:41
 *  Author: user
 *    
    DATA     DS  <-----> PORTA.0
    CLOCK   SHCP <-----> PORTA.2
    LATCH    STCP <-----> PORTA.1
    
    Digit 4,3 = Common Cathode Type FND
    Digit 2,1 = Common Anode Type FND
            
 */ 
 
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
 
#define TRUE    1
#define FALSE    0
 
volatile unsigned char count1 = 10, init_flag = 0;
volatile unsigned int msec = 0;
 
void HC595write(unsigned char);
void HC595write_4byte(unsigned int);
 
ISR(INT0_vect){
    if(init_flag == TRUE){
        init_flag = FALSE;
        msec = 0;
    }
    else{
        init_flag = TRUE;
    }
}
 
ISR(TIMER0_COMP_vect){
    if(init_flag == TRUE){
        count1 --;
        if (count1 == 0){
            HC595write_4byte(msec++);
            if(msec >= 6000) msec = 0;
            count1=10;
        }
    }
}
 
void HC595write(unsigned char udata){
    unsigned char i=0;
    while(i<=7){
        PORTA  = ( udata >> i) & 0x01;    // DATA
        PORTA |= 0b00000100;            // SHIFT 1
        PORTA &= 0b11111011;            // SHIFT 0
        i++;
    }
}
 
void HC595write_4byte(unsigned int udata){
    unsigned char digit_common_cathode[10] = {
        0b11111100,        //0
        0b01100000,        //1
        0b11011010,        //2
        0b11110010,        //3
        0b01100110,        //4
        0b10110110,        //5
        0b00111110,        //6
        0b11100100,        //7
        0b11111110,        //8
        0b11100110        //9
    };
    
    PORTA &= 0b11111110;            // DATA 0
    PORTA &= 0b11111011;            // SHIFT 0
    PORTA &= 0b11111101;            // LATCH 0
    
    unsigned char d1000 = digit_common_cathode[udata/1000];
    unsigned char d100  = digit_common_cathode[(udata%1000)/100];
    unsigned char d10   = digit_common_cathode[(udata%100)/10];
    unsigned char d1    = digit_common_cathode[udata%10];
    
    HC595write(d1000);
    HC595write(d100);
    HC595write(~d10);
    HC595write(~d1);
    
    PORTA |= 0b00000010;        // LATCH 0
    PORTA &= 0b11111101;        // LATCH 1
}
 
int main(void){
 
    DDRA  = 0xFF;
    PORTA = 0x00;
 
    EIMSK = 0x01;        // Init0 Enable
    EICRA = 0x02;        
    EIFR  = 0x00;
    
    TCCR0  = (1<<WGM01) | (1<<CS02);    // TCCR0 = 0x0C
    OCR0   = 0xF9;                    // OCR0 = 249
    TIMSK |= 0x02;
    
    sei();
    
    HC595write_4byte(0);        // 4Digit FND Initialize
    while(1){
    }
}
 
cs









Comments