asm-avr-uart

  Serial I/O(UART) Communication - ASM

Serial 통신은 병렬 형태의 데이터(보통 Byte 단위)를 직렬(Bit 단위)로 전환 하여 전송하고 수신 하기 때문에 병렬 통신에 비교 하여 속도는 느리다.

그러나 여러 개의 통신선(Bus)을 필요로 하는 병렬 통신에 비교 하여 최소 3개의 통신선(Tx, Rx, GND)만을 필요로 하기 때문에 서로 떨어져 있는 장치 사이에 용이하게 통신 선로를 구축 할 수 있다.

또한, 비동기 방식 통신은 서로 다른 Clock를 사용 하는 장치 사이에도 별도의 Clock 신호 없이(Clock를 사용 하지 않기 때문에 두 장치에서 미리 서로 약속한 속도(Baud Rate)로 송수신 하여야 한다.) 통신 할 수 있기 때문에 대부분의 Embedded Computer에서 기본 통신 장치로 제공(ATmega128에는 2개의 UART 통신 장치가 제공 됨) 된다.

---

• 두 장치(DCT와 DTE ) 사이에 UART(Universal Asynchronous Receiver/Transmitter) 통신을 하기 위한 구성도
• ATmega128의 USART(Universal Synchronous and Asynchronous Receiver/Transmitter) Block Diagram
• Baud Rate Generation Block
• Transmitter Block
• Receiver Block
• Control and Status Register
• ATmega128 Asynchronous Communication(UART)
• Serial frame format
• Asynchronous Clock Recovery
• Error detection
• 외부 장치와 UART 통신 구현에 필요한 Interface IC 예(MAX232)
• Serial Communication에 사용하는 Connector 예
• ATmega128 USART
• ATmega128 USART에 시용되는 Register
• USART Data Registers
• Baud Rate Registers
• UCSRnA(USART Control and Status Register A)
• UCSRnB(USART Control and Status Register B)
• UCSRnC(USART Control and Register C)
• ATmega128 UART 프로그램 예
• UART 통신를 위한 설정과 문자 Input/Output 프로그램 예
• UART 통신을 이용한 Microcontroller 제어 예
• UART 통신과 문자열(String) I/O을 이해 하기 위한 예
• UART Rx Interrupt를 이용한 제어 문자 입력과 LED shift 제어 프로그램 예
• Serial I/O(UART) Communication 관련 페이지 보기
• ATmega128 I/O Port - ASM
• Switch debouncing 과 Keypad Interfacing - ASM

---

두 장치(DCT와 DTE ) 사이에 UART(Universal Asynchronous Receiver/Transmitter) 통신을 하기 위한 구성도

• 쌍방향 통신(Full Duplex)을 위하여 DTE 의 Tx 신호와 DCE의 Rx 신호를 연결 하고, DTE의 Rx 신호와 DCE의 Tx 신호, 양측의 GND 신호를 연결 한다.
• 비 동기(Asynchronous) 방식 통신인 경우 Clock 신호는 필요 없다.
• 아래에 있는 UART 통신 프로그램 예(cho_uart_basic_i_o.c)에서는 PC를 DTE(PC에 직렬 통신을 위한 Console 프로그램을 설치 하여 사용 함) 장치로 사용 하고, 실험용 Embedded Computer에 통신 프로그램을 설치 하여 DCE로 이용 하였다.

• DTE(Data Terminal Equipment)
• DCE(Data Communication Equipment)

ATmega128의 USART(Universal Synchronous and Asynchronous Receiver/Transmitter) Block Diagram

USART Block은 Baud Rate 발생을 시키는 Block과, 병렬 Data를 직렬로 변환 하여 전송 하는 Transmitter Block, 직렬로 수신된 Data를 병렬로 변환 하여 수신 하는 Receiver Block으로 구성 되어 있고, 여기에 USART의 기능을 다양 하게(Programmable) 설정 할 수 있도록 하고, USART의 동작 상태(Status)를 표시 하는 기능 제어 및 상태 표시 Rg(Control and Status Register)가 포함 되어 있다. 이 페이지 에서는 비동기 통신(Asynchronous) 모드 만을 설명 하기 때문에 USART에서 동기 통신(Synchronous)을 뺀 UART 통신 모드에 데하여만 설명 한다.

• Baud Rate Generation Block
• Baud Rate Generation Block은 Baud Rate 설정 값을 저장 하고 있는 UBRR Rg(8 Bits Rg 2개(UBRRH, UBRRL)와 Baud rate 발생 회로로 구성 되어 있다.
• Baud Rate에 따른 UBRR Rg의 설정은 아래(UBRR register 값과 baud rates 예)를 참고 하기 바람.
• Baud Rate 설정 Coding 예
.def AC0 = r16 ; Accumulator Byte Rg 0 .def AC1 = r17 ; Accumulator Byte Rg 1 .equ FOSC = 16000000 // Clock Speed ; Generic Constant Structure .equ BAUD = 19200 // Baud rate 값(상수) .equ MYUBRR = FOSC/16/BAUD-1 // UBRR Rg에 설정 할 값(상수) 계산 ; Init USART ldi AC1, HIGH(MYUBRR) ldi AC0, LOW(MYUBRR) ; Set baud rate sts UBRR0H, AC1 out UBRR0L, AC0


• Transmitter Block
• Transmitter Block은 CPU로 부터 전송 할 Data를 받는 UDR(Transmit) Rg와 직렬 전송을 위하여 병렬로 받은 Data를 직렬로 변환 하는 Transmit shift Rg, Error 검출을 위한 Parity Bit를 발생 시키기 위한 Parity Generator로 구성 되어 있다.
• Data 전송을 위한 Coding 예

uart0의 초기화하는 함수

.def AC0 = r16 ; Accumulator Byte Rg 0 .def AC1 = r17 ; Accumulator Byte Rg 1 .def RG_ARG0_H = r25 ; Function Argument Word Rg 0 High .def RG_ARG0_L = r24 ; Function Argument Word Rg 0 Low .equ FOSC = 16000000 // Clock Speed ; Generic Constant Structure .equ BAUD = 19200 // Baud rate 값(상수) .equ MYUBRR = FOSC/16/BAUD-1 // UBRR Rg에 설정 할 값(상수) 계산 MAIN: .... ; Init USART ; Set Baud Rate : 19200( UBRR <- 51) ldi RG_ARG0_H, HIGH(MYUBRR) ldi RG_ARG0_L, LOW(MYUBRR) rcall USART_Init ; Init USART ; Calling Sequence ; RG_ARG0_H <- UBRRH ; RG_ARG0_L ,- UBRL ; rcall USART_Init USART_Init: ; Set baud rate sts UBRR0H, RG_ARG0_H out UBRR0L, RG_ARG0_L ; Enable receiver and transmitter ldi AC0, (1<<RXEN0)|(1<<TXEN0) out UCSR0B,AC0 ; Set frame format: 8data, 1stop bit ldi AC0, (0<<USBS0)|(3<<UCSZ00) sts UCSR0C,AC0 ret


uart0를 이용 하여 하나의 문자를 전송 하는 함수

; Calling Sequence ; RG_ARG0_L <- Transmit Data USART_Transmit: UART_putchar: ; Wait for empty transmit buffer sbis UCSR0A,UDRE0 rjmp USART_Transmit ; Put data (RG_ARG0_L) into buffer, sends the data out UDR0,RG_ARG0_L ret


• Receiver Block
• Receiver Block은 Rx Pin으로 부터 수신한 Data(Bit 단위로 수신)를 병렬로 변환 하는 Receive shift Rg와 병렬로 변환된 Data를 CPU 내의 Rg로 전송하는 UDR(Receive) Rg, 수신한 Data의 Error 발생 여부를 체크 하는 Parity Checker 회로로 구성 되어 있다.
• Data 수신을 위한 Coding 예(초기화 함수는 윗 void uart0_init(void)를 이용)

uart0로 부터 하나의 문자를 수신 하는 함수

; Calling Sequence ; RG_ARG0_L : Received Data USART_Receive: UART_getchar: ; Wait for data to be received sbis UCSR0A, RXC0 rjmp USART_Receive ; Get and return received data from buffer in RG_ARG0_L, UDR0 ret


• Control and Status Register
• ATmega128 Chip은 UCSRA, UCSRB,UCSRC 3개의 Control and Status Register(Control Rg)를 갖고 있다. Control Rg 에 대한 설명은 아래 Control Rg 부분을 참고 하기 바람.

ATmega128 Asynchronous Communication(UART)

• Serial frame format

• Every frame will have at least
• 1 start bit
• data bits (5,6,7,8 or 9)
• 1-2 stop bit
• Parity is optional


• Asynchronous Clock Recovery

• 비 동기 모드에서 정확한 Data 수신을 위한 Clock Recovery와 Start Bit Sampling
• Start Bit 를 Sampling 하기 위하여 16배(or 8배)(Normal mode 인 경우 16배, Double Speed mode 인 경우에는 8배) 속도의 내부 Clock를 사용 한다.
• 중간 부분에서 3번 Sampling 하여 2개 이상이 0 이면 0, 2개 이상이 1이면 1로 결정 한다.


• Error detection
• Parity Error

• Data bits의 XOR에 의하여 Parity Bit를 생성 한다.
• Parity는 Even 과 Odd Parity 로 구분 한다.
• Peven= dn XOR dn-1 XOR dn-2 ........ XOR d0 XOR 0
• Podd = dn XOR dn-1 XOR dn-2 ........ XOR d0 XOR 1
• Frame Error

• Stop Bit 가 발견 되지 않는 경우
• 첫 번째 Stop bit가 0으로 검출되는 경우
• Data Overrun Error
• 수신 버퍼에 현재 읽지 않은 데이터가 들어있는 상태에서 새로운 데이터가 수신 완료되고, 그 다음 수신 데이터인 Start bit가 검출된 경유


• 외부 장치와 UART 통신 구현에 필요한 Interface IC 예(MAX232)

• Logic(0,1)의 전압 발생
• TTL Logic : 0V, 5V
• RS-232 : -12V, +12V
• MAX232 : Negative와 Positive 전압을 발생 시키는 Charge pump 기능을 포함 함.


• Serial Communication에 사용하는 Connector 예

• 간단한 RS232 Cable 연결 예



• ATmega128 USART
• USART : UART 의 기능과 Synchronous Communication을 포함 하고 있다.
• Asynchronous (UART): Universal Asynchronous Receiver and Transmitter
• 두 장치간에 clock 을 공유 하지 않는다.
• Synchronous: clock 을 공유 한다.
• Baud rate : 매 초간 전달(수신, 송신)되는 Symbol의 수
• Data rate : 매 초간 전달(수신, 송신)되는 Data 수
• Data rate = Baud rate / Frame Bits(Data Bits + Start,Stop, Parity Bits)
• ATmega128 USART Pin
• USART0 : Port E 사용
• PE0: Receive Pin
• PE1: Transmit Pin
• PE2: External Clock
• USART1 : Port D 사용
• PD2: Receive Pin
• PD3: Transmit Pin
• PD5: External Clock

ATmega128 USART에 시용되는 Register

• USART Data Registers
• UDRn: 8-bit Data Register

• UDRn(Usart 0,1 I/O Data Register)
• UDRn 레지스터는 송/수신되는 데이터 값을 저장하는 버퍼 역할을 하게 된다.
• UDRn은 TXBn(송신버퍼)/RXBn(수신버퍼) 레지스터로 구성되고, 같은 I/O 주소를 갖는다.
• 송신할 때는 UDRn(Read)에 데이터를 Write 하고,
• 수신할 때는 UDRn(Write)의 테이터를 Read 한다.
• UDRn(Read)와 UDRn(Write)은 같은 이름을 사용 하지만 별개의 Rg 이다. Read 동작에서는 UDRn(Read) Rg를 읽고, Write 동작에서는 UDRn(Write) Rg에 Data를 Write 한다.


• Baud Rate Registers
• UBRRnH and UBRRnL: Baud Rate Registers


2개의 8-bit registers를 사용 한다.(n은 USART 번호로 0 또는 1)

• USART internal clock 은 UBRR register에 의하여 설정 된다.
• 12 bits Baud Rate Rg UBRR의 값은
• UBRR = (System Clock / 16XBaud Rate) – 1 식으로 구한다.

주의 : UBBRnH Write 후 UBBRnL를 나중에 Write 하여야 한다.

• UBRR register 값과 baud rates 예



• UCSRnA(USART Control and Status Register A)

• Bit 7 – RXCn(USART Receive Complete Flag)
• Receive Buffer에 읽지 않은 Data가 있을 때 Set 되고,
• Receive Buffer 가 비어 있을 때 Clear 된다.
• Receive Disabled 되면 이 Buffer는 Flushed 되고,
• RXCn Flag는 Clear(Zero) 된다.
• RX Complete Interrupt Enable 상태 일 경우 이 Flag 가 Set 되면 RX Complete Interrupt 가 발생 된다.
• Bit 6 – TXCn(USART Transmit Complete Flag)
• Transmit buffer(UDRn)에 전송된 Data 가 Transmit Shift Register에서 shifted out 되어 전송을 위한 새로운 Data를 받을 수 있는 상태가 되면 이 Flag 가 Set 된다.
• TX Complete Interrupt Enable 상태에서 Transmit complete interrupt 이 실행 되면 이 Falg는 자동으로 Clear 된다.
• TX Complete Interrupt를 사용 하지 않는 경우에는 이 Bit에 1을 쓰는 방법으로 이 Flag를 Clear 할 수 있다.
• TX Complete Interrupt Enable 상태 일 경우 이 Flag 가 Set 되면 TX Complete Interrupt 가 발생 된다.
• Bit 5 – UDREn(USART Data Register Empty Flag)
• Flag는 Transmit buffer(UDRn)의 상태를 표시 한다.
• 이 Flag가 1(Set)인 경우 Transmit buffer(UDRn)가 Empty 상태이기 때문에 전송을 위하여 새 Data를 받을 수 있다.
• Data Register Empty Interrupt Enable 상태 일 경우 이 Flag 가 Set 되면 Data Register Empty Interrupt 가 발생 된다.
• Bit 4 – FEn(USART Frame Error)
• Bit 3 – DORn(USART Data Overrun Error)
• Bit 2 – UPEn(USART Parity Error)
• Bit 1 – U2Xn(Double the USART Transmission Speed)
• U2Xn = 1 : 비동기 모드에서 클럭의 분주비를 16에서 8로 낮추어 전송속도를 2배 높이는 기능.
• Bit 0 – MPCMn(USART Multi-Processer Communication Mode)


• UCSRnB(USART Control and Status Register B)

• Bit 7 – RXCIEn(USART RX Complete Interrupt Enable)
• SREG의 Global interrupt flag 가 Set 되고,
• 이 Bit가 Set된 상태(RX Complete Interrupt Enable)에서,
• RXC flag가 Set 되면 RX Complete Interrupt가 발생 한다.
• RX Complete Interrupt Routine에서 UDRn(Read) Data를 읽어서 사용 할 수 있다.
• Bit 6 – TXCIEn(USART TX Complete Interrupt Enable)
• SREG의 Global interrupt flag 가 Set 되고,
• 이 Bit가 Set된 상태(TX Complete Interrupt Enable)에서,
• TXC flag가 Set 되면 TX Complete Interrupt가 발생 한다.
• TX Complete Interrupt Routine에서 UDRn(Write)에 전송 할 Data를 쓸 수 있다.
• Bit 5 – UDRIEn(USART Data Register Empty Interrupt Enable)
• SREG의 Global interrupt flag 가 Set 되고,
• 이 Bit가 Set된 상태(Data Register Empty Interrupt Enable)에서,
• UDREn flag가 Set 되면 Data Register Empty Interrupt가 발생 한다.
• Data Register Empty Interrupt Routine에서 UDRn(Write)에 전송 할 Data를 쓸 수 있다.
• Bit 4 – RXENn(USART Receiver Enable)
• 이 Bit가 Set 되면 USARTn Receiver가 Enable(사용 할 수 있는 상태) 된다.
• 이 Bit가 Set 되면 RxDn와 공통으로 이 Pin을 사용 하는 I/O Port는 이 Pin을 사용 할 수 없다.
• 이 Bit을 Clear(Receiver Disable) 하면 Receive buffer(UDRn(Read))는 Flush 된다.
• Bit 3 – TXENn(USART Transmitter Enable)
• 이 Bit가 Set 되면 USARTn Transmitter가 Enable(사용 할 수 있는 상태) 된다.
• 이 Bit가 Set 되면 TxDn와 공통으로 이 Pin을 사용 하는 I/O Port는 이 Pin을 사용 할 수 없다.
• 이 Bit을 Clear(Transmitter Disable) 하여도 현재 전송 중인 Data는 전송이 완료 된다.
• Bit 2 – UCSZn2(USART Character Size)
• UCSTnC 의 UCSZn1:0 와 함께 사용 함.
• Bit 1 – RXB8n(USART Receive Data Bit 8)
• Bit 0 – TXB8n(USART Transmit Data Bit 8)


• UCSRnC(USART Control and Register C)

• Bit 6 – USMSELn(USART Mode Select)
• USMSELn = 1 : 동기전송모드
• USMSELn = 0 : 비동기전송모드
• Bit 5, 4 – UPMn1, UPMn0(USART Parity Mode)

• Bit 3 – USBSn(USART Stop Bit Select)
• USBSn = 0 : 1 Stop bits
• USBSn = 1 : 2 Stop bits
• Bit 2, 1 – UCSZn1, UCSZn0 : 아래 "Character Size" 참고요
• Bit 0 – UCPOLn(USART Clock Polarity)
• 동기 전동 모드에서만 사용.
• UCPOLn = 1 : 송신데이터는 XCKn Clock Falling Edge에서, 출력 수신데이터는 XCKn Clock Rising Edge 에서 검출
• UCPOLn = 0 : 송신데이터는 XCKn Clock Rising Edge 에서, 출력 수신데이터는 XCKn Clock Falling Edge에서 검출
• Character Size : UCSZn2(UCSRnB: Bit2), UCSZn1(UCSRnC: Bit2), UCSZn0(UCSRnC: Bit1)

• UCSZn2, UCSZn1, UCSZn0의 설정에 따라 5-9Bits 로 결정 된다.

ATmega128 UART 프로그램 예:

• UART 통신를 위한 설정과 문자 Input/Output 프로그램 예

UART 통신 실험을 위한 회로 구성 예


• UART 통신를 위한 설정과 문자를 Input/Output 하는 프로그램 예: AVR_asm_usart_io_basic.zip
; [Add Project title here] ; ; Author: Your Name Here ; Lab: ; Date: 2022. 00. 00 .NOLIST .include "m128def.inc" ; Definition file for ATmega128 ; Interrupt Vectors Table ;.include "avr128_interrupt_table.inc" ; [Add all hardware information here] .DEVICE ATmega128 .LIST ; Program Constants .equ const = $00 ; Generic Constant Structure ; ; Program Variables Definitions .def AC0 = r16 ; Accumulator Byte Rg 0 .def AC1 = r17 ; Accumulator Byte Rg 1 .def RG_ARG0_H = r25 ; Function Argument Word Rg 0 High .def RG_ARG0_L = r24 ; Function Argument Word Rg 0 Low .equ CR = $0d .equ LF = $0a .equ FOSC = 16000000 // Clock Speed ; Generic Constant Structure .equ BAUD = 19200 // Baud rate 값(상수) .equ MYUBRR = FOSC/16/BAUD-1 // UBRR Rg에 설정 할 값(상수) 계산 ; SRAM Definitions .DSEG .ORG 0x0100 ;vgByte: .BYTE 1 ; Reserve 1 Byte to Global Variable ;vgWord: .BYTE 2 ; Reserve 2 Byte to Global Variable .CSEG ; ; Func: RESET Handler Routine RESET: ; Stack Pointer Init ldi AC0, LOW(RAMEND) out SPL, AC0 ldi AC0, HIGH(RAMEND) out SPH, AC0 rjmp MAIN ; Main Entry into program MAIN: ; Insert your program Here ; Init USART ; Set Baud Rate : 19200( UBRR <- 51) ldi RG_ARG0_H, HIGH(MYUBRR) ldi RG_ARG0_L, LOW(MYUBRR) rcall USART_Init ldi ZL, LOW(mesg1 << 1) ; Byte Address <- Word Address ldi ZH, HIGH(mesg1 << 1) rcall MesgOut ldi RG_ARG0_L, CR rcall UART_putchar ldi RG_ARG0_L, LF rcall UART_putchar loop: rcall USART_Receive rcall USART_Transmit cpi RG_ARG0_L, CR brne loop ldi RG_ARG0_L, LF rcall UART_putchar rjmp loop ; Calling Sequence ; RG_ARG0_H <- UBRRH ; RG_ARG0_L ,- UBRL ; rcall USART_Init ; Init USART USART_Init: ; SREG(Status Register)와 서브루틴에서 사용하는 Rg를 스택에 Save 한다. push AC0 ; Subroutine에서 사용할 AC0 Rg를 Save 한다. in AC0, SREG ; SREG 값을 갖어온다. push AC0 ; SREG Rg 값을 Save 한다. ; Set baud rate sts UBRR0H, RG_ARG0_H out UBRR0L, RG_ARG0_L ; Enable receiver and transmitter ldi AC0, (1<<RXEN0)|(1<<TXEN0) out UCSR0B,AC0 ; Set frame format: 8data, 1stop bit ldi AC0, (0<<USBS0)|(3<<UCSZ00) sts UCSR0C,AC0 pop AC0 ; SREG Rg 값을 Load 한다. out SREG, AC0 ; SREG Rg를 Restore 한다. pop AC0 ; AC0 Rg 값을 Restore 한다. ret ; Calling Sequence ; RG_ARG0_L <- Transmit Data USART_Transmit: UART_putchar: ; Wait for empty transmit buffer sbis UCSR0A,UDRE0 rjmp USART_Transmit ; Put data (RG_ARG0_L) into buffer, sends the data out UDR0,RG_ARG0_L ret ; Calling Sequence ; RG_ARG0_L : Received Data USART_Receive: UART_getchar: ; Wait for data to be received sbis UCSR0A, RXC0 rjmp USART_Receive ; Get and return received data from buffer in RG_ARG0_L, UDR0 ret ; Calling Sequence ; Z <- String Address ; rcall OutString OutString: ld RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndOutString rcall UART_putchar rjmp OutString EndOutString: ret ; Calling Sequence ; Z <- String Address ; rcall MesgOut from Program Memory MesgOut: lpm RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndMesgout rcall UART_putchar rjmp MesgOut EndMesgOut: ret ; Allocata byte(s) of storage with initialized values mesg1: .DB "USART Test",0x00,0x00

• 실험을 위한 준비
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 RXD와 Atmega128의 TXD0(PE1)를 연결한다.
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 TXD와 Atmega128의 RXD0(PE0)를 연결한다.

주: 컴퓨터에 Serial Port가 없는 경우 "USB --> UART(RS232) 변환 모듈"를 사용(USB Port를 Serial Port로 변환)하여 연결한다. 개발보드에 따라서는 "USB --> UART(RS232) 변환 모듈"을 내장하고 있는 경우가 많기 때문에 본인이 사용하는 개발보드에서 확인 하여야 한다.

참고자료: USB - Serial 변환 모듈

• 컴퓨터(USB --> UART(RS232)의 GND와 Atmega128의 GND를 연결한다. "USB --> UART(RS232) 변환 모듈"를 사용하는 경우 변환 모듈의 GND와 Atmega128의 GND를 연결한다.
• 실험 방법
• Project(Project name: AVR_asm_usart_io_basic)를 생성 한다.
• 위 프로그램을 main.asm에 복사하고 저장한다.
• Build → Build Solution 를 실행 하면 main.asm File 이 Assemble 되어 AVR_asm_usart_io_basic.hex 파일이 생성된다.
• AVR_asm_usart_io_basic.hex 파일을 Target Board에 Upload 하고 프로그램을 실행한다.

주: 모니터 프로그램(예: OC-Console, Tera Term)과 hex 파일을 Target Board에 Upload 하는 프로그램이 동일한 Port를 사용하기 때문에 모니터 프로그램을 중지하고 Upload를 실행하여야 한다.

• 모니터 프로그램(예: OC-Console, Tera Term)을 설치(이미 설치되어 있는 경우에는 실행만 하면됨)하고 실행 한다.
• 모니터 프로그램에서 필요한 설정(Serial Port와 Baudrate 등을 설정)을 한다.
• 실험:
• 개발 보드의 Reset SW를 누르면 모니터에 "UART0 Testing..." 메세지가 출력된다.
• 모니터에서 문자를 입력하면 입력된 문자는 UART 통신을 이용하여 개발보드에 전송된다.
• 개발보드에 전송된 문자는 다시 UART 통신을 이용하여 모니터에 출력된다.

참고자료: GCC asm 프로그램 예: GCC_asm_usart_io_basic.zip

• UART 통신을 이용한 Microcontroller 제어 예
• UART 통신을 이용하여 Microcontroller를 제어 하는 프로그램 예: AVR_asm_led_usart_shift.zip
; [Add Project title here] ; ; Author: Your Name Here ; Lab: ; Date: 2000. 00. 00 .NOLIST .include "m128def.inc" ; Definition file for ATmega128 ; Interrupt Vectors Table ;.include "avr128_interrupt_table.inc" ; [Add all hardware information here] .DEVICE ATmega128 .LIST ; Program Constants .equ const = $00 ; Generic Constant Structure ; ; Program Variables Definitions .def AC0 = r16 ; Accumulator Byte Rg 0 .def AC1 = r17 ; Accumulator Byte Rg 1 .def RG_ARG0_H = r25 ; Function Argument Word Rg 0 High .def RG_ARG0_L = r24 ; Function Argument Word Rg 0 Low .def SHIFT_DIR = r19 ; .equ CR = $0d .equ LF = $0a .equ FOSC = 16000000 // Clock Speed ; Generic Constant Structure .equ BAUD = 19200 // Baud rate 값(상수) .equ MYUBRR = FOSC/16/BAUD-1 // UBRR Rg에 설정 할 값(상수) 계산 ; SRAM Definitions .DSEG .ORG 0x0100 ;vgByte: .BYTE 1 ; Reserve 1 Byte to Global Variable ;vgWord: .BYTE 2 ; Reserve 2 Byte to Global Variable ;vgDWord: .BYTE 4 ; Reserve 4 Byte to Global Variable ;mesg1: .DB "USART Test",0x00 ; Allocata byte(s) of storage with initialized values .CSEG ; ; Func: RESET Handler Routine RESET: ; Stack Pointer Init ldi AC0, LOW(RAMEND) out SPL, AC0 ldi AC0, HIGH(RAMEND) out SPH, AC0 rjmp MAIN ; Main Entry into program MAIN: ; I/O Port Init ser AC0 sts DDRF, AC0 ; PORTF : Output Port, Memory Mapped I/O Port clr AC0 sts PORTF, AC0 ; LED Turn OFF ; Init USART ; Set Baud Rate : 19200 ldi RG_ARG0_H, HIGH(MYUBRR) ldi RG_ARG0_L, LOW(MYUBRR) rcall USART_Init ldi ZL, LOW(mesg1 << 1) ; Byte Address <- Word Address ldi ZH, HIGH(mesg1 << 1) rcall MesgOut ldi RG_ARG0_L, CR rcall UART_putchar ldi RG_ARG0_L, LF rcall UART_putchar clr SHIFT_DIR ; Shift Direction 초기화(Up 방향) ldi AC1, 1 ; Shift Data 초기화 loop: sts PORTF, AC1 ; PORTF : Memory Mapped I/O Port ldi AC0, 200 ; 200mSec Delay rcall mSecDelay ; Test for data to be received sbic UCSR0A, RXC0 rcall getchar_set_dir SET_DIR: ; SHIFT_DIR Rg의 값에 따라 회전 방향을 설정 한다. and SHIFT_DIR,SHIFT_DIR breq ROT_LEFT ROT_RIGHT: ; Down 방향 clc ror AC1 brcc LOOP ror AC1 rjmp LOOP ; Loop Indefinitly ROT_LEFT: ; Up 방향 clc rol AC1 brcc LOOP rol AC1 rjmp LOOP ; Loop Indefinitly // UART로 부터 하나의 문자를 읽고 // 만약 이 문자가 L 인 경우에는 Up 방향으로 회전 하도록 설정 하고 // 만약 이 문자가 R 인 경우에는 Down 방향으로 회전 하도록 설정 한다. getchar_set_dir: push AC0 in RG_ARG0_L, UDR0 push RG_ARG0_L rcall UART_putchar ldi RG_ARG0_L, CR rcall UART_putchar pop RG_ARG0_L cpi RG_ARG0_L, 'L' ; breq DIR_UP cpi RG_ARG0_L, 'l' ; breq DIR_UP cpi RG_ARG0_L, 'R' ; breq DIR_DOWN cpi RG_ARG0_L, 'r' ; breq DIR_DOWN pop AC0 ret DIR_DOWN: ; 만약 문자 R or r 이 입력된 경우 Down 방향 ser SHIFT_DIR pop AC0 ret DIR_UP: ; 만약 문자 L or l 이 입력된 경우 Up 방향 clr SHIFT_DIR pop AC0 ret ; Calling Sequence ; RG_ARG0_H <- UBRRH ; RG_ARG0_L ,- UBRL ; rcall USART_Init USART_Init: ; SREG(Status Register)와 서브루틴에서 사용하는 Rg를 스택에 Save 한다. push AC0 ; Subroutine에서 사용할 AC0 Rg를 Save 한다. in AC0, SREG ; SREG 값을 갖어온다. push AC0 ; SREG Rg 값을 Save 한다. ; Set baud rate sts UBRR0H, RG_ARG0_H out UBRR0L, RG_ARG0_L ; Enable receiver and transmitter ldi AC0, (1<<RXEN0)|(1<<TXEN0) out UCSR0B,AC0 ; Set frame format: 8data, 1stop bit ldi AC0, (0<<USBS0)|(3<<UCSZ00) sts UCSR0C,AC0 pop AC0 ; SREG Rg 값을 Load 한다. out SREG, AC0 ; SREG Rg를 Restore 한다. pop AC0 ; AC0 Rg 값을 Restore 한다. ret ; Calling Sequence ; RG_ARG0_L <- Transmit Data USART_Transmit: UART_putchar: ; Wait for empty transmit buffer sbis UCSR0A,UDRE0 ; sbis 0x0b,UDRE rjmp USART_Transmit ; Put data (RG_ARG0_L) into buffer, sends the data out UDR0,RG_ARG0_L ret ; Calling Sequence ; RG_ARG0_L : Received Data USART_Receive: UART_getchar: ; Wait for data to be received sbis UCSR0A, RXC0 ; sbis 0x0b, RXC rjmp USART_Receive ; Get and return received data from buffer in RG_ARG0_L, UDR0 ret ; Calling Sequence ; Z <- String Address ; rcall OutString OutString: ld RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndOutString rcall UART_putchar rjmp OutString EndOutString: ret ; Calling Sequence ; Z <- String Address ; rcall MesgOut from Program Memory MesgOut: lpm RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndMesgout rcall UART_putchar rjmp MesgOut EndMesgOut: ret mesg1: .DB "UART: LED Rotation Control",CR,LF,"L -> Left R -> Right",CR,LF,0x00,0x00 ; Passing Argument ; AC0 : N 100mSec ; Return Value : Void mSec100Delay: push AC0 push AC1 mov AC1,AC0 ldi AC0, 100 ; m100LOOP: rcall mSecDelay ; 100mSec dec AC1 ; brne m100LOOP ; pop AC1 pop AC0 ret ; Passing Argument ; AC0 : N mSec ; Return Value : Void mSecDelay: push AC0 push AC1 mov AC1,AC0 ldi AC0, 250 ; mLOOP: rcall uSecDelay ; 250uSec + rcall uSecDelay ; 250uSec + rcall uSecDelay ; 250uSec + rcall uSecDelay ; 250uSec = 1mSec dec AC1 ; brne mLOOP ; pop AC1 ; pop AC0 ; ret ; Passing Argument ; AC0 : N uSec ; Return Value : Void uSecDelay: push AC0 ; 2 cycle uLOOP: push AC0 ; 2 cycle + pop AC0 ; 2 cycle + push AC0 ; 2 cycle + pop AC0 ; 2 cycle + push AC0 ; 2 cycle + pop AC0 ; 2 cycle + nop ; 1 cycle + dec AC0 ; 1 cycle + brne uLoop ; 1 cycle = (15 + M1) cycle * 0.0625uSec = 1uSec pop AC0 ; 2 cycle ret

• 실험을 위한 준비
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 RXD와 Atmega128의 TXD0(PE1)를 연결한다.
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 TXD와 Atmega128의 RXD0(PE0)를 연결한다.

주: 컴퓨터에 Serial Port가 없는 경우 "USB --> UART(RS232) 변환 모듈"를 사용(USB Port를 Serial Port로 변환)하여 연결한다. 개발보드에 따라서는 "USB --> UART(RS232) 변환 모듈"을 내장하고 있는 경우가 많기 때문에 본인이 사용하는 개발보드에서 확인 하여야 한다.

참고자료: USB - Serial 변환 모듈

• 컴퓨터(USB --> UART(RS232)의 GND와 Atmega128의 GND를 연결한다. "USB --> UART(RS232) 변환 모듈"를 사용하는 경우 변환 모듈의 GND와 Atmega128의 GND를 연결한다.
• 실험 방법
• Project(Project name: AVR_asm_led_usart_shift)를 생성 한다.
• 위 프로그램을 main.asm에 복사하고 저장한다.
• Build → Build Solution 를 실행 하면 main.asm File 이 Assemble 되어 AVR_asm_led_usart_shift.hex 파일이 생성된다.
• AVR_asm_led_usart_shift.hex 파일을 Target Board에 Upload 하고 프로그램을 실행한다.

주: 모니터 프로그램(예: OC-Console, Tera Term)과 hex 파일을 Target Board에 Upload 하는 프로그램이 동일한 Port를 사용하기 때문에 모니터 프로그램을 중지하고 Upload를 실행하여야 한다.

• 모니터 프로그램(예: OC-Console, Tera Term)을 설치(이미 설치되어 있는 경우에는 실행만 하면됨)하고 실행 한다.
• 모니터 프로그램에서 필요한 설정(Serial Port와 Baudrate 등을 설정)을 한다.
• 실험:
• 개발 보드의 Reset SW를 누르면 모니터에 "UART: LED Rotation Control" 메세지가 출력된다.
• 모니터에서 L 문자를 입력하면 LED가 좌측으로 회전하고 R 문자를 입력하면 LED가 우측으로 회전한다.
• UART 통신과 문자열(String) I/O을 이해 하기 위한 예
• UART 통신과 문자열(String) I/O 프로그램 예: AVR_asm_usart_string_io.zip
// USART Test // // Author: chowk // Lab: KHU // Date: 2022. 8. 20 # ifndef atmega128 #define atmega128 # endif #define FOSC 16000000// Clock Speed #include <avr/io.h> // Definition file for ATmega128 #include "cho_asm_io_def.h" // I/O Port Definition for ATmega128 // SRAM Definitions #define _SFR_OFFSET 0 // Needed to subtract 0x20 from I/O addresses // [Add all hardware information here] // Program Constants // Program Variables Definitions #define RG_TEMP r0 // Temporary Register #define RG_ZERO r1 // Zero #define AC0 r16 // Accumulator Byte Rg 0 #define AC1 r17 // Accumulator Byte Rg 1 #define AC2 r18 // Accumulator Byte Rg 2 #define AC3 r19 // Accumulator Byte Rg 3 #define ACW0_L r2 // Accumulator Word Rg 0 Low #define ACW0_H r3 // Accumulator Word Rg 0 High #define ACW1_L r4 // Accumulator Word Rg 1 Low #define ACW1_H r5 // Accumulator Word Rg 1 High #define ACW2_L r6 // Accumulator Word Rg 2 Low #define ACW2_H r7 // Accumulator Word Rg 2 High #define ACW3_L r8 // Accumulator Word Rg 3 Low #define ACW3_H r9 // Accumulator Word Rg 3 High #define RG_ARG0_H r25 // Function Argument Word Rg 0 High #define RG_ARG0_L r24 // Function Argument Word Rg 0 Low #define RG_ARG1_H r23 // Function Argument Word Rg 1 High #define RG_ARG1_L r22 // Function Argument Word Rg 1 Low #define RG_ARG2_H r21 // Function Argument Word Rg 2 High #define RG_ARG2_L r20 // Function Argument Word Rg 2 Low #define CR 0x0d #define LF 0x0a #define BAUD 19200 // Baud rate 값(상수) #define MYUBRR (FOSC/16/BAUD-1) // UBRR Rg에 설정 할 값(상수) 계산식 #define IN_BUFFER_SIZE 16 .section .data .ORG 0x0000 // Compiler 가 OffSet 0x0100을 더하기 때문에 실제 번지는 0x0100 이 된다. //mesg1: .asciz "Input New String: " // Allocata byte(s) of storage with initialized values //mesg_input_buffer_error: .asciz " Input Buffer Overflow Error" input_buffer: .space IN_BUFFER_SIZE ; Reserve 16 Byte to Global Variable //cByte: .byte 0x00 // Allocata byte(s) of storage with initialized values //cWord: .word 0x0000 // Allocata word(s) of storage with initialized values //cLongWord: .long 0x00000000 // Allocata 32-bit long word(s) of storage with initialized values //mesg1: .space MSEG_SIZE .global UART_Init,UART_Transmit,UART_Receive .global OutString .section .text .global main // My Main Entry into program main: // Init USART // Set Baud Rate : 19200( UBRR <- 51) ldi RG_ARG0_H, hi8(MYUBRR) ldi RG_ARG0_L, lo8(MYUBRR) rcall UART_Init loop: ldi RG_ARG0_L, lo8(mesg1) ldi RG_ARG0_H, hi8(mesg1) rcall OutString ldi RG_ARG0_L, lo8(input_buffer) ldi RG_ARG0_H, hi8(input_buffer) ldi RG_ARG1_L, IN_BUFFER_SIZE rcall InString ldi RG_ARG0_L, CR rcall UART_putchar ldi RG_ARG0_L, LF rcall UART_putchar ldi RG_ARG0_L, lo8(input_buffer) ldi RG_ARG0_H, hi8(input_buffer) rcall OutString ldi RG_ARG0_L, CR rcall UART_putchar ldi RG_ARG0_L, LF rcall UART_putchar rjmp loop // Loop Indefinitly ; Calling Sequence ; RG_ARG0_H <- UBRRH ; RG_ARG0_L ,- UBRL ; rcall USART_Init ; C Function : void USART_Init(unsigned int); UART_Init: push AC0 ; Set baud rate sts UBRR0H, RG_ARG0_H out ASM_UBRR0L, RG_ARG0_L ; Enable receiver and transmitter ldi AC0, (1<<RXEN)|(1<<TXEN) out ASM_UCSR0B,AC0 ; Set frame format: 8data, 1stop bit ldi AC0, (0<<USBS)|(3<<UCSZ0) sts UCSR0C,AC0 pop AC0 ret ; Calling Sequence ; RG_ARG0_L <- Transmit Data ; C Function : void UART_putchar(unsigned char); UART_Transmit: UART_putchar: ; Wait for empty transmit Rg sbis ASM_UCSR0A,UDRE rjmp UART_Transmit ; Put data (AC0) into transmit Rg out ASM_UDR0,RG_ARG0_L ret ; Return Value ; RG_ARG0_L : Received Data ; RG_ARG0_H : zero ; C Function : unsigned char UART_getchar(void); UART_Receive: UART_getchar: ; Wait for data to be received sbis ASM_UCSR0A, RXC rjmp UART_Receive ; Get received data in RG_ARG0_L, ASM_UDR0 clr RG_ARG0_H ret ; Calling Sequence ; RG_ARG0_L <- String Buffer Starting Address : Low Byte ; RG_ARG0_H <- String Buffer Starting Address : High Byte ; RG_ARG1_L <- Buffer Size ; rcall InString ; C Function : void InString(char *, char ); InString: push AC0 push ZL push ZH mov ZL, RG_ARG0_L mov ZH, RG_ARG0_H mov AC0, RG_ARG1_L InStringLoop: rcall UART_getchar cpi RG_ARG0_L, CR breq EndInString st Z+, RG_ARG0_L rcall UART_putchar dec AC0 breq BUF_OV rjmp InStringLoop BUF_OV: ; Input Buffer Overflow clr RG_ARG0_L ; End String st -Z, RG_ARG0_L ldi RG_ARG0_L, lo8(mesg_input_buffer_error) ldi RG_ARG0_H, hi8(mesg_input_buffer_error) rcall OutString rjmp EndString EndInString: clr RG_ARG0_L ; End String st Z, RG_ARG0_L EndString: pop ZH pop ZL pop AC0 ret ; Calling Sequence ; RG_ARG0_L <- Char String Starting Address : Low Byte ; RG_ARG0_H <- Char String Starting Address : High Byte ; rcall OutString ; C Function : void OutString(char *); OutString: push ZL push ZH mov ZL, RG_ARG0_L mov ZH, RG_ARG0_H OutString1: ld RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndOutString rcall UART_putchar rjmp OutString1 EndOutString: pop ZH pop ZL ret // Calling Sequence // RG_ARG0_L <- Char String Starting Address : Low Byte // RG_ARG0_H <- Char String Starting Address : High Byte // rcall MesgOut from Program Memory MesgOut: push ZL push ZH mov ZL, RG_ARG0_L mov ZH, RG_ARG0_H MesgOut1: lpm RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndMesgout rcall UART_putchar rjmp MesgOut1 EndMesgout: pop ZH pop ZL ret // Messege mesg1: .asciz "Input New String: " mesg_input_buffer_error: .asciz " Input Buffer Overflow Error" .end

• 실험을 위한 준비
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 RXD와 Atmega128의 TXD0(PE1)를 연결한다.
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 TXD와 Atmega128의 RXD0(PE0)를 연결한다.

주: 컴퓨터에 Serial Port가 없는 경우 "USB --> UART(RS232) 변환 모듈"를 사용(USB Port를 Serial Port로 변환)하여 연결한다. 개발보드에 따라서는 "USB --> UART(RS232) 변환 모듈"을 내장하고 있는 경우가 많기 때문에 본인이 사용하는 개발보드에서 확인 하여야 한다.

참고자료: USB - Serial 변환 모듈

• 컴퓨터(USB --> UART(RS232)의 GND와 Atmega128의 GND를 연결한다. "USB --> UART(RS232) 변환 모듈"를 사용하는 경우 변환 모듈의 GND와 Atmega128의 GND를 연결한다.
• 실험 방법
• Project(Project name: AVR_asm_usart_string_io)를 생성 한다.
• 위 프로그램을 main.asm에 복사하고 저장한다.
• Build → Build Solution 를 실행 하면 main.asm File 이 Assemble 되어 AVR_asm_usart_string_io.hex 파일이 생성된다.
• AVR_asm_usart_string_io.hex 파일을 Target Board에 Upload 하고 프로그램을 실행한다.

주: 모니터 프로그램(예: OC-Console, Tera Term)과 hex 파일을 Target Board에 Upload 하는 프로그램이 동일한 Port를 사용하기 때문에 모니터 프로그램을 중지하고 Upload를 실행하여야 한다.

• 모니터 프로그램(예: OC-Console, Tera Term)을 설치(이미 설치되어 있는 경우에는 실행만 하면됨)하고 실행 한다.
• 모니터 프로그램에서 필요한 설정(Serial Port와 Baudrate 등을 설정)을 한다.
• 실험:
• 개발 보드의 Reset SW를 누르면 모니터에 "Input New String:" 메세지가 출력된다.
• 모니터에서 문자를 입력하면 입력된 문자는 UART 통신을 이용하여 개발보드에 전송되어 Input buffer에 저장된다.
• Enter Key를 누르면 Input buffer에 저장된 문자열이 모니터에 출력된다.

참고자료: GCC asm 프로그램 예: GCC_asm_usart_string_io.zip

• UART Rx Interrupt를 이용한 제어 문자 입력과 LED shift 제어
• UART Rx Interrupt를 이용한 제어 문자 입력과 LED shift 제어 프로그램 예: AVR_asm_led_shift_uart_Rx_int.zip
; [Add Project title here] ; ; Author: Your Name Here ; Lab: ; Date: 2000. 00. 00 .NOLIST .include "m128def.inc" ; Definition file for ATmega128 ; Interrupt Vectors Table .include "avr128_interrupt_table.inc" ; [Add all hardware information here] .DEVICE ATmega128 .LIST ; Program Constants ; ; Program Variables Definitions .def AC0 = r16 ; Accumulator Byte Rg 0 .def AC1 = r17 ; Accumulator Byte Rg 1 .def RG_ARG0_H = r25 ; Function Argument Word Rg 0 High .def RG_ARG0_L = r24 ; Function Argument Word Rg 0 Low .def SHIFT_DIR = r19 ; .equ CR = $0d .equ LF = $0a .equ FOSC = 16000000 // Clock Speed ; Generic Constant Structure .equ BAUD = 19200 // Baud rate 값(상수) .equ MYUBRR = FOSC/16/BAUD-1 // UBRR Rg에 설정 할 값(상수) 계산 ; SRAM Definitions .DSEG .ORG 0x0100 ;vgByte: .BYTE 1 ; Reserve 1 Byte to Global Variable ;vgWord: .BYTE 2 ; Reserve 2 Byte to Global Variable ;vgDWord: .BYTE 4 ; Reserve 4 Byte to Global Variable ;mesg1: .DB "USART Test",0x00 ; Allocata byte(s) of storage with initialized values .CSEG ; Func: RESET Handler Routine RESET: ; Stack Pointer Init ldi AC0, LOW(RAMEND) out SPL, AC0 ldi AC0, HIGH(RAMEND) out SPH, AC0 rjmp MAIN ; Main Entry into program MAIN: ; I/O Port Init ser AC0 sts DDRF, AC0 ; PORTF : Output Port, Memory Mapped I/O Port clr AC0 sts PORTF, AC0 ; LED Turn OFF ; Init USART ; Set Baud Rate : 19200 ldi RG_ARG0_H, HIGH(MYUBRR) ldi RG_ARG0_L, LOW(MYUBRR) rcall USART_Init ldi ZL, LOW(mesg1 << 1) ; Byte Address <- Word Address ldi ZH, HIGH(mesg1 << 1) rcall MesgOut ldi RG_ARG0_L, CR rcall UART_putchar ldi RG_ARG0_L, LF rcall UART_putchar clr SHIFT_DIR ; Shift Direction 초기화(Up 방향) ldi AC1, 1 ; Shift Data 초기화 loop: sts PORTF, AC1 ; PORTF : Memory Mapped I/O Port ldi AC0, 200 ; 200mSec Delay rcall mSecDelay SET_DIR: ; SHIFT_DIR Rg의 값에 따라 회전 방향을 설정 한다. and SHIFT_DIR,SHIFT_DIR breq ROT_LEFT ROT_RIGHT: ; Down 방향 clc ror AC1 brcc LOOP ror AC1 rjmp LOOP ; Loop Indefinitly ROT_LEFT: ; Up 방향 clc rol AC1 brcc LOOP rol AC1 rjmp LOOP ; Loop Indefinitly // UART로 부터 하나의 문자를 읽고 // 만약 이 문자가 L 인 경우에는 Up 방향으로 회전 하도록 설정 하고 // 만약 이 문자가 R 인 경우에는 Down 방향으로 회전 하도록 설정 한다. getchar_set_dir: push RG_ARG0_L // Rx Interrupt를 Disable 한다. cbi UCSR0B, RXCIE0 // getchar in RG_ARG0_L, UDR0 push RG_ARG0_L rcall UART_putchar ldi RG_ARG0_L, CR rcall UART_putchar pop RG_ARG0_L // 만약 문자 L or l 이 입력된 경우 Up 방향 cpi RG_ARG0_L, 'L' ; brne DIR_UP1 clr SHIFT_DIR DIR_UP1: cpi RG_ARG0_L, 'l' ; brne DIR_DOWN clr SHIFT_DIR // 만약 문자 R or r 이 입력된 경우 Down 방향 DIR_DOWN: cpi RG_ARG0_L, 'R' ; brne DIR_DOWN1 ser SHIFT_DIR DIR_DOWN1: cpi RG_ARG0_L, 'r' ; brne NEXT ser SHIFT_DIR NEXT: // RX0 Complete Interrupt Enable sbi UCSR0B, RXCIE0 pop RG_ARG0_L reti ; Calling Sequence ; RG_ARG0_H <- UBRRH ; RG_ARG0_L <- UBRL ; rcall USART_Init USART_Init: ; SREG(Status Register)와 서브루틴에서 사용하는 Rg를 스택에 Save 한다. push AC0 ; Subroutine에서 사용할 AC0 Rg를 Save 한다. in AC0, SREG ; SREG 값을 갖어온다. push AC0 ; SREG Rg 값을 Save 한다. ; Set baud rate sts UBRR0H, RG_ARG0_H out UBRR0L, RG_ARG0_L ; Enable receiver and transmitter ldi AC0, (1<<RXEN0)|(1<<TXEN0) out UCSR0B,AC0 ; Set frame format: 8data, 1stop bit ldi AC0, (0<<USBS0)|(3<<UCSZ00) sts UCSR0C,AC0 pop AC0 ; SREG Rg 값을 Load 한다. out SREG, AC0 ; SREG Rg를 Restore 한다. pop AC0 ; AC0 Rg 값을 Restore 한다. //RX0 Complete Interrupt Enable sbi UCSR0B, RXCIE0 sei // Set Global Interrupt Flag ret ; Calling Sequence ; RG_ARG0_L <- Transmit Data USART_Transmit: UART_putchar: ; Wait for empty transmit buffer sbis UCSR0A,UDRE0 rjmp USART_Transmit ; Put data (RG_ARG0_L) into buffer, sends the data out UDR0,RG_ARG0_L ret ; Calling Sequence ; RG_ARG0_L : Received Data USART_Receive: UART_getchar: ; Wait for data to be received sbis UCSR0A, RXC0 rjmp USART_Receive ; Get and return received data from buffer in RG_ARG0_L, UDR0 ret ; Calling Sequence ; Z <- String Address ; rcall OutString OutString: ld RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndOutString rcall UART_putchar rjmp OutString EndOutString: ret ; Calling Sequence ; Z <- String Address ; rcall MesgOut from Program Memory MesgOut: lpm RG_ARG0_L, Z+ and RG_ARG0_L, RG_ARG0_L breq EndMesgout rcall UART_putchar rjmp MesgOut EndMesgOut: ret mesg1: .DB "UART: LED Rotation Control",CR,LF,"L -> Left R -> Right",CR,LF,0x00,0x00 ; Passing Argument ; AC0 : N 100mSec ; Return Value : Void mSec100Delay: push AC0 push AC1 mov AC1,AC0 ldi AC0, 100 ; m100LOOP: rcall mSecDelay ; 100mSec dec AC1 ; brne m100LOOP ; pop AC1 pop AC0 ret ; Passing Argument ; AC0 : N mSec ; Return Value : Void mSecDelay: push AC0 push AC1 mov AC1,AC0 ldi AC0, 250 ; mLOOP: rcall uSecDelay ; 250uSec + rcall uSecDelay ; 250uSec + rcall uSecDelay ; 250uSec + rcall uSecDelay ; 250uSec = 1mSec dec AC1 ; brne mLOOP ; pop AC1 ; pop AC0 ; ret ; Passing Argument ; AC0 : N uSec ; Return Value : Void uSecDelay: push AC0 ; 2 cycle uLOOP: push AC0 ; 2 cycle + pop AC0 ; 2 cycle + push AC0 ; 2 cycle + pop AC0 ; 2 cycle + push AC0 ; 2 cycle + pop AC0 ; 2 cycle + nop ; 1 cycle + dec AC0 ; 1 cycle + brne uLoop ; 1 cycle = (15 + M1) cycle * 0.0625uSec = 1uSec pop AC0 ; 2 cycle ret

• ATMega128 Interrupt Vector Table Template: "avr128_interrupt_table.inc"
• USART0 Rx Complete Handler을 사용하기위한 Interrupt Vector Table 편집 예
.... .... reti ; Timer0 Overflow Handler nop reti ; SPI Transfer Complete Handler nop jmp getchar_set_dir ; USART0 Rx Complete Handler reti ; UDR0 Rmpty Handler nop reti ; USART0 Tx Complete Handler nop .... ....

• 실험을 위한 준비
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 RXD와 Atmega128의 TXD0(PE1)를 연결한다.
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 TXD와 Atmega128의 RXD0(PE0)를 연결한다.
• 컴퓨터(USB --> UART(RS232) 변환 모듈)의 GND와 Atmega128의 GND를 연결한다. "USB --> UART(RS232) 변환 모듈"를 사용하는 경우 변환 모듈의 GND와 Atmega128의 GND를 연결한다.
• PORTF에 저항(330Ω)과 LED Array(8Bits)를 연결한다.

참고자료: 8Bit-LED-array-module 제작 예

• 실험 방법
• Project(Project name: AVR_asm_led_shift_uart_Rx_int)를 생성 한다.
• 위 프로그램을 main.asm에 복사하고 저장한다.
• ATMega128 Interrupt Vector Table Template를 Download 하여 avr128_interrupt_table.inc 파일을 main.asm이 있는 폴더에 복사한다
• USART0 Rx Interrupt가 발생하면 "getchar_set_dir" Interrupt Handler 가 실행되도록 avr128_interrupt_table.inc 파일의 "USART0 Rx Complete Handler"를 위 "USART0 Rx Complete Handler을 사용하기위한 Interrupt Vector Table 편집 예"와 같이 편집하여 저장한다.
• Build → Build Solution 를 실행 하면 main.asm File 이 Assemble 되어 AVR_asm_led_shift_uart_Rx_int.hex 파일이 생성된다.
• AVR_asm_led_shift_uart_Rx_int.hex 파일을 Target Board에 Upload 하고 프로그램을 실행한다.
• 모니터 프로그램(예: OC-Console, Tera Term)을 설치(이미 설치되어 있는 경우에는 실행만 하면됨)하고 실행 한다.
• 모니터 프로그램에서 필요한 설정(Serial Port와 Baudrate 등을 설정)을 한다.
• 실험: USART0 Rx Interrupt를 이용하는 예 이다.
• 개발 보드의 Reset SW를 누르면 모니터에 "UART0 Interrupt: LED Shift."와 "SHIFT_LEFT: L SHIFT_RIGHT: R" 메세지가 출력된다.
• 모니터 프로그램에서 문자 "L"를 입력하면 LED 가 좌측으로 회전하고, 문자 "R"를 입력하면 LED 가 우측으로 회전한다.
• 개발보드는 모니터 프로그램으로 부터 UART Interrupt를 이용하여 명령 문자를 받는다.

Serial I/O(UART) Communication 관련 페이지 보기

• ATmega128 I/O Port - ASM
• Switch debouncing 과 Keypad Interfacing - ASM