AVR: 2016

2016년 4월 28일 목요일

// int1.c
// INT7(interrupt 7)을 이용한 외부 인터럽트 테스트
// INT7 스위치를 누를 때마다 LED를 차례로 켜고
// FND를 차례로 증가시킨다.

#include <avr/io.h>
#include <avr/interrupt.h>

#define FND_ON 0xe3 // PE4=0

unsigned char fnd[] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, // 0~4
0x92, 0x82, 0xf8, 0x80, 0x98, // 5~9
0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e}; // AbCdEF

volatile unsigned char int_cnt = 0;

void int_init();

// ISR - Interrupt Service Routine
ISR(INT7_vect) { // SIGNAL(SIG_INTERRUPT7)
int_cnt++;
}

int main(void) {
unsigned char led = 0xfe;
unsigned char bin = 0;

DDRD = 0x0f;
PORTD = 0xff;

DDRA = 0xff;
PORTA = 0xff;

DDRE = 0x3f; // 0011 1111, PE7=0(INT7용 값 입력), PE4=1(FND_ON)
PORTE = FND_ON; // PE4에 0 출력

int_init(); // interrupt 초기화 루틴
sei(); // SREG bit 7을 1로 세팅(Set Enable Interrupt)

while(1) {
if(int_cnt) {
int_cnt = 0;

PORTD = led; // LED 이동
led <<= 1;
led |= 0xf1;
if(led == 0xff)
led = 0xfe;

PORTA = fnd[bin]; // FND 표시
bin++;
if(bin >= 16)
bin = 0;

} // if

} // while

return(0);
} // main

// interrupt 초기화 루틴
void int_init() {
EIMSK = 0x80; // 1000 0000 (Int7을 사용하겠다.)
EICRB = 0Xc0; // 10 00 00 00(falling edge에서 동작하게 해준다.)
// 0x40 : falling/rising edge
// 0x80 : falling edge
// 0xc0 : rising edge

}

AVR 설정

2016년 4월 19일 화요일

AVR Proteus

가상avr

sw3.c

// sw3.c
// switch input test
// PD(port D) : SW7,6,5,4 LED3,2,1,0

#include <avr/io.h>
#include <util/delay.h>
void switch4();
void switch5();

int main(void) {
unsigned char led;
int dir = 0;
DDRD = 0x0f; // 0000:input, 1111:output

while(1) {
led = PIND | 0x0f; // 1111 1111 : light off // when switch not pressed,
if(led != 0xff) { // when switch pressed,
led >>= 4;
led |= 0xf0;

if(led == 0xfe)
switch4();
else if(led == 0xfd)
switch5();
else if(led == 0xfc){
switch4();
switch5();
}
else if(led == 0xfb)
PORTD = !led;

}
else // if switch not pressed,
PORTD = 0xff; // led off

_delay_ms(100);

}//while

return(0);

}

void switch4(){
while(1){
led <<= 1; // shift left 1bit
led |= 0xf1; // 1111 0001, 우측에 1을 삽입
if(led == 0xff)
led = 0xfe;
PORTD = led; // LED on concerning sw pressed,
}
}

void switch5(){
while(1){
led >>= 1;
led |= 0x80;
if(led == 0xff)
led = 0xf7;
PORTD = led; // LED on concerning sw pressed,
}
}

sw2.c

// sw1.c
// switch input test
// PD(port D) : SW7,6,5,4 LED3,2,1,0

#include <avr/io.h>
#include <util/delay.h>
void switch4();
void switch5();

int main(void) {
unsigned char led;
DDRD = 0x0f; // 0000:input, 1111:output

while(1) {
led = PIND | 0x0f; // 1111 1111 : light off // when switch not pressed,
if(led != 0xff) { // when switch pressed,
led >>= 4;
led |= 0xf0;

if(led == 0xfe)
switch4();
else if(led == 0xfd)
switch5();
else if(led == 0xfc){
switch4();
switch5();
}
else if(led == 0xfb)
PORTD = !led;

}
else // if switch not pressed,
PORTD = 0xff; // led off

_delay_ms(100);

}//while

return(0);

}

void switch4(){
led <<= 1; // shift left 1bit
led |= 0xf1; // 1111 0001, 우측에 1을 삽입
if(led == 0xff)
led = 0xfe;
PORTD = led; // LED on concerning sw pressed,
}

void switch5(){
led >>= 1;
led |= 0x80;
if(led == 0xff)
led = 0xf7;
PORTD = led; // LED on concerning sw pressed,
}

led2.c

// led2.c
// led on & off
// define 문을 이용해서 필요한 부분만 컴파일 및 실행

#include <avr/io.h>
#include <util/delay.h>
#define TEST 1

int main(void) {
#if TEST == 1 // #ifdef TEST
unsigned char led = 0xfe; // 1111 1110
#else
unsigned char led = 0xf7; // 1111 0111
#endif

DDRD = 0x0f;
// upper4bit : input
// under4bit :

while(1) {
PORTD = led; // on
_delay_ms(1000); // delay

#if TEST == 1
led <<= 1; // shift left 1bit
led |= 0xf1; // 1111 0001, 우측에 1을 삽입
if(led == 0xff)
led = 0xfe;

#else
led >>= 1;
led |= 0x80;
if(led == 0xff)
led = 0xf7;

#endif
} // while

return(0);

}

2016년 4월 18일 월요일

port D vs pin D

port d : 불 출력

pin d : 스위치 읽기

sw1.c

// sw1.c
// switch input test
// PD(port D) : SW7,6,5,4 LED3,2,1,0

#include <avr/io.h>
#include <util/delay.h>

int main(void) {
unsigned char led;
DDRD = 0x0f; // 0000:input, 1111:output

while(1) {
led = PIND | 0x0f; // 1111 1111 : light off
if(led != 0xff) { // if switch pressed,
led >>= 4;
led |= 0xf0;
PORTD = led; // LED on concerning sw pressed,
}
else // if switch not pressed,
PORTD = 0xff; // led off

_delay_ms(100);
}

return(0);

}

시프트 연산자

[C/C++강좌] 17. 연산자 - 시프트 연산자

글쓴이 : 관리자

트랙백 주소 : http://www.tipssoft.com/bulletin/tb.php/FAQ/724

팁스소프트에서 제공하는 프로그래밍과 관련된 자료나 정보들을 무단으로 복제하거나 게재하는 행위는
상호간의 신뢰를 무너뜨리는 행위이며, 법적인 문제를 야기할 수 있으므로 각별한 주의를 당부드립니다.

* 팁스소프트 저작권 정책 보기 - http://www.tipssoft.com/bulletin/tb.php/FAQ/637

이 자료들은 팁스소프트에서 제공하는 [ 알짜배기 ] 프로그램을 이용하면 더 편리하게 볼수 있습니다.

* 알짜배기 프로그램 받기 - http://www.tipssoft.com/bulletin/tb.php/QnA/8406

이 강좌에서는 C/C++ 언어의 제어문인 시프트(Shift) 연산자에 대하여 알아보도록 하겠습니다.

1. 시프트 연산자란?

시프트 연산자는 데이터를 비트 단위로 이동시켜 값을 증감시키는 연산자입니다. 비트는 2진수의

형태를 가지고 있기때문에 비트를 이동시키는 방향에 따라서 값이 2배씩 증가 혹은 감소하게됩니다.

그래서 2의 제곱으로 값을 변경시키는 경우에 유용하게 사용할 수 있습니다.

프로그램에서 시프트 연산자는 "<<" 혹은 ">>" 키워드를 사용하여 아래와 같은 형식으로 표현합니다.

데이터 << 이동할 비트 수

데이터 >> 이동할 비트 수

"<<" 키워드는 데이터를 왼쪽으로 비트 수만큼 이동시키기 때문에 2의 "이동할 비트수" 를 제곱한 값과

데이터가 곱해진 값이 결과 값으로 도출됩니다. 아래의 코드는 값을 왼쪽으로 시프트 시키는 예입니다.

// int 형 변수에 5를 저장

int number = 5;

// 5를 왼쪽으로 3비트 이동하는 시프트 연산을 한다. 연산결과는 40 이다.

// 5 * (2^3) = 5 * 8 = 40

int result = number << 3;

위의 코드는 5가 저장된 number 변수를 왼쪽으로 3비트 이동시키는 것입니다. 비트의 각 자리수는

왼쪽으로 갈수록 2배씩 가중치가 증가하기때문에 number 값을 3비트 이동시키면 2의 3제곱 값을

곱한만큼 값이 증가하게 됩니다. 즉, "5 << 3" 은 5에 2의 3제곱인 8을 곱하는 것과 같습니다.

위의 그림은 5에 3만큼 왼쪽으로 시프트하는 과정을 나타낸 것입니다. 5의 2진수인 "101" 가 왼쪽으로

3만큼 이동한 후 생긴 빈 공간에는 0이 채워져서 "101000" 이 되는 것을 볼 수 있습니다. 그래서 결과

값은 5에 8(2의 3제곱)을 곱한 40이 됩니다.

이번에는 아래의 코드와 같은 오른쪽으로 1만큼 시프트하는 연산에 대해 알아보겠습니다.

// int 형 변수에 40 을 저장

int number = 40;

// 40 을 오른쪽으로 1비트 이동하는 시프트 연산을 한다. 연산결과는 20 이다.

// 40 / (2^1) = 40 * 2 = 20

int result = number >> 1;

위의 코드는 40이 저장된 number 를 오른쪽으로 1비트 이동시키는 것입니다. 비트의 각 자리수는

오른쪽으로 이동할수록 2의 제곱으로 가중치가 감소하기 때문에 number 값을 오른쪽으로 1비트

이동시키면 2배만큼 감소하게 됩니다. 즉, "40 >> 1" 은 40에서 2를 나눈 것과 같습니다.

위의 그림은 40에서 오른쪽으로 1번 시프트하는 과정을 나타낸 것입니다. 40의 2진수인 "101000" 을

오른쪽으로 1만큼 이동한 후 생긴 빈 공간에는 0이 채워지고 결과 값은 "10100" 이 되는 것을 볼 수

있습니다. 그래서 결과 값은 40에 2를 나눈 20이 됩니다.

2. 부호비트와 시프트 연산

수치 데이터를 저장하는 데이터 타입에는 부호가 있는 데이터와 부호가 없는 데이터가 있습니다.

부호가 없는 데이터 값을 시프트 연산하는 것과 달리 부호가 있는 데이터 값을 시프트 연산할 때에는

부호비트에 따라 연산 과정이 조금 달라집니다.

2.1 부호비트와 왼쪽 시프트 연산(Left - Shift)

왼쪽으로 시프트 연산을 수행하는 경우 값은 2배씩 증가하게 됩니다. 이때 아래의 그림과 같이

최상위 비트와 그 다음 비트가 서로 다른 값인 경우 오버플로우(Overflow)가 발생합니다.

위의 그림이 왼쪽 시프트 연산을 하기 전 값은 79 이지만 "79 << 1" 을 연산한 결과는 "10011110" 이

되며 10진수로 변환한 결과 값은 -98이 됩니다. 최상위 비트가 부호비트가 아니라면 연산 결과는

79 의 2 배인 158 이지만 최상위비트가 변경되어 오버플로우가 발생하였기 때문에 부호가 바뀌고

결과 값이 원하는 값과 다르게 나온 것입니다.

오버플로우는 부호비트가 1 에서 0 으로 변경된 경우에도 발생하며 이 때에는 음수가 양수로 바뀌게

됩니다. 그러므로 부호가 있는 데이터의 왼쪽 시프트 연산 시에는 오버플로우가 발생할 수 있는

것을 고려해주어야 합니다.

2.2 부호비트와 오른쪽 시프트 연산(Right - Shift)

오른쪽으로 시프트 연산을 하는 경우는 2의 제곱으로 나누기 연산을 하는 것입니다. 이때 비트들이

오른쪽으로 이동하면서 생긴 공간은 부호비트의 값으로 채워집니다. 아래의 그림에서는 부호비트가

1이기 때문에 1로채워지지만 만약 부호비트값이 0이라면 0으로 채워지게 됩니다.

예를 들어 위의 그림과 같이 "1011 1111" 값을 오른쪽으로 한번 이동하면 왼쪽에 생긴 빈 공간은

최상위 비트인 1 값으로 채워지는 것입니다. 만약 "-160 >> 4" 를 연산하면 -160 의 이진수 값인

"1010 0000" 가 오른쪽으로 4비트만큼 이동하고, 왼쪽에 생긴 네개의 빈 공간은 최상위 비트인

1 로 채워지므로 연산 결과는 "1111 1010" 가 됩니다.

3. 시프트 연산시 주의 사항

시프트 연산자의 우선순위 산술 연산자보다 낮습니다. 그렇기 때문에 다음과 같은 문제가 발생할 수

있으므로 시프트 연산시 괄호를 사용하여 연산하는 습관을 들이는 것이 좋습니다.

int data = 10 << 3 - 2 >> 1;

= 10 << 1 >> 1

= 20 >> 1

= 10 // 원하지 않는 결과 값 발생

위의 예제는 "10 << 3" 을 연산한 결과에서 "2 >> 1" 을 연산한 결과를 뺄 목적으로 수식을 작성한

것이지만 연산자 우선순위에 의해 "3 - 2" 가 먼저 연산되어 원하지 않는 연산 결과가 발생하였습니다.

올바른 연산 결과를 얻기 위해서는 아래와 같이 시프트 연산 부분을 괄호로 묶어주면 됩니다.

int data = ( 10 << 3 ) - ( 2 >> 1 );

= 80 - ( 2 >> 1 )

= 80 - 1

= 79 // 올바른 결과 값 발생

4. 시프트 연산을 수행하는 간단한 예제

아래의 코드는 1바이트 크기의 char 형 변수 네개의 값을 4바이트 크기의 int 형 변수에 저장했다가

다시 4개의 char 형 변수로 나누어 저장하는 예제입니다.

    void main()
    {
        // 4바이트 변수를 선언한다.        int data = 0;

        // 1바이트 변수 4개를 선언하여 값을 저장한다.        char id = 23;
        char korean = 98, english = 76, math = 86;

// 1바이트 변수 4개를 선언한다. char id2, korean2, english2, math2;

// 시프트 연산전 데이터의 값들을 출력한다. printf("shift 연산 전 : id %d번 학생의 시험성적입니다.\n", id);
printf("국어점수 : %d, 영어점수 : %d, 수학점수 : %d \n\n", korean, english, math);

// 1바이트 변수에 저장된 4개의 값을 4바이트 변수에 나누어 저장한다.

// id 값을 왼쪽으로 24비트 이동시킨 후 data 값과 OR 연산하여 data 에 저장한다.
// 데이터 변수의 상위 8비트(i) 에 id 값이 저장된다. // iiiiiiii 00000000 00000000 00000000 data = data | (id << 24);

        // korean 값을 왼쪽으로 16비트 이동시킨 후 data 값과 OR 연산하여 data 에 저장한다.
        // 데이터 변수의 상위 9 ~ 16 번째 비트(k)에 korean 값이 저장된다.
        // iiiiiiii kkkkkkkk 00000000 00000000
        data = data | (korean << 16);

        // english 값을 왼쪽으로 8비트 이동시킨 후 data 값과 OR 연산하여 data 에 저장한다.
        // 데이터 변수의 상위 17 ~ 24 번째 비트(e)에 english 값이 저장된다.
        // iiiiiiii kkkkkkkk eeeeeeee 00000000
        data = data | (english << 8);

        // math 값을 data 값과 OR 연산하여 data 에 저장한다.
        // 데이터 변수의 상위 25 ~ 32 번째 비트(m)에 math 값이 저장된다.
        // iiiiiiii kkkkkkkk eeeeeeee mmmmmmmm        data = data | math;

// data변수에 저장된 값들을 1바이트씩 나누어 4개의 변수에 저장한다.
// data 값을 오른쪽으로 24비트 이동시킨 후 0x000000FF과 AND 연산하여 id2에 저장한다. id2 = (data >> 24) & 0x000000FF;

// data 값을 오른쪽으로 16비트 이동시킨 후 0x000000FF과 AND 연산하여 korean2에 저장한다. korean2 = (data >> 16) & 0x000000FF;

// data 값을 오른쪽으로 8비트 이동시킨 후 0x000000FF과 AND 연산하여 english2에 저장한다. english2 = (data >> 8) & 0x000000FF;

// data 값을 0x000000FF과 AND 연산하여 math2에 저장한다. math2 = data & 0x000000FF;

        // 시프트 연산으로 합쳤다가 분리한 값들을 출력하여 확인한다.         printf("shift 연산 후 : id %d번 학생의 시험성적입니다.\n", id2);
        printf("국어점수 : %d, 영어점수 : %d, 수학점수 : %d \n", korean2, english2, math2);
    }

** 연산 결과 **

led1.c 2016.04.19.

// led1.c
// led on & off

#include <avr/io.h>
void delay(int d1, int d2);

int main(void) {
    unsigned char led = 0xfe;
    int dir = 1;                // 1 == left, 2 == right
    DDRD = 0x0f;
    // upper4bit : input
    // under4bit :

    while(1) {
        PORTD = led;            // on
        delay(1000, 1000);        // delay
        if(dir == 1) {
            led <<= 1;            // shift left 1bit
            led |= 0xf1;        // 1111 0001, 우측에 1을 삽입
            if(led == 0xff) {
                led = 0xfb;
                dir = 2;
            }
        }
        else {
            led >>= 1;
            led |= 0x80;
            if(led == 0xff) {
                led = 0xfd;
                dir = 1;
            }
        }

//        PORTD = 0b00001110;
//        delay(1000, 1000);
//        PORTD = 0b00001101;
//        delay(1000, 1000);
//        PORTD = 0b00001011;
//        delay(1000, 1000);
//        PORTD = 0b00000111;
//        delay(1000, 1000);
//        PORTD = LED;
//        PORTD = 0xfe;
//        delay(1000, 1000);
//        PORTD = 0xfe<<1 || 0x01;
//        delay(1000, 1000);
//        PORTD = 0xfe<<2;
//        delay(1000, 1000);
//        PORTD = 0xfe<<3;
//        delay(1000, 1000);

    }

    return(0);

}

void delay(int d1, int d2) {
    int i, j;

    for(i=0; i<d1; i++)
        for(j=0; j<d2; j++);

AVR