반응형

1.6 Arrays

 

* Arrays 클래스 : 배열을 다루는데 유용한 메서드가 정의되어 있음. 아래 정의된 toString(), 모든 기본형 배열, 참조형 배열 별로 하나씩 정의됨.

 

static String toString(boolean[ ]a)

static String toString(byte[ ] a)

static String toString(char[ ] a)

static String toString(short[ ] a)

static String toString(int[ ] a)

static String toString(long[ ] a)

static String toString(float[ ] a)

static String toString(double[ ] a)

static String toString(object[ ] a)

 

------------------------------------------------------------------------------------------------------------------------------------------------------------

 

* 배열의 복사

- copyOf() : 배열 전체 복사

- copyOfRange() : 배열의 일부를 복사

하여 새로운 배열을 만들어 반환.

 

int[ ] arr = {0,1,2,3,4,};

int[ ] arr2 = Arrays.copyOf(arr, arr.length);

int[ ] arr3 = Arrays.copyOf(arr, 3);

int[ ] arr4 = Arrays.copyOf(arr, 7);

 

int[ ] arr5 = Arrays.copyOfRange(arr,2,4);

int[ ] arr6 = Arrays.copyOfRange(arr,0,7);

 

 

// 배열의 복사

package Collection_Framework;
import java.util.*;
public class Arrays1 {
 public static void main(String[]arge) {

  int[ ] arr = {0,1,2,3,4,};
  int[ ] arr2 = Arrays.copyOf(arr, arr.length);
  int[ ] arr3 = Arrays.copyOf(arr, 3);
  int[ ] arr4 = Arrays.copyOf(arr, 7);

  int[ ] arr5 = Arrays.copyOfRange(arr,2,4);
  int[ ] arr6 = Arrays.copyOfRange(arr,0,7);

  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.toString(arr2));
  System.out.println(Arrays.toString(arr3));
  System.out.println(Arrays.toString(arr4));
  System.out.println(Arrays.toString(arr5));
  System.out.println(Arrays.toString(arr6));
 }
}

 

출력결과 :

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2]
[0, 1, 2, 3, 4, 0, 0]
[2, 3]
[0, 1, 2, 3, 4, 0, 0]


 

* 배열 채우기

- fil() : 배열의 모든 요소를 지정된 값으로 채운다.

- setAll() : 배열을 채우는데 사용할 함수형 인터페이스를 매겨변수로 받는다.

 

package Collection_Framework;
import java.util.*;
public class Arrays2 {

 public static void main(String[] args) {

  int[]arr = new int[5];
  Arrays.fill(arr, 9);
  Arrays.setAll(arr, () -> (int)(Math.random()*5)+1); // 람다식을 지정해야 함.

 System.out.println(Arrays.toString(arr));
 }

}

 

출력 결과 :

[9, 9, 9, 9, 9]

* 배열의 정렬과 검색

- sort() : 배열을 정렬할 때 사용

- binarySearch() : 저장된 요소를 검색 할 때 사용, 배열에서 지정된 값이 저장된 위치(index)를 찾아서 반환하는데, 반드시 배열이 정렬된 상태이어야 올바른 결과를 얻음.

 

package Collection_Framework;
import java.util.*;
public class Arrays3 {

 public static void main(String[] args) {
  int[] arr = {3,2,0,1,4};
  int idx = Arrays.binarySearch(arr, 2);
  System.out.println(Arrays.toString(arr));
 
  Arrays.sort(arr);
  System.out.println(Arrays.toString(arr));
  int idx2 = Arrays.binarySearch(arr,2);
 
  
 }

}

 

출력 결과 :

[3, 2, 0, 1, 4]
[0, 1, 2, 3, 4] 
<- 올바른 결과.
 

 

 

* 문자열의 비교와 출력

- equals() : 두 배열에 저장된 모든 요소를 비교해서 같으면 true, 다르면 false를 반환. 일차원 배열에서만 사용가능

- toString() : 일차원 배열에서 문자열로 편하게 출력함.

 

다차원 배열에서

- deepToString(), deepToEquals() 사용

 

package Collection_Framework;
import java.util.*;
public class Arrays4 {

 public static void main(String[] args) {
  int[] arr = {0,1,2,3,4};
  int[] [] arr2D = {{11,12},{21,22}};
  
  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.deepToString(arr2D));
  
  String[] [] str2D = new String [] [] {{"aaa","bbb"},{"AAA","BBB"}};
  String[] [] str2D2 = new String [] [] {{"aaa","bbb"},{"AAA","BBB"}};
  System.out.println(Arrays.equals(str2D, str2D2));
  System.out.println(Arrays.deepEquals(str2D, str2D2));
 }

}

출력결과 :

[0, 1, 2, 3, 4]
[[11, 12], [21, 22]]
false
true

* 배열을 List로 변환 // 이해가 잘 안감...

- asList(Object... a)

 

package Collection_Framework;
import java.util.*;
public class Arrays5 {

 public static void main(String[] args) {
  List list = Arrays.asList(new Integer[] {1,2,3,4,5,});
  List<Integer> list = Arrays.asList(1,2,3,4,5);
  list.add(6);
  
 }

}

 

 

* parallel로 시작하는 메서드(), spliterator(), tream()등등

 

 

 

반응형
반응형

1.5 lterator, Listlterator, Enumeration

 

lterator, Listlterator, Enumeration 모두 컬렉션에 저장된 요소를 접근하는데 사용하는 인터페이스 이다.

 

Enumeration은 Iterator의 구버전이다. ListIterator은 Iterator의 기능을 향상 시킨 것이다.

 

* Iterator  

 

- interface 메서드
 public interface Iterator {
  boolean hasNext(); // 읽어 올 요소가 남아 있는지 확인 한다. 있으면 true, 없으면 false.
  Object next(); // 다음 요소를 읽어 온다. next()를 호출 하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전.
  void remove(); // next()로 읽어 온 요소를 삭제한다. next()를 호출한 다음에 remove()를 호출해야 한다.(선택적)
 }
  public interface Collection{
  public Iterator iterator();
 }

-------------------------------------------------------------------------------------------------------------------------------------------------

 

package Collection_Framework;
import java.util.*;
public class Iterator1 {

 public static void main(String[] args) {

  ArrayList<String> list = new ArrayList<String>();
  
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5"); 
  
  Iterator<String> iter = list.iterator();
  
  while(iter.hasNext()) {
   Object obj = iter.next();
   System.out.println(obj);
  }
 }
}

 

출력 결과 :

1
2
3
4
5

 

===========================================================================================

* ListIterator

 : 양방향으로 이동하기 때문에 각 요소간의 이동이 자유롭다.

다만 이동하기 전에 반드시 hasNext() 나 hasPrevious()를 호출하여 이동할 수 있는지 확인해야 한다.

 

- interface 메서드

void add(Object o) // 컬렉션에 새로운 객체 o를 추가한다.

boolean hasNext() // 읽어 올 다음 요소가 남아있는지 확인한다. 있으면 true, 없으면 false를 반환

boolean hasPrevious() // 읽어 올 이전 요소가 남아 있는지 확인한다. 있으면 true, 없으면 false를 반환

Object next() //다음 요소를 읽어 온다. next()를 호출하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전한다.

Object previous() // 이전 요소를 읽어온다. previous()를 초훌하기 전에 hasPrevious()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전한다.

int nextindex() // 다음 요소의 index를 반환한다.

int previousindex() // 이전 요소의 index를 반환한다.

void remove() // next() 또는 previous()로 읽어 온 요소를 삭제한다. 반드시 next()나 previous()를 먼저 호출한 다음에 이 메서드를 호출해야 한다.

void set(Object o) // next()또는 previous()로 읽어 온 요소를 지정된 객체(o)로 변경한다. 반드시 next()나 previous()를 먼저 호출한 다음에 이 메서드를 호출해야한다.

 

예제.

package Collection_Framework;
import java.util.*;
public class listlterator1 {
 public static void main(String[]args) {
  ArrayList<String> list = new ArrayList<String>();
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5"); 
  
  ListIterator<String> iter = list.listIterator();
  
  while (iter.hasNext()) {
   System.out.print(iter.next());
  }
  System.out.println();
  
  while(iter.hasPrevious()) {
   System.out.print(iter.previous());
  }
  System.out.println();
 }
}

 

 

출력 결과 :

12345
54321


 

* Enumeration

- interface 메서드

boolean hasMoreElements() // 읽어 올 요소가 남아 있는지 확인한다. 있으면 true, 없으면 false 반환. Iterator의 hasNext()와 같음

Object nextElement() // 다음 요소를 읽어 온다. nextElement()를 호출하기 전에 hasMoreElements()를 호출해서 읽어올 요소가 남아 있는지 확인하는 것이 안전한다. Iterator의 next()와 같다.

반응형
반응형

1. 개념적 모델 (concecptual model)

1) 개체 - 관계 모델 (entity - relation diagram)

- entity, relation, atribute

 

2. 논리적 모델(logical model)

- 테이블 형식 (relation)

1) Key

* 기본키 (primary key)

* 외래키 (foreign key)

* 슈퍼키 : 키의 집합

* 후보키 (candidate key)

* 복합키 : atribute가 2개이상으로 구성된 키

 

* 슈퍼키 > 후보키 > 기본키 = 대체키

 

* 정규화 : 불필요한 중복을 없애는 방식

 

3. 물리적 모델(physical model)

 

 

 

* DDL & DML

 

 

*SQL DEV 실습

select * from Customer;
select * from buy;

CREATE TABLE Customer (
id varchar(20) Not NULL,
name varchar(20) not null,
Levels varchar(20),
적립금 INT DEFAULT 0,
address varchar(20),
job varchar(20),
CONSTRAINT CustomerPK PRIMARY KEY (id));
);

CREATE TABLE buy (
num INT,
id varchar(20) NOT NULL,
CNO INT NOT NULL,
DATES INT,
count INT
CONSTRAINT CustomerForeignkey FOREIGN KEY ();
);

CREATE TABLE 상품 (
num INT,
name varchar(20),
price INT,
company varchar(20),
usabledate varchar(20)
);
DROP Table Customer;
DROP Table buy;

insert into Customer values('jhs', '조', '1', 0, '대전', 'job');

 

 

 

 

 

//select * from Customer; 실행시 , buy table 재설계 필요

 

반응형
반응형

 

Orcle

Database 12c 설치 후

JavaEE에서 http://localhost:8080

접속시 Tomcat 페이지 출력된다.

 

 

1. oracle 12c. 11g

 


 - https://localhost:5500/em
 >> DB 종합정보

 

SQL DEVELOPER

1. system 생성

2. sys 생성(dba)

3. scott 생성 // 사용자 이름 c##scott

 

반응형
반응형

 

// 소스 코드 :

 

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
#include <avr/io.h>
#include <util/delay.h>
#define F_CPU 16000000UL
#include <avr/interrupt.h>
 
#define OFF 0
#define ON 1
volatile unsigned char digit_c[10= {0x000x270x090x030x260x120x100x060x000x02}; // 0 ~ 10
volatile unsigned char digit_b[10= {0x040x04, ~0x04, ~0x04, ~0x04, ~0x04, ~0x040x04, ~0x04, ~0x04}; // 0 ~ 10
volatile unsigned char fnd_sel[4= {0x100x200x400x80}; // fnd_sel c1, c2, c3, c4
 
volatile unsigned int msec, sec,min,hour = 0// time
volatile unsigned int play = ON; // play ON/OFF
 
 
 
int main(){
 
 
 DDRB = 0x04;
 DDRC = 0xff;
 DDRD = 0xf0;
 
 
 while(1){
  
  if ((PIND & 0x01== 0x00){ 
  play = ON; continue;}
  if ((PIND & 0x02== 0x00){
  play = OFF; continue;}
    
  if(play == ON){
  
  msec++
  if(msec>40){msec=0; sec++;}
  if(sec>59){sec=0; min++;}
  if(min>59){min=0; hour++;}
  if(hour>23){hour=0;}
 
  PORTC = digit_c[hour/10]; PORTB = digit_b[hour/10]; PORTD = fnd_sel[3];_delay_ms(3);
  PORTC = digit_c[hour%10]; PORTB = digit_b[hour%10]; PORTD = fnd_sel[2];_delay_ms(3);
  PORTC = digit_c[min/10]; PORTB = digit_b[min/10]; PORTD = fnd_sel[1];_delay_ms(3);
  PORTC = digit_c[min%10]; PORTB = digit_b[min%10]; PORTD = fnd_sel[0];_delay_ms(3);
  }
 
  if(play == OFF){
 
  cli();
  GICR = 0xc0;
  MCUCR = 0x0a;
  GIFR = 0x00;
  sei();
  
  PORTC = digit_c[hour/10]; PORTB = digit_b[hour/10]; PORTD = fnd_sel[3]; _delay_ms(3);
  PORTC = digit_c[hour%10]; PORTB = digit_b[hour%10]; PORTD = fnd_sel[2]; _delay_ms(3);
  PORTC = digit_c[min/10]; PORTB = digit_b[min/10]; PORTD = fnd_sel[1]; _delay_ms(3);
  PORTC = digit_c[min%10]; PORTB = digit_b[min%10]; PORTD = fnd_sel[0]; _delay_ms(3);
 
  }
 }
 
}
 
ISR(INT0_vect){
 if(min <= 59){
 min++;
 }
 if(min >59){
 min = 0; hour++;
 }
}
ISR(INT1_vect){
 if(hour <= 23){hour++;
 }
 if(hour >23){
 hour =0;
 }
}
 
 
/*
SW 1,2,3,4,
SW 1: Play Mode
SW 2: STOP Setting Mode
SW 3: Hour ++;
SW 4: Min ++;
 
스위치 4개로 시간을 설정/재생 할 수 있다.
 
시간측정을해보니 약 5~10초정도 오차가 있다. 몇달 몇년으로 따지면 엄청난 오차.
 
차후엔 ds3231 rtc모듈을 이용하여 만들어 볼 예정.
*/
 

// 그전에 Timer/Counter로 먼저 만들어 봐야 할 것 같다. 

 
cs

 

 

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

 

반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

[NPAVR Board] AVR -Atmega128 (FND, Switch)  (0) 2018.09.03
[NPAVR Board] AVR -Atmega128 (FND)  (0) 2018.09.03
B/T LED 부품 선정 및 견적서  (1) 2017.04.10
B/T LED Control circuit  (0) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
반응형

 

반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

[NPAVR Board] AVR -Atmega128 (FND)  (0) 2018.09.03
Atmgea8 FND 시계  (0) 2018.02.21
B/T LED Control circuit  (0) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
코드비젼/ AVR EDIT/ ICC/ AVRSTUDIO/ IAR/ 컴파일러 변경시 참조  (0) 2015.06.11
반응형

start_4.pdf

 

반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

Atmgea8 FND 시계  (0) 2018.02.21
B/T LED 부품 선정 및 견적서  (1) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
코드비젼/ AVR EDIT/ ICC/ AVRSTUDIO/ IAR/ 컴파일러 변경시 참조  (0) 2015.06.11
pwm duty  (0) 2015.06.11
반응형

 연산자

기능 

결합방향 

 =

 연산자 오른쪽에 있는 값을 연산자 왼쪽에 있는 변수에 대힙한다 

 <- 

 +

 두 피연산자의 값을 더한다 

 ->

 -

 왼쪽의 피연산자 값에서 오른쪽의 피연산자 값을 뺀다 

 -> 

 *

 두 피연산자의 값을 곱한다 

 -> 

 /

 왼쪽의 피연산자 값을 오른쪽의 피연산자 값으로 나눈다 

 -> 

 %

 왼쪾의 피연산자 값을 오른쪽의 피연산자 값으로 나눴을 때 얻게 되는 나머지를 반환한다. 

 ->

 ++num

 값을 1 증가후, 속한 문장의 나머지를 진행(선증가 후 연산) 

 <- 

 num++

 속한 문장을 먼저 진행한 후 값을 1증가(선연산 후 증가) 

 ->

 --num

 값을 1 감소후, 속한 문장의 나머지를 진행(선 감소후 연산) 

 <-

 num--

  속한 문장을 진행한 후 값을 1 감소(선 연산후 감소)

 ->

 <

 예  n1<n2

 n1이 n2보다 작은가? 

 -> 

 >

 예 n1>n2

 n1이 n2보다 큰가? 

 ->

 ==

 예 n1==n2

 n1과 n2가 같은가?

 ->

 !=

 예 n1 != n2

 n1과 n2가 다른가?

 ->

 <=

 예 n1<=n2

 n1이 n2보다 같거나 작은가?

 ->

 >=

 예 n1>=n2

 n1이 n2보다 같거나 큰가?

 ->

 &&

 예 A&&B

 A와 B모두 참이면 연산결과로 참을 반환(논리 AND 

 ->

 ||

 예 A||B

 A와 B 둘중 하나라도 참이면 연산결과로 참을 반환(논리 OR) 

 ->

 !

 예 A!

 A가 참이면 거짓, A가 거짓이면 참을 반환(논리 NOT) 

 <-

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - 배열 (빙고판 만들기)  (0) 2018.08.24
C언어 - 배열 (2차원배열)  (0) 2018.08.24
C언어 - 배열 (로또번호 난수발생기)  (0) 2018.08.24
C언어 과제1  (0) 2018.08.21
C언어 과제2  (0) 2018.08.21
반응형

#include <avr/io.h>

#include <util/delay.h>

#include <avr/interrupt.h>

 unsigned int cnt=0;

unsigned int cntt=0;

void buzzer()

 PORTB = 0x02;

 _delay_ms(10);

 PORTB = 0x00;

 _delay_ms(10);

}

int main()

{

 DDRB = 0xFF;

 PORTB =0x00;

 DDRC = 0x01;

 PORTC = 0x00;

 DDRD = 0xe3;

 PORTD = 0x00;

 //PORTD = 0x40; // 1번째 녹색

 //PORTD = 0x80; // 2번째 녹색

 //PORTB= 0x01; // 3번째 녹색

 //PORTB= 0x40; // 1번째 빨강

 //PORTB= 0x80; // 2번째 빨강

 //PORTD = 0x20; // 3번째 빨강

 //  (PIND & 0xFF) == 0x0c // 선택 스위치 PIND4

 //  (PIND & 0xFF) == 0x14 // 전원부 스위치 PIND3

 // PIND4 0x10; 선택스위치

 // PIND3 0x08; 전원스위치 인터럽트

 

buzzer();

 while(1){

  PORTD = 0x40;

 if((PIND & 0x10)==0x00) // 선택 스위치

  cnt++;

 switch(cnt){  

case 1:

 PORTD = 0xc0;

 _delay_ms(20);

 break;


case 2:

 PORTD = 0xc0;

 PORTB = 0x01;

 _delay_ms(20); 

 break;


case 3:

 PORTD = 0x40;

 PORTB = 0x00;

 cnt=0;

 _delay_ms(20);

 break;

}


   if((PIND & 0x08) == 0x00){// 전원 스위치 

if(cnt == 0){

PORTC = 0x01;

_delay_ms(500);

PORTC = 0x00;

}

else if(cnt==1)

{

PORTC = 0x01;

_delay_ms(500);

PORTC = 0x00;

}

else if(cnt==2){

 PORTC = 0x01;

_delay_ms(500);

PORTC = 0x00;

}

 

 }

}


return 0;}


반응형
반응형

컴파일러

비트표현

코드비젼

bit a,b,c; // 비트변수 선언

PORTA.0=0; // 출력

PORTA.0=1;

a=PORTA.0; // 입력

b=PORTA.1;

PORTA.0= ~PORTA.0; //토글

if(PORTB.0)PORTA.0=0;

if(!PORTB.0)PORTA.0=1;

AVR EDIT & AVRSTUDIO

ICC

IAR

비트 변수 선언 지원 안함

비트변수는 사용자가 구조체로 쓰기도 하지만, 불편

// bit 매크로
#define SetBit(x,y) (x|=(1<<y))
#define ClrBit(x,y) (x&=~(1<<y))
#define ToggleBit(x,y) (x^=(1<<y))
#define FlipBit(x,y) (x^=(1<<y)) // Same as ToggleBit.
#define TestBit(x,y) (x&(1<<y))
위와 같은 비트 매크로를 이용하기도 합니다.

포트 비트 조작 지원 안함

PORTA&=0xFE; // 0 출력

PORTA|=0x01; // 1 출력

출력포트 체크 및 출력

if(PORTB&0x01) PORTA&=0xFE;

if(!(PORTB&0x01)) PORTA|=0x01;

입력포트 체크 및 출력

if(PINB&0x01) PORTA&=0xFE;

if(!(PINB&0x01)) PORTA|=0x01;

 

비트 입출력 비교

코드비젼

AVR EDIT & AVRSTUDIO

ICC

IAR

if( 입력핀==0){} // PA.0==0?

if(!PINA.0){};

if(!(PINA&0x01)){};

if( 입력핀==1){} // PA.0==1?

if(PINA.0){};

if(PINA&0x01){};

출력핀=0; // PB.0=0

PORTB.0=0;

PORTB&=0xFE;

출력핀=1; // PB.0=1

PORTB.0=1;

PORTB|=0x01;

MCU에서 비트 제어를 제공 한다고 하면 컴파일러도 반드시 비트제어 표현이 가능 해야 합니다.

마스크 처리에 의한 비트제어 보다

직접 비트제어를 하는 것이 사용자 입장에서 편리합니다.

만약 포트 A.0을 읽어서 0이면 포트 B.0에 포트 A.0의 값을 반전 시켜서 넣는다고 하면

코드비젼 :

PORTB.0=~PINA.0

다른컴파일러 :

if(PINA&0x01){ PORTB&=0xFE; }

else PORTB|=0x01;

코드비젼 코드가 훨씬 간결 함을 알 수 있습니다.

컴파일러

volatile

코드비젼

 사용 안함

AVR EDIT & AVRSTUDIO

ICC

IAR

 인터럽트에서 사용하는 전역 변수는

volatile 형을 사용해야 합니다.

번거로우므로 전역변수는

모두 volatile 형으로 처리 하는 것이 편합니다.

예) volatile unsigned char i=0;

 

컴파일러

128 헤더파일

코드비젼

 #include <mega128.h>

AVR EDIT & AVRSTUDIO

 #include <avr/io.h>

ICC

 #include <iom128v.h>

IAR

 #include<iom128.h>

#include <ina90.h>


컴파일러

인터럽트

코드비젼

interrupt [EXT_INT0] void ext_int0_isr(void){}

interrupt [EXT_INT1] void ext_int1_isr(void){}

interrupt [EXT_INT2] void ext_int2_isr(void){}

interrupt [EXT_INT3] void ext_int3_isr(void){}

interrupt [EXT_INT4] void ext_int4_isr(void){}

interrupt [EXT_INT5] void ext_int5_isr(void){}

interrupt [EXT_INT6] void ext_int6_isr(void){}

interrupt [EXT_INT7] void ext_int7_isr(void){}

interrupt [TIM0_OVF] void timer0_ovf_isr(void){}

interrupt [TIM0_COMP] void timer0_comp_isr(void){ }

interrupt [TIM1_OVF] void timer1_ovf_isr(void){}

interrupt [TIM1_CAPT] void timer1_capt_isr(void){ }

interrupt [TIM1_COMPA] void timer1_compa_isr(void){ }

interrupt [TIM1_COMPB] void timer1_compb_isr(void){ }

interrupt [TIM1_COMPC] void timer1_compc_isr(void){ }

interrupt [TIM2_OVF] void timer2_ovf_isr(void){}

interrupt [TIM2_COMP] void timer2_comp_isr(void){ }

interrupt [TIM3_OVF] void timer3_ovf_isr(void){}

interrupt [TIM3_CAPT] void timer3_capt_isr(void){ }

interrupt [TIM3_COMPA] void timer3_compa_isr(void){ }

interrupt [TIM3_COMPB] void timer3_compb_isr(void){ }

interrupt [TIM3_COMPC] void timer3_compc_isr(void){ }

interrupt [USART0_RXC] void usart0_rx_isr(void){}

interrupt [USART0_DRE] void usart0_dre_isr(void){}

interrupt [USART0_TXC] void usart0_tx_isr(void){}

interrupt [USART1_RXC] void usart1_rx_isr(void){}

interrupt [USART1_DRE] void usart1_dre_isr(void){}

i nterrupt [USART1_TXC] void usart1_tx_isr(void){}

interrupt [ADC_INT] void adc_isr(void){}

interrupt [ANA_COMP] void ana_comp_isr(void){}

interrupt [EE_RDY] void ee_rdy_isr(void){}

interrupt [SPI_STC] void spi_isr(void){}

interrupt [TWI] void twi_isr(void){}

interrupt [SPM_RDY] void spm_rdy_isr(void){}

AVR EDIT & AVRSTUDIO

#include <avr/interrupt.h>

ISR(INT0_vect){}

ISR(INT1_vect){}

ISR(INT2_vect){}

ISR(INT3_vect){}

ISR(INT4_vect){}

ISR(INT5_vect){}

ISR(INT6_vect){}

ISR(INT7_vect){}

ISR(TIMER0_OVF_vect){}

ISR(TIMER0_COMP_vect){}

ISR(TIMER1_OVF_vect){}

ISR(TIMER1_CAPT_vect){}

ISR(TIMER1_COMPA_vect){}

ISR(TIMER1_COMPB_vect){}

ISR(TIMER1_COMPC_vect){}

ISR(TIMER2_OVF_vect){}

ISR(TIMER2_COMP_vect){}

ISR(TIMER3_OVF_vect){}

ISR(TIMER3_CAPT_vect){}
ISR(TIMER3_COMPA_vect){}
ISR(TIMER3_COMPB_vect){}
ISR(TIMER3_COMPC_vect){}

ISR(USART0_RX_vect){}
ISR(USART0_UDRE_vect){}
ISR(USART0_TX_vect){}

ISR(USART1_RX_vect){}
ISR(USART1_UDRE_vect){}
ISR(USART1_TX_vect){}

ISR(ADC_vect){}
ISR(ANALOG_COMP_vect){}
ISR(EE_READY_vect){}
ISR(SPI_STC_vect){}
ISR(TWI_vect){}
ISR(SPM_READY_vect){}

ICC

#pragma interrupt_handler ext_int0_isr: iv_INT0
void ext_int0_isr(void){ }
#pragma interrupt_handler ext_int1_isr: iv_INT1
void ext_int1_isr(void){ }
#pragma interrupt_handler ext_int2_isr: iv_INT2
void ext_int2_isr(void){ }
#pragma interrupt_handler ext_int3_isr: iv_INT3
void ext_int3_isr(void){ }
#pragma interrupt_handler ext_int4_isr: iv_INT4
void ext_int4_isr(void){ }
#pragma interrupt_handler ext_int5_isr: iv_INT5
void ext_int5_isr(void){ }
#pragma interrupt_handler ext_int6_isr: iv_INT6
void ext_int6_isr(void){ }
#pragma interrupt_handler ext_int7_isr: iv_INT7
void ext_int7_isr(void){ }

#pragma interrupt_handler timer0_ovf_isr: iv_TIMER0_OVF
void timer0_ovf_isr(void){ }
#pragma interrupt_handler timer0_comp_isr: iv_TIMER0_COMP
void timer0_comp_isr(void){ }

#pragma interrupt_handler timer1_ovf_isr: iv_TIMER1_OVF
void timer1_ovf_isr(void){ }
#pragma interrupt_handler timer1_capt_isr: iv_TIMER1_CAPT
void timer1_capt_isr(void){ }
#pragma interrupt_handler timer1_compa_isr: iv_TIMER1_COMPA
void timer1_compa_isr(void){ }
#pragma interrupt_handler timer1_compb_isr: iv_TIMER1_COMPB
void timer1_compb_isr(void){ }
#pragma interrupt_handler timer1_compc_isr: iv_TIMER1_COMPC
void timer1_compc_isr(void){ }

#pragma interrupt_handler timer2_ovf_isr: iv_TIMER2_OVF
void timer2_ovf_isr(void){ }
#pragma interrupt_handler timer2_comp_isr: iv_TIMER2_COMP
void timer2_comp_isr(void){ }

#pragma interrupt_handler timer3_ovf_isr: iv_TIMER3_OVF
void timer3_ovf_isr(void){ }
#pragma interrupt_handler timer3_capt_isr: iv_TIMER3_CAPT
void timer3_capt_isr(void){ }
#pragma interrupt_handler timer3_compa_isr: iv_TIMER3_COMPA
void timer3_compa_isr(void){ }
#pragma interrupt_handler timer3_compb_isr: iv_TIMER3_COMPB
void timer3_compb_isr(void){ }
#pragma interrupt_handler timer3_compc_isr: iv_TIMER3_COMPC
void timer3_compc_isr(void){ }

#pragma interrupt_handler usart0_rx_isr: iv_USART0_RX
void usart0_rx_isr(void){ }
#pragma interrupt_handler usart0_dre_isr: iv_USART0_DRE
void usart0_dre_isr(void){ }
#pragma interrupt_handler usart0_tx_isr: iv_USART0_TX
void usart0_tx_isr(void){ }

#pragma interrupt_handler usart1_rx_isr: iv_USART1_RX
void usart1_rx_isr(void){ }
#pragma interrupt_handler usart1_dre_isr: iv_USART1_DRE
void usart1_dre_isr(void){ }
#pragma interrupt_handler usart1_tx_isr: iv_USART1_TX
void usart1_tx_isr(void){ }

#pragma interrupt_handler adc_isr: iv_ADC
void adc_isr(void){ }
#pragma interrupt_handler ana_comp_isr: iv_ANA_COMP
void ana_comp_isr(void){ }
#pragma interrupt_handler ee_rdy_isr: iv_EE_RDY
void ee_rdy_isr(void){ }
#pragma interrupt_handler spi_isr: iv_SPI_STC
void spi_isr(void){ }
#pragma interrupt_handler twi_isr: iv_TWSI
void twi_isr(void){ }
#pragma interrupt_handler spm_rdy_isr: iv_SPM_RDY
void spm_rdy_isr(void){ }

IAR

#pragma pack=INT0_vect

__interrupt void INT0_interrupt(void){ }
#pragma pack=INT1_vect
__interrupt void INT1_interrupt(void){ }
#pragma pack=INT2_vect
__interrupt void INT2_interrupt(void){ }
#pragma pack=INT3_vect
__interrupt void INT3_interrupt(void){ }
#pragma pack=INT4_vect
__interrupt void INT4_interrupt(void){ }
#pragma pack=INT5_vect
__interrupt void INT5_interrupt(void){ }
#pragma pack=INT6_vect
__interrupt void INT6_interrupt(void){ }
#pragma pack=INT7_vect
__interrupt void INT7_interrupt(void){ }

#pragma pack=TIMER3_CAPT_vect
__interrupt void TIMER3_CAPT_interrupt(void){ }
#pragma pack=TIMER3_COMPA_vect
__interrupt void TIMER3_COMPA_interrupt(void){ }
#pragma pack=TIMER3_COMPB_vect
__interrupt void TIMER3_COMPB_interrupt(void){ }
#pragma pack=TIMER3_COMPC_vect
__interrupt void TIMER3_COMPC_interrupt(void){ }
#pragma pack=TIMER3_OVF_vect
__interrupt void TIMER3_OVF_interrupt(void){ }
#pragma pack=TIMER2_COMP_vect
__interrupt void TIMER2_COMP_interrupt(void){ }
#pragma pack=TIMER2_OVF_vect
__interrupt void TIMER2_OVF_interrupt(void){ }
#pragma pack=TIMER1_CAPT_vect
__interrupt void TIMER1_CAPT_interrupt(void){ }
#pragma pack=TIMER1_COMPA_vect
__interrupt void TIMER1_COMPA_interrupt(void){ }
#pragma pack=TIMER1_COMPB_vect
__interrupt void TIMER1_COMPB_interrupt(void){ }
#pragma pack=TIMER1_COMPC_vect
__interrupt void TIMER1_COMPC_interrupt(void){ }
#pragma pack=TIMER1_OVF_vect
__interrupt void TIMER1_OVF_interrupt(void){ }
#pragma pack=TIMER0_COMP_vect
__interrupt void TIMER0_COMP_interrupt(void){ }
#pragma pack=TIMER0_OVF_vect
__interrupt void TIMER0_OVF_interrupt(void){ }

#pragma pack=USART1_RXC_vect
__interrupt void USART1_RXC_interrupt(void){ }
#pragma pack=USART1_vect
__interrupt void USART1_interrupt(void){ }
#pragma pack=USART1_TXC_vect
__interrupt void USART1_TXC_interrupt(void){ }
#pragma pack=USART0_RXC_vect
__interrupt void USART0_RXC_interrupt(void){ }
#pragma pack=USART0_UDRE_vect
__interrupt void USART0_UDRE_interrupt(void){ }
#pragma pack=USART0_TXC_vect
__interrupt void USART0_TXC_interrupt(void){ }

#pragma pack=ADC_vect
__interrupt void ADC_interrupt(void){ }

#pragma pack=ANA_COMP_vect
__interrupt void ANA_COMP_interrupt(void){ }

#pragma pack=SPI_STC_vect
__interrupt void SPI_STC_interrupt(void){ }

#pragma pack=TWI_vect
__interrupt void TWI_interrupt(void){ }

#pragma pack=EE_RDY_vect
__interrupt void EE_RDY_interrupt(void){ }

#pragma pack=SPM_RDY_vect
__interrupt void SPM_RDY_interrupt(void){ }


컴파일러

인터럽트 허가/금지

코드비젼

#asm("sei")

#asm("cli")

AVR EDIT & AVRSTUDIO

sei();

cli();

ICC

SEI();

CLI();

IAR

__enable_interrupt();

__disable_interrupt();


컴파일러

메인함수

코드비젼

void main(void){}

AVR EDIT & AVRSTUDIO

int main(void){}

ICC

void main(void){}

IAR

void main(void){}


컴파일러

FLASH

코드비젼

flash table[] = { 1, 2, 3 };

c= table[x];

i= table[x];

AVR EDIT & AVRSTUDIO

prog_uchar table[] = { 1, 2, 3 };

c=pgm_read_byte(&table[x]);

i=pgm_read_word(&table[x]);

ICC

__flash int table[] = { 1, 2, 3 };
__flash char hello[] = "Hello World";
__flash char *ptr1;
char * __flash ptr2;
__flash char * __flash ptr3;

IAR

__flash char str[] = {"abcdefg"};

__flash char str1[]={"12345"};

__flash char str2[]={"23456"};

char __flash * __flash *strP;

flash fdata[][100]={{0x02,0xf0,.......},{0x00,....}};
char flash *p ;

p = &fdata[0][0];


컴파일러

내부 EEPROM

코드비젼

eeprom int foo = 0x1234;
eeprom char table[] = { 0, 1, 2, 3, 4, 5 };

int i=3;

foo=i;

i-foo;

AVR EDIT & AVRSTUDIO

#include <avr/eeprom.h>

eeprom_write_dword((uint32_t*)0, i);

i= eeprom_read_dword((uint32_t*)0);

eeprom_write_byte((uint8_t*)EE_ADD, c);
c= eeprom_read_byte((uint8_t*)EE_ADD);
eeprom_write_dword((uint32_t*)EE_ADD, L);
L= eeprom_read_dword((uint32_t*)EE_ADD);

ICC

//Initializing EEPROM
#pragma data:eeprom
int foo = 0x1234;
char table[] = { 0, 1, 2, 3, 4, 5 };
#pragma data:data

//Accessing EEPROM
int i;
EEPROM_READ(0x1, i); // read 2 bytes into i
int i;
EEPROM_WRITE(0x1, i); // write 2 bytes to 0x1

EEPROMWriteBytes(int location, void *ptr, int size)
EEPROMReadBytes(int location, void *ptr, int size)

IAR

__eeprom int i;
int temp;
i=23; //write 23 to EEPROM
temp=i; //read from EEPROM into temp


컴파일러

delay

코드비젼

#include <delay.h>

delay_us(1000); // 1msec

delay_ms(1000); // 1sec

AVR EDIT & AVRSTUDIO

# define F_CPU 16000000UL

#include <util/delay.h>

_delay_us(1000); // 1msec

_delay_ms(1000); // 1sec

ICC

IAR


mega128 위주로 작성된 자료이므로 다른 다비이스에서는 내용이 다를 수 있습니다.

디바이스 헤더 파일 참고해서 맞는 것을 사용하세요

컴파일러를 모두 사용하는 것이 아니므로 일부 틀린 내용이 있을 수 있습니다.

또, 컴파일러 버전에 따라서 계속 변경 되는 부분이 발생 합니다.

잘못된 부분 / 빠진 부분/ 버전에 따라서 달라진 부분

아래 댓글로 알려주시면 수정 하겠습니다. ^^


반응형

'Study > 8-bit MCUs' 카테고리의 다른 글

B/T LED Control circuit  (0) 2017.04.10
led 제어 현재 상황  (0) 2016.02.26
pwm duty  (0) 2015.06.11
Atmega128을 이용하여 Duty 50%, 10[Khz] Clock을 출력하는 방법  (0) 2015.06.11
Atmega128 타이머 참고  (0) 2015.06.09

+ Recent posts