본문 바로가기
ATmega128

코드비젼/ AVR EDIT/ ICC/ AVRSTUDIO/ IAR/ 컴파일러 변경 비교

모카소년 2015. 9. 24. 16:15




 컴파일러

 비트표현

코드비젼

 

 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 위주로 작성된 자료이므로 다른 다비이스에서는 내용이 다를 수 있습니다.

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

 

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

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

 

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

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

 

출처 : 키트의 전자공작 (http://cafe.naver.com/circuitsmanual/998)

[출처] 코드비젼/ AVR EDIT/ ICC/ AVRSTUDIO/ IAR/ 컴파일러 변경시 참조 (! 전자공작) |작성자 키트


저작자표시 비영리 변경금지

'ATmega128' 카테고리의 다른 글

MCU와 ATmega128  (0) 2015.08.21

'ATmega128' Related Articles

티스토리툴바