'2019/11'에 해당되는 글 4건

  1. 2019.11.17 STM32F723 UART LL_DRIVER 예제
  2. 2019.11.10 STM32H743 LL_Driver Timer
  3. 2019.11.09 STM32H743 UART LL_Driver 예제
  4. 2019.11.04 Intel-Hex 프로토콜 구조
2019.11.17 20:10

뭘 좀 잘못한 걸까요? F723이 H743보다 더 빠르다니 이해가 잘 안되네요.

하지만 STM32F103이 STM32F091보다 연산이 느린걸 보면 그럴수도 있다고 생각이 되기도 하네요.(내부 플래쉬 메모리 접근 구조나 이런 차이일까요? 아님 캐쉬를 안 돌렸나? 확인 안해봤으니 상상의 나래만 ㅋㅋ큐ㅠㅠㅠ)

USB HS PHY가 안에 들어있어서 써볼까 생각했었는데 더 잘 되었네요. 다만 UFBGA나 WLCSP 타입이라서 아트웍이나 PCB 제작 후 수삽할 때 짜증이.... ㅠㅠ 

 

STM32F446 - 225DMIPS - ARIA 128, CBC Mode

Data Length - 32 byte
61 us
Data Length - 64 byte
100 us
Data Length - 128 byte
177 us
Data Length - 256 byte
331 us

Data Length - 512 byte

639 us

 

STM32H743 - 1027DMIPS - ARIA 128, CBC Mode

Data Length - 512 byte

393 us

 

STM32F723 - 462DMIPS - ARIA 128, CBC Mode

Data Length - 512 byte

237 us

 

그 외 키 길이별 속도 측정)

STM32F446 - 225DMIPS - ARIA 192, CBC Mode

Data Length - 512 byte

735 us

 

STM32F446 - 225DMIPS - ARIA 256, CBC Mode

Data Length - 512 byte

824 us



void Init_UART(uint8_t a_chUart, uint32_t a_nBaud)

  if(a_chUart == USART_1)
  {
/* (1) Enable GPIO clock and configures the USART pins *********************/

/* Enable the peripheral clock of GPIO Port */
LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);

/* Configure Tx Pin as : Alternate function, High Speed, Push pull, Pull up */
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_9, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_8_15(GPIOA, LL_GPIO_PIN_9, LL_GPIO_AF_7);
LL_GPIO_SetPinSpeed(GPIOA, LL_GPIO_PIN_9, LL_GPIO_SPEED_FREQ_HIGH);
LL_GPIO_SetPinOutputType(GPIOA, LL_GPIO_PIN_9, LL_GPIO_OUTPUT_PUSHPULL);
LL_GPIO_SetPinPull(GPIOA, LL_GPIO_PIN_9, LL_GPIO_PULL_UP);

/* Configure Rx Pin as : Alternate function, High Speed, Push pull, Pull up */
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_10, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_8_15(GPIOA, LL_GPIO_PIN_10, LL_GPIO_AF_7);
LL_GPIO_SetPinSpeed(GPIOA, LL_GPIO_PIN_10, LL_GPIO_SPEED_FREQ_HIGH);
LL_GPIO_SetPinOutputType(GPIOA, LL_GPIO_PIN_10, LL_GPIO_OUTPUT_PUSHPULL);
LL_GPIO_SetPinPull(GPIOA, LL_GPIO_PIN_10, LL_GPIO_PULL_UP);

/* (2) NVIC Configuration for USART interrupts */
/*  - Set priority for USARTx_IRQn */
/*  - Enable USARTx_IRQn */
NVIC_SetPriority(USART1_IRQn, 2);  
NVIC_EnableIRQ(USART1_IRQn);

/* (3) Enable USART peripheral clock and clock source ***********************/
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);

/* Set clock source */
LL_RCC_SetUSARTClockSource(LL_RCC_USART1_CLKSOURCE_PCLK2);

/* (4) Configure USART functional parameters ********************************/

/* Disable USART prior modifying configuration registers */
/* Note: Commented as corresponding to Reset value */
// LL_USART_Disable(USART1);

/* TX/RX direction */
LL_USART_SetTransferDirection(USART1, LL_USART_DIRECTION_TX_RX);

/* 8 data bit, 1 start bit, 1 stop bit, no parity */
LL_USART_ConfigCharacter(USART1, LL_USART_DATAWIDTH_8B, LL_USART_PARITY_NONE, LL_USART_STOPBITS_1);

/* No Hardware Flow control */
/* Reset value is LL_USART_HWCONTROL_NONE */
LL_USART_SetHWFlowCtrl(USART1, LL_USART_HWCONTROL_NONE);

/* Oversampling by 16 */
/* Reset value is LL_USART_OVERSAMPLING_16 */
LL_USART_SetOverSampling(USART1, LL_USART_OVERSAMPLING_16);

/* Set Baudrate to 115200 using APB frequency set to 32000000 Hz */
/* Frequency available for USART peripheral can also be calculated through LL RCC macro */
/* Ex :
Periphclk = LL_RCC_GetUSARTClockFreq(Instance); or LL_RCC_GetUARTClockFreq(Instance); depending on USART/UART instance

In this example, Peripheral Clock is expected to be equal to 32000000 Hz => equal to SystemCoreClock
*/
LL_USART_SetBaudRate(USART1, SystemCoreClock/APB_Div, LL_USART_OVERSAMPLING_16, a_nBaud); 

/* (5) Enable USART *********************************************************/
LL_USART_Enable(USART1);

while((!(LL_USART_IsActiveFlag_TEACK(USART1))))

}
/* Enable RXNE and Error interrupts */
LL_USART_EnableIT_RXNE(USART1);
LL_USART_EnableIT_ERROR(USART1);

UART1_ClearBuf();
  }
  else if(a_chUart == USART_2){
/* (1) Enable GPIO clock and configures the USART pins *********************/

/* Enable the peripheral clock of GPIO Port */
LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);

/* Configure Tx Pin as : Alternate function, High Speed, Push pull, Pull up */
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_2, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_0_7(GPIOA, LL_GPIO_PIN_2, LL_GPIO_AF_7);
LL_GPIO_SetPinSpeed(GPIOA, LL_GPIO_PIN_2, LL_GPIO_SPEED_FREQ_HIGH);
LL_GPIO_SetPinOutputType(GPIOA, LL_GPIO_PIN_2, LL_GPIO_OUTPUT_PUSHPULL);
LL_GPIO_SetPinPull(GPIOA, LL_GPIO_PIN_2, LL_GPIO_PULL_UP);

/* Configure Rx Pin as : Alternate function, High Speed, Push pull, Pull up */
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_3, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_0_7(GPIOA, LL_GPIO_PIN_3, LL_GPIO_AF_7);
LL_GPIO_SetPinSpeed(GPIOA, LL_GPIO_PIN_3, LL_GPIO_SPEED_FREQ_HIGH);
LL_GPIO_SetPinOutputType(GPIOA, LL_GPIO_PIN_3, LL_GPIO_OUTPUT_PUSHPULL);
LL_GPIO_SetPinPull(GPIOA, LL_GPIO_PIN_3, LL_GPIO_PULL_UP);

/* (2) NVIC Configuration for USART interrupts */
/*  - Set priority for USARTx_IRQn */
/*  - Enable USARTx_IRQn */
NVIC_SetPriority(USART2_IRQn, 2);  
NVIC_EnableIRQ(USART2_IRQn);

/* (3) Enable USART peripheral clock and clock source ***********************/
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART2);

/* Set clock source */
LL_RCC_SetUSARTClockSource(LL_RCC_USART2_CLKSOURCE_PCLK1);

/* TX/RX direction */
LL_USART_SetTransferDirection(USART2, LL_USART_DIRECTION_TX_RX);

/* 8 data bit, 1 start bit, 1 stop bit, no parity */
LL_USART_ConfigCharacter(USART2, LL_USART_DATAWIDTH_8B, LL_USART_PARITY_NONE, LL_USART_STOPBITS_1);

/* No Hardware Flow control */
/* Reset value is LL_USART_HWCONTROL_NONE */
LL_USART_SetHWFlowCtrl(USART2, LL_USART_HWCONTROL_NONE);

/* Oversampling by 16 */
/* Reset value is LL_USART_OVERSAMPLING_16 */
LL_USART_SetOverSampling(USART2, LL_USART_OVERSAMPLING_16);

/* Set Boad Rate */
LL_USART_SetBaudRate(USART2, SystemCoreClock/APB_Div, LL_USART_OVERSAMPLING_16, a_nBaud); 

/* (5) Enable USART *********************************************************/
LL_USART_Enable(USART2);

while((!(LL_USART_IsActiveFlag_TEACK(USART2))))

}
/* Enable RXNE and Error interrupts */
LL_USART_EnableIT_RXNE(USART2);
LL_USART_EnableIT_ERROR(USART2);

UART2_ClearBuf();
  }
}

 

/*******************************************************************************
* Function Name : 
* Parameters    : None
* Return        : None
* Description   : 
*******************************************************************************/
void UART1_ClearBuf(void)
{
    Uart1.RxInCnt = 0;
    Uart1.RxOutCnt = 0;
}

/*******************************************************************************
* Function Name : u8 UART1_GetChar(char *data)
* Parameters    : 
* Return        : µ¥ÀÌŸ ¼ö½Å ¿©ºÎ(0: ¼ö½Å¹öÆÛ°¡ ºñ¾úÀ½, 1: ¼ö½Å¹öÆÛ¿¡ µ¥ÀÌŸ°¡ ÀÖÀ½)
* Description   : UART1·Î ¼ö½Å¹öÆÛ¿¡¼­ µ¥ÀÌŸ(1byte) °¡Á®¿À±â
*******************************************************************************/
uint8_t UART1_GetChar(char *data)
{
    if(Uart1.RxInCnt == Uart1.RxOutCnt) return 0;
    else *data = Uart1.RxBuf[Uart1.RxOutCnt];
    if(Uart1.RxOutCnt<RBUF_SIZE-1) Uart1.RxOutCnt++;
    else Uart1.RxOutCnt = 0;

    return 1;
}

/*******************************************************************************
* Function Name : void UART1_PutChar(char data)
* Parameters    : ¾Æ½ºÅ°ÄÚµå
* Return        : None
* Description   : UART1 1¹®ÀÚ Ãâ·Â
*******************************************************************************/
void UART1_PutChar(uint8_t data)
{
// /* Wait for TXE flag to be raised */
// while (!LL_USART_IsActiveFlag_TXE(USART1));
// /* Write character in Transmit Data register.
// TXE flag is cleared by writing data in DR register */
// LL_USART_TransmitData8(USART1, data);
// /* Wait for TC flag to be raised for last char */
// while (!LL_USART_IsActiveFlag_TC(USART1));


/* Write character in Transmit Data register.
TXE flag is cleared by writing data in DR register */
LL_USART_TransmitData8(USART1, data);
/* Wait for TXE flag to be raised */
while (!LL_USART_IsActiveFlag_TXE(USART1));

}

/*******************************************************************************
* Function Name : 
* Parameters    : 
* Return        : None
* Description   :  
*******************************************************************************/
void UART1_PutStr(char *string)
{
while(*string != '\0') UART1_PutChar(*string++);
}

/*******************************************************************************
* Function Name : void UART1_Printf(const char *fmt,...)
* Parameters    : ¹®ÀÚ¿­ + ¼­½Ä
* Return        : none
* Description   : UART1 printf
*******************************************************************************/
void UART1_Printf(const char *fmt,...)
{
  char string[256];
  va_list ap;
  
  va_start(ap,fmt);
  vsprintf(string,fmt,ap);
  va_end(ap);
  
  UART1_PutStr(string);
}

/*******************************************************************************
* Function Name :  
* Parameters    : 
* Return        :
* Description   :  
void USARTx_IRQHandler(void)
{
  if(LL_USART_IsActiveFlag_RXNE(USART1) && LL_USART_IsEnabledIT_RXNE(USART1))
  {
    Callback_RX_USART1();
  }
  else
  {
    Error_Callback();
  }
}
*******************************************************************************/
void Callback_RX_USART1(void)
{
Uart1.RxBuf[Uart1.RxInCnt] = LL_USART_ReceiveData8(USART1);
/* ECHO mode Start */
// LL_USART_TransmitData8(USART1, Uart1.RxBuf[Uart1.RxInCnt]);
/* ECHO mode End */

if(Uart1.RxInCnt<RBUF_SIZE-1) Uart1.RxInCnt++;
else Uart1.RxInCnt = 0;
}

/*******************************************************************************
* Function Name : 
* Parameters    : None
* Return        : None
* Description   : 
*******************************************************************************/
static void UART2_ClearBuf(void)
{
    Uart2.RxInCnt = 0;
    Uart2.RxOutCnt = 0;
}

/*******************************************************************************
* Function Name : u8 UART1_GetChar(char *data)
* Parameters    : 
* Return        : µ¥ÀÌŸ ¼ö½Å ¿©ºÎ(0: ¼ö½Å¹öÆÛ°¡ ºñ¾úÀ½, 1: ¼ö½Å¹öÆÛ¿¡ µ¥ÀÌŸ°¡ ÀÖÀ½)
* Description   : UART1·Î ¼ö½Å¹öÆÛ¿¡¼­ µ¥ÀÌŸ(1byte) °¡Á®¿À±â
*******************************************************************************/
uint8_t UART2_GetChar(char *chpData)
{
    if(Uart2.RxInCnt == Uart2.RxOutCnt) return 0;
    else *chpData = Uart2.RxBuf[Uart2.RxOutCnt];
    if(Uart2.RxOutCnt<RBUF_SIZE-1) Uart2.RxOutCnt++;
    else Uart2.RxOutCnt = 0;

    return 1;
}

/*******************************************************************************
* Function Name : void UART1_PutChar(char data)
* Parameters    : ¾Æ½ºÅ°ÄÚµå
* Return        : None
* Description   : UART1 1¹®ÀÚ Ãâ·Â
*******************************************************************************/
void UART2_PutChar(uint8_t chData)
{
/* Write character in Transmit Data register.
TXE flag is cleared by writing data in DR register */
LL_USART_TransmitData8(USART2, chData);
/* Wait for TXE flag to be raised */
while (!LL_USART_IsActiveFlag_TXE(USART2));

}

/*******************************************************************************
* Function Name : 
* Parameters    : 
* Return        : None
* Description   :  
*******************************************************************************/
void UART2_PutStr(char *chpString)
{
while(*chpString != '\0') UART2_PutChar(*chpString++);
}

/*******************************************************************************
* Function Name : void UART2_Printf(const char *fmt,...)
* Parameters    : ¹®ÀÚ¿­ + ¼­½Ä
* Return        : none
* Description   : UART1 printf
*******************************************************************************/
void UART2_Printf(const char *fmt,...)
{
  char string[256];
  va_list ap;
  
  va_start(ap,fmt);
  vsprintf(string,fmt,ap);
  va_end(ap);
  
  UART2_PutStr(string);
}

/*******************************************************************************
* Function Name :  
* Parameters    : 
* Return        :
* Description   :  
void USARTx_IRQHandler(void)
{
  if(LL_USART_IsActiveFlag_RXNE(USART1) && LL_USART_IsEnabledIT_RXNE(USART1))
  {
    Callback_RX_USART1();
  }
  else
  {
    Error_Callback();
  }
}
*******************************************************************************/
void Callback_RX_USART2(void)
{
Uart2.RxBuf[Uart2.RxInCnt] = LL_USART_ReceiveData8(USART2);
 /* ECHO mode Start */
// LL_USART_TransmitData8(USART2, Uart2.RxBuf[Uart2.RxInCnt]);
 /* ECHO mode End */

 if(Uart2.RxInCnt<RBUF_SIZE-1) Uart2.RxInCnt++;
 else Uart2.RxInCnt = 0;
}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2019.11.10 09:34

분주하는 부분에서 약간 헤맸습니다.

 

 

/*******************************************************************************
* Function Name : 
* Parameters    : None
* Return        : None
* Description   : 
DEBUGPRINT("%d \r\n", SystemCoreClock);//400000000
*******************************************************************************/
void Config_TIM(void)
{
uint32_t Prescaler;
Prescaler = (uint32_t)(SystemCoreClock / (2*1000000)) - 1;

Init_Timer(eTimer2, 1000000, eInterruptEnable, Prescaler);
}

 

/*******************************************************************************
* Function Name : 
* Parameters    : None
* Return        : 
* Description   : 
*******************************************************************************/

int Init_Timer(const uint8_t a_chTimer, const uint32_t a_nUs, const InterruptEnableState a_chInt, const uint32_t a_nPrescaler)
{
/* Initial autoreload value */
if(a_nPrescaler > 65536){
return 1;
}
  
  if(a_chTimer == 1){
  }  
  else if(a_chTimer == 2){
/* Enable the timer peripheral clock */
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM2); 

/* Set counter mode */
/* Reset value is LL_TIM_COUNTERMODE_UP */
LL_TIM_SetCounterMode(TIM2, LL_TIM_COUNTERMODE_UP);

/* Set the pre-scaler value to have TIM2 counter clock equal to 10 kHz      */
LL_TIM_SetPrescaler(TIM2, a_nPrescaler);

// LL_TIM_SetClockDivision(TIM2, 64);

/* Set the auto-reload value to have an initial update event frequency of 10 Hz */
LL_TIM_SetAutoReload(TIM2, a_nUs);

    if(a_chInt == eInterruptEnable){
/* Enable the update interrupt */
LL_TIM_EnableIT_UPDATE(TIM2);

/* Configure the NVIC to handle TIM2 update interrupt */
NVIC_SetPriority(TIM2_IRQn, 0);
NVIC_EnableIRQ(TIM2_IRQn);
}
/* Enable counter */
LL_TIM_EnableCounter(TIM2);

/* Force update generation */
LL_TIM_GenerateEvent_UPDATE(TIM2);
  }

return 0;

}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2019.11.09 23:56

STM32H7 시리즈의 LL_Driver 예제를 찾아봐도 보이지 않았습니다.

예제는 COMP, DAC, RTC, SPI만 있어서 직접 만들었습니다.

약간의 삽질을 했습니다.

LL_USART_SetBaudRate함수에 분주까지 들어가서 헤맸네요.......

암호모듈 속도 측정결과 뭔가 획기적으로 속도가 빨라지지는 않네요. DMIPS 차이로는 거즘 4배인데 연산속도 차이는 2배가 채 안되어서 약간 실망감이 드네요.

 

STM32F446 - 225DMIPS - ARIA 128, CBC Mode

Data Length - 32 byte
61 us
Data Length - 64 byte
100 us
Data Length - 128 byte
177 us
Data Length - 256 byte
331 us

Data Length - 512 byte

639 us

 

STM32H743 - 1027DMIPS - ARIA 128, CBC Mode

Data Length - 512 byte

393 us

 

그 외 키 길이별 속도 측정)

STM32F446 - 225DMIPS - ARIA 192, CBC Mode

Data Length - 512 byte

735 us

 

STM32F446 - 225DMIPS - ARIA 256, CBC Mode

Data Length - 512 byte

824 us

 

 

#include "usr_usart.h"

#include  <stdarg.h>
#include  <stdio.h>

#include "stm32h7xx_ll_bus.h"
#include "stm32h7xx_ll_rcc.h"
#include "stm32h7xx_ll_gpio.h"
#include "stm32h7xx_ll_usart.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro ------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
tUart Uart6;

/* Private function prototypes ------------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

/*******************************************************************************
* Function Name : 
* Parameters    : None
* Return        : None
* Description   : 
*******************************************************************************/
void Config_UART(void)
{
Init_UART(USART_6, BAUDRATE_115200);
}

/*******************************************************************************
* Function Name : void Init_UART(uint8_t a_chUart,uint32_t baud)
* Parameters    : Åë½ÅÆ÷Æ®. Åë½Å¼Óµµ
* Return        : None
* Description   : UART ÃʱâÈ­
*******************************************************************************/
void Init_UART(uint8_t a_chUart, uint32_t a_nBaud)

  if(a_chUart == USART_1) {
  }
  else if(a_chUart == USART_2){
  }
  else if(a_chUart == USART_6)
  {
/* (1) Enable GPIO clock and configures the USART pins *********************/

/* Enable the peripheral clock of GPIO Port */
LL_AHB4_GRP1_EnableClock(LL_AHB4_GRP1_PERIPH_GPIOC);

/* Configure Tx Pin as : Alternate function, High Speed, Push pull, Pull up */
LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_6, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_0_7(GPIOC, LL_GPIO_PIN_6, LL_GPIO_AF_7);
LL_GPIO_SetPinSpeed(GPIOC, LL_GPIO_PIN_6, LL_GPIO_SPEED_FREQ_HIGH);
LL_GPIO_SetPinOutputType(GPIOC, LL_GPIO_PIN_6, LL_GPIO_OUTPUT_PUSHPULL);
LL_GPIO_SetPinPull(GPIOC, LL_GPIO_PIN_6, LL_GPIO_PULL_UP);

/* Configure Rx Pin as : Alternate function, High Speed, Push pull, Pull up */
LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_7, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_0_7(GPIOC, LL_GPIO_PIN_7, LL_GPIO_AF_7);
LL_GPIO_SetPinSpeed(GPIOC, LL_GPIO_PIN_7, LL_GPIO_SPEED_FREQ_HIGH);
LL_GPIO_SetPinOutputType(GPIOC, LL_GPIO_PIN_7, LL_GPIO_OUTPUT_PUSHPULL);
LL_GPIO_SetPinPull(GPIOC, LL_GPIO_PIN_7, LL_GPIO_PULL_UP);

/* (2) NVIC Configuration for USART interrupts */
/*  - Set priority for USARTx_IRQn */
/*  - Enable USARTx_IRQn */
NVIC_SetPriority(USART6_IRQn, 2);  
NVIC_EnableIRQ(USART6_IRQn);

/* (3) Enable USART peripheral clock and clock source ***********************/
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART6);

/* Set clock source */
LL_RCC_SetUSARTClockSource(LL_RCC_USART16_CLKSOURCE_PCLK2);

/* (4) Configure USART functional parameters ********************************/

/* Disable USART prior modifying configuration registers */
/* Note: Commented as corresponding to Reset value */
LL_USART_Disable(USART6);

/* TX/RX direction */
LL_USART_SetTransferDirection(USART6, LL_USART_DIRECTION_TX_RX);

/* 8 data bit, 1 start bit, 1 stop bit, no parity */
LL_USART_ConfigCharacter(USART6, LL_USART_DATAWIDTH_8B, LL_USART_PARITY_NONE, LL_USART_STOPBITS_1);

// LL_USART_SetDataWidth(USART6, LL_USART_DATAWIDTH_8B);
// LL_USART_SetParity(USART6, LL_USART_PARITY_NONE);
// LL_USART_SetStopBitsLength(USART6, LL_USART_STOPBITS_1);
//
/* No Hardware Flow control */
/* Reset value is LL_USART_HWCONTROL_NONE */
LL_USART_SetHWFlowCtrl(USART6, LL_USART_HWCONTROL_NONE);

/* Oversampling by 16 */
/* Reset value is LL_USART_OVERSAMPLING_16 */
LL_USART_SetOverSampling(USART6, LL_USART_OVERSAMPLING_16);

/* Set Baudrate to 115200 using APB frequency set to 32000000 Hz */
/* Frequency available for USART peripheral can also be calculated through LL RCC macro */
/* Ex :
Periphclk = LL_RCC_GetUSARTClockFreq(Instance); or LL_RCC_GetUARTClockFreq(Instance); depending on USART/UART instance

In this example, Peripheral Clock is expected to be equal to 32000000 Hz => equal to SystemCoreClock
*/
LL_USART_SetBaudRate(USART6, SystemCoreClock, LL_USART_PRESCALER_DIV4, LL_USART_OVERSAMPLING_16, a_nBaud); 

/* (5) Enable USART *********************************************************/
LL_USART_Enable(USART6);

while((!(LL_USART_IsActiveFlag_TEACK(USART6))) || (!(LL_USART_IsActiveFlag_REACK(USART6))))

}
/* Enable RXNE and Error interrupts */
LL_USART_EnableIT_RXNE(USART6);
LL_USART_EnableIT_ERROR(USART6);

ClearBuf_UART6();
  }
}


/*******************************************************************************
* Function Name : 
* Parameters    : None
* Return        : None
* Description   : 
*******************************************************************************/
void ClearBuf_UART6(void)
{
    Uart6.RxInCnt = 0;
    Uart6.RxOutCnt = 0;
}

/*******************************************************************************
* Function Name : u8 GetChar_Uart6(char *data)
* Parameters    : 
* Return        : µ¥ÀÌŸ ¼ö½Å ¿©ºÎ(0: ¼ö½Å¹öÆÛ°¡ ºñ¾úÀ½, 1: ¼ö½Å¹öÆÛ¿¡ µ¥ÀÌŸ°¡ ÀÖÀ½)
* Description   : Uart6·Î ¼ö½Å¹öÆÛ¿¡¼­ µ¥ÀÌŸ(1byte) °¡Á®¿À±â
*******************************************************************************/
uint8_t GetChar_Uart6(char *data)
{
    if(Uart6.RxInCnt == Uart6.RxOutCnt) return MH_EMPTY;
    else *data = Uart6.RxBuf[Uart6.RxOutCnt];
    if(Uart6.RxOutCnt<RBUF_SIZE-1) Uart6.RxOutCnt++;
    else Uart6.RxOutCnt = 0;

    return MH_RECEIVED;
}

/*******************************************************************************
* Function Name : void PutChar_Uart6(char data)
* Parameters    : ¾Æ½ºÅ°ÄÚµå
* Return        : None
* Description   : Uart6 1¹®ÀÚ Ãâ·Â
*******************************************************************************/
void PutChar_Uart6(uint8_t data)
{
/* Write character in Transmit Data register.
TXE flag is cleared by writing data in DR register */
USART6->TDR = data;
/* Wait for TXE flag to be raised */
while (!LL_USART_IsActiveFlag_TXE(USART6));
}

/*******************************************************************************
* Function Name : 
* Parameters    : 
* Return        : None
* Description   :  
*******************************************************************************/
void PutStr_Uart6(char *string)
{
while(*string != '\0') PutChar_Uart6(*string++);
}

/*******************************************************************************
* Function Name : void Printf_Uart6(const char *fmt,...)
* Parameters    : ¹®ÀÚ¿­ + ¼­½Ä
* Return        : none
* Description   : Uart6 printf
*******************************************************************************/
void Printf_UART6(const char *fmt,...)
{
  char string[256];
  va_list ap;
  
  va_start(ap,fmt);
  vsprintf(string,fmt,ap);
  va_end(ap);
  
  PutStr_Uart6(string);
}

/*******************************************************************************
* Function Name :  
* Parameters    : 
* Return        :
* Description   :  
void USARTx_IRQHandler(void)
{
  if(LL_USART_IsActiveFlag_RXNE(USART6) && LL_USART_IsEnabledIT_RXNE(USART6))
  {
    Callback_RX_USART6();
  }
  else
  {
    Error_Callback();
  }
}
*******************************************************************************/
void Callback_RX_USART6(void)
{
Uart6.RxBuf[Uart6.RxInCnt] = LL_USART_ReceiveData8(USART6);
/* ECHO mode Start */
// LL_USART_TransmitData8(USART6, Uart6.RxBuf[Uart6.RxInCnt]);
/* ECHO mode End */

if(Uart6.RxInCnt<RBUF_SIZE-1) Uart6.RxInCnt++;
else Uart6.RxInCnt = 0;
}

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요

2019.11.04 14:06

keil로 컴파일하고 나니 나온 Address Offset 데이터가 위아래로 섞여 있어서 난리였습니다.

차근차근 일정한 패턴을 가지고 Address Offset가 순차로 내려갈 줄 알았는데 위, 아래, 위위, 아래 난리네요.

다운로드 프로그램을 만드는데 전부 확인해서 조립한 다음 일정 바이트씩 쪼개서 내려줘야하니 이것도 참 문제네요.

 

 

--- Intel-Hex 프로토콜 구조 ---

STX : 1byte(:)

Length : 1byte

Address Offset : 2byte

Type : 1byte

Data : 0 ~ 255byte

CheckSum : 1byte

 

 

예제)

:09 6D59 00 7D027F487E600265F7 AF
:10 6B0F 00 7D047F487E601265F77F467E601265FE CA
:0B 6B1F 00 8F3FE4FD7F467E600265F7 BB

.......

 

:03 000B 00 02530B 92
.......


:08 6A6A 00 4207C2950EBE08EA C6
:01 6A72 00 22 01
......

 

:05 000E 00 126CC17F06 29
:08 0013 00 C293126A5AD29322 33

......

:0E 6267 00 7A81798C7B01908140E0FCA3E0FD 00

:0B 6275 00 9081B2EBF0A3EAF0A3E9F0 87

Posted by 초보 HW 엔지니어 로망와니

댓글을 달아 주세요