[NXP]/LPC8002014. 3. 9. 21:00

LPC812 EVM - UART 테스트

LPC812 EVM -  UART 테스트


LPC812 는 3채널의 UART가 있다. 20핀 소형 페키지 임에도 불구하고 3개의 UART가 있어 유용하게 사용될곳이 많을것 같다.

그리고 스위치 메트릭스라는 기능을 이용하여 UART핀을 자유롭게 맵핑할 수 있는것도 상당히 마음에 든다.


아래 그림은 LPC812의 UART 블록도 이다.



LPC812 UART 핀맵핑 


#if 1

  /* connect the UART0 TXD abd RXD sigals to port pins(P0.4-P0.0)*/

regVal = LPC_SWM->PINASSIGN0 & ~( 0xFF << 0 );

LPC_SWM->PINASSIGN0 = regVal | ( 4 << 0 ); /* P0.4 is UART0 TXD, ASSIGN0(7:0) */

regVal = LPC_SWM->PINASSIGN0 & ~( 0xFF << 8 );

LPC_SWM->PINASSIGN0 = regVal | ( 0 << 8 ); /* P0.0 is UART0 RXD. ASSIGN0(15:8) */

regVal = LPC_SWM->PINASSIGN0 & ~( 0xFF << 16 );

LPC_SWM->PINASSIGN0 = regVal | ( 12 << 16 ); /* P0.12 is UART0 RTS, ASSIGN0(23:16) */

regVal = LPC_SWM->PINASSIGN0 & ~( 0xFFUL << 24 );

LPC_SWM->PINASSIGN0 = regVal | ( 13 << 24 ); /* P0.13 is UART0 CTS. ASSIGN0(31:24) */

#endif


#if 0

  /* connect the UART1 TXD abd RXD sigals to port pins(P0.4-P0.0)*/

regVal = LPC_SWM->PINASSIGN1 & ~( 0xFF << 8 );

LPC_SWM->PINASSIGN1 = regVal | ( 4 << 8 ); /* P0.4 is UART1 TXD, ASSIGN1(15:8) */

regVal = LPC_SWM->PINASSIGN1 & ~( 0xFF << 16 );

LPC_SWM->PINASSIGN1 = regVal | ( 0 << 16 ); /* P0.0 is UART1 RXD. ASSIGN1(23:16) */

regVal = LPC_SWM->PINASSIGN1 & ~( 0xFFUL << 24 );

LPC_SWM->PINASSIGN1 = regVal | ( 12 << 24 ); /* P0.12 is UART1 RTS. ASSIGN1(31:24) */

regVal = LPC_SWM->PINASSIGN2 & ~( 0xFF << 0 );

LPC_SWM->PINASSIGN2 = regVal | ( 13 << 0 ); /* P0.13 is UART1 RTS, ASSIGN2(7:0) */

#endif


#if 0

/* connect the UART2 TXD abd RXD sigals to port pins(P0.4-P0.0)*/

regVal = LPC_SWM->PINASSIGN2 & ~( 0xFF << 16 );

LPC_SWM->PINASSIGN2 = regVal | ( 4 << 16 ); /* P0.4 is UART2 TXD, ASSIGN2(23:16) */

regVal = LPC_SWM->PINASSIGN2 & ~( 0xFFUL << 24 );

LPC_SWM->PINASSIGN2 = regVal | ( 0 << 24 ); /* P0.0 is UART2 RXD. ASSIGN2(31:24) */

regVal = LPC_SWM->PINASSIGN3 & ~( 0xFF << 0 );

LPC_SWM->PINASSIGN3 = regVal | ( 12 << 0 ); /* P0.12 is UART2 RTS. ASSIGN1(7:0) */

regVal = LPC_SWM->PINASSIGN3 & ~( 0xFF << 8 );

LPC_SWM->PINASSIGN3 = regVal | ( 13 << 8 ); /* P0.13 is UART2 RTS, ASSIGN2(15:8) */

#endif



LPC812의 UART는 스위치 메트릭스로 원하는 포트에 할당가능하다. 다만 부트로드의 경우 디폴트로 P0.0, P1.4에 할당되어 있다.부트로더를 이용한다면 하드웨어 설계시주의가 필요하다.





LPC812 UART Status Register

RXDATSTAT의 RXRDY 비트가 1이면 수신버퍼로부터 데이터르 읽어 올 수 있다. 데이터를 읽어오면 자동으로 0이 된다.




LPC812 UART 송수신 함수

void U0_PutByte(unsigned char Data)

{

    while ( !(LPC_USART0->STAT & TXRDY) );

    LPC_USART0->TXDATA = Data;    

}



unsigned char U0_GetByte(void)

{

    while(!(LPC_USART0->STAT & RXRDY));     

    return LPC_USART0->RXDATA;

}



Posted by nexp

댓글을 달아 주세요

Cortex-M/INFINEON2013. 11. 24. 22:00

XMC1300 EVM - UART 테스트 (Infineon Cortex-M0)

[XMC1300 EVM] - UART 테스트 (Infineon Cortex-M0)



XMC1300는 UART, SPI,I2C,I2S통신을 위한    모듈이 하나의 통합된 모듈로 2채널 존재한다

하나의 통합된 모듈이기 때문에 소프트웨어 적으로는 거의 동일하게 설정해서 사용할 수 있기 때문에 편리하다. 하지만 동시에 여러 통신 채널을 사용하는 어플리케이션에는 문제가 발생 할 수 있다



XMC1300 UART 블록도



여러 통신모듈이 레지스터를 공유하기 때문에 다소 복잡해 보인다

하지만 몇가지 레지스터만 학인하면 쉽게 UART통신이 가능하다



TDV 

bit7

Transmit Data Valid


전송버퍼 (TBUF)의 데이터 상태를 나타내는 비트로 1이면 정상 전송되었음을 나타낸다.의  can be considered as valid for




REMPTY 3 rh Receive Buffer Empty

This bit indicates whether the receive buffer is

empty.

0B The receive buffer is not empty.

1B The receive buffer is empty.




TEMPTY 11 rh Transmit Buffer Empty

This bit indicates whether the transmit buffer is

empty.

0B The transmit buffer is not empty.

1B The transmit buffer is empty.



XMC1300 UART 송수신 함수

unsigned char U0_GetByte(void)

{

    while((USIC0_CH1->TRBSR&BIT3));

    return USIC0_CH1->OUTR;

}



void U0_PutByte(unsigned char Data)

{

    while(USIC0_CH1->TCSR & BIT7); 

    USIC0_CH1->TBUF[0]  = Data;

}


Posted by nexp

댓글을 달아 주세요

[FreeScale]/KINETIS2013. 11. 2. 22:30

K20 EVM - Kinetis Cortex-M4 K20 UART 테스트

K20 EVM - Kinetis Cortex-M4 K20  UART 테스트


K20의 UART는 일반 UART 3채널로 구성되어 있다.


PTA1 -> UART0_RX

PTA2 -> UART0_TX


PTB16 ->UART0_RX

PTB17 ->UART0_TX


PTD6 -> UART0_RX

PTD7 -> UART0_TX



PTC3 ->UART1_RX

PTC4 ->UART1_TX


PTD2 ->UART2_RX

PTD3 ->UART2_TX


UART clocking

UART0 and UART1 modules operate from the core/system clock, which provides higher

performance level for these modules. All other UART modules operate from the bus

clock.






K20 UART 초기화 함수

// Serial Prot0 Utility Fuction Routine

void U0_Init(unsigned char baud)

{

//UART포트 설정

// Enable the UART_RXD function on PTA1 

PORTA_PCR1 = PORT_PCR_MUX(0x2);


// Enable the UART_TXD function on PTA2 

PORTA_PCR2 = PORT_PCR_MUX(0x2);


//UART0 클럭 Enable 

SIM_SCGC4 |= SIM_SCGC4_UART0_MASK;

    //UART disable

    UART_C2_REG(UART0_BASE_PTR) &= ~(UART_C2_TE_MASK | UART_C2_RE_MASK );


    //Configure the UART for 8-bit mode, no parity(디폴트 값 사용)

    UART_C1_REG(UART0_BASE_PTR) = 0;

    

    

    U0_SetBaud(baud);


 

    //Enable UART

UART_C2_REG(UART0_BASE_PTR) |= (UART_C2_TE_MASK | UART_C2_RE_MASK );

}





UARTx_S1(UART Status Register 1)





DRE

Transmit Data Register Empty Flag

TDRE will set when the number of datawords in the transmit buffer (D and C3[T8])is equal to or less than

the number indicated by TWFIFO[TXWATER]. A character that is in the process of being transmitted is

not included in the count. To clear TDRE, read S1 when TDRE is set and then write to the UART data

register (D). For more efficient interrupt servicing, all data except the final value to be written to the buffer

must be written to D/C3[T8]. Then S1 can be read before writing the final data value, resulting in the

clearing of the TRDE flag. This is more efficient because the TDRE reasserts until the watermark has

been exceeded. So, attempting to clear the TDRE with every write will be ineffective until sufficient data

has been written.

0 The amount of data in the transmit buffer is greater than the value indicated by TWFIFO[TXWATER].

1 The amount of data in the transmit buffer is less than or equal to the value indicated by

TWFIFO[TXWATER] at some point in time since the flag has been cleared.



5

RDRF

Receive Data Register Full Flag

RDRF is set when the number of datawords in the receive buffer is equal to or more than the number

indicated by RWFIFO[RXWATER]. A dataword that is in the process of being received is not included in

the count. RDRF is prevented from setting while S2[LBKDE] is set. Additionally, when S2[LBKDE] is set,

the received datawords are stored in the receive buffer but over-write each other. To clear RDRF, read S1

when RDRF is set and then read D. For more efficient interrupt and DMA operation, read all data except

the final value from the buffer, using D/C3[T8]/ED. Then read S1 and the final data value, resulting in the

clearing of the RDRF flag. Even if RDRF is set, data will continue to be received until an overrun condition

occurs.

0 The number of datawords in the receive buffer is less than the number indicated by RXWATER.

1 The number of datawords in the receive buffer is equal to or greater



K20 UART 송수신 함수

unsigned char U0_GetByte(void)

{

//데이터가 수신되면

while (!(UART_S1_REG(UART0_BASE_PTR) & UART_S1_RDRF_MASK));


//데이터 읽어옴

return UART_D_REG(UART0_BASE_PTR);

}



void U0_PutByte(unsigned char Data)

{

//송신 FIFO가 비어지면

while(!(UART_S1_REG(UART0_BASE_PTR) & UART_S1_TDRE_MASK));


//데이터 전송

UART_D_REG(UART0_BASE_PTR) = Data;

}





Posted by nexp

댓글을 달아 주세요

[MSP430]/MSP430_FRAM2013. 5. 17. 22:30

MSP430FR5739 EVM - eUSCI UART테스트

MSP430FR5739 EVM - eUSCI UART테스트

MSP430F5739는 eUSCI(enhanced universal serial communication interface) 라고 하는 통신 인터페이스가 적용되었다고 한다.

새로운 기능으로 추가되는것은 좋지만 기존 코드를 좀 쓸수 있었으면 좋겠는데... 레지스터명이나 기능들이 또 바뀌어 있다.

설계 할때 잘 해둘필요가 있는데... 아무튼 다시 한번 정리해 본다.


 

 

MSP430FR5739 UART 블록도



 

MSP430FR5739 UART 초기화 함수

// Serial Prot0 Utility Fuction Routine
void U0_Init(unsigned char baud)

  U0_SetBaud(baud);
 //set Baudrate
 //---------------------------------------------------------

    UCA0CTL1 |= UCSWRST;    


    // Configure UART pins
    P2SEL1 |= BIT0 + BIT1;
    P2SEL0 &= ~(BIT0 + BIT1);

 


    UCA0CTL1 = UCSSEL__SMCLK;                 // UCSSEL__SMCLK = 32768 as UCBRCLK

 

   UCA0CTL1 &= ~UCSWRST;

}


 

MSP430FR5739 UART 송수신 함수

#define u0_WaitForReceive()     while((UCA0IFG&UCRXIFG) == 0)
#define u0_RxData()        (UCA0RXBUF)

#define u0_TxData(Data)      (UCA0TXBUF = (Data))
#define u0_WaitForSend()     while (!(UCA0IFG&UCTXIFG));

#define u0_IsReceiveData()     (UCA0IFG&UCRXIFG)
#define u0_RXINT_EN()      (IE2 |= UCA0RXIE)  

 

unsigned char U0_GetByte(void)
{
 u0_WaitForReceive();
 return u0_RxData();
}

 

void U0_PutByte(unsigned char Data)
{
 u0_WaitForSend();
 u0_TxData(Data);
}

 


 

Posted by nexp

댓글을 달아 주세요

Cortex-M/EFM322013. 4. 30. 21:30

EFM32G210 EVM - UART 테스트

EFM32G210 EVM - UART 테스트

 


MCU를 처음 다룰때 디버깅 및 제어를 위해 가장 기본적으로 필요한 인터페이스 수단으로 UART를 사용하는데 EFM32는 2채널의 UART가 있다. 특히 Low Energy UART 기능이 있어 저전력으로 UART통신을 할 수 있다고 한다.











EFM32 UART 블록도

 


EFM32 UART 핀맵

PE10, PE11 에 UART0가 연결되어 있다.

 

PC0, PC1에 UART1이 연결되어 [EFM32 EVM] 보드에서는  있지만 SPI로 사용하고 있다.

 


EFM32 UART 초기화코드

 void U0_Init(unsigned char baud)
{   
 USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
 USART_TypeDef *usart = USART0;
 
 U0_SetBaud(baud);

    CMU_ClockEnable(cmuClock_HFPER, true);
    CMU_ClockEnable(cmuClock_USART0, true);   

 /* Use default location 0: TX - Pin C0, RX - Pin C1 */
 GPIO_PinModeSet(gpioPortE, 10, gpioModePushPull, 1);
 ///Define input, no filtering
 GPIO_PinModeSet(gpioPortE, 11, gpioModeInput, 0);
 
 //Enable pins at default location
 usart->ROUTE = USART_ROUTE_LOCATION_LOC0 | USART_ROUTE_RXPEN | USART_ROUTE_TXPEN;

 /* Configure USART for basic async operation */
 init.enable = usartEnable;
 USART_InitAsync(usart, &init);

 /* Finally enable it */
 USART_Enable(usart, usartEnable);
}

 

 

EFM32 UART 송수신 함수

unsigned char U0_GetByte(void)
{
  while (!(USART0->STATUS & USART_STATUS_RXDATAV));

  return (uint8_t)(USART0->RXDATA);
}

 

 

void U0_PutByte(unsigned char Data)
{
  while (!(USART0->STATUS & USART_STATUS_TXBL));
  USART0->TXDATA = (uint32_t)Data;
}

 

 

 

EFM32 UART 테스트 소스코드

int main(void)
{
    unsigned int cnt = 0;
    _SystemInit();

   
    Led1Init();
    Led1Off();
   
    DebugInit(BAUD_115200);
    DebugPrint("EFM32 UART Test\r\m");
   
    while (1)
    {
        DebugPrint("cnt=%d\r\n", cnt++);
        Delay(100);
    }
}

 

Posted by nexp

댓글을 달아 주세요