이번에 CUBEMX 를 업데이트하고 나서, USB CDC 를 테스트 해 봤습니다.


예전에, USBD_CDC.h 파일에서 수정해야 동작하던 상수값이, 
이번 버전(Ver 4.23.0)의 CUBE MX 에서는 제대로 생성해 주는 것을 확인했고,
몇가지 간단하게 수정하면 USB CDC 를 바로 쓸 수가 있었습니다.




usbd_cdc.h  예전의 설정 (USB COM Port 장치 에러 발 생)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/** @defgroup usbd_cdc_Exported_Defines
  * @{
  */ 
#define CDC_IN_EP                                   0x81  /* EP1 for data IN */
#define CDC_OUT_EP                                  0x01  /* EP1 for data OUT */
#define CDC_CMD_EP                                  0x82  /* EP2 for CDC commands */
 
/* CDC Endpoints parameters: you can fine tune these values depending on the needed baudrates and performance. */
#define CDC_DATA_HS_MAX_PACKET_SIZE                 512  /* Endpoint IN & OUT Packet size */
#define CDC_DATA_FS_MAX_PACKET_SIZE                 64  /* Endpoint IN & OUT Packet size */
#define CDC_CMD_PACKET_SIZE                         8  /* Control Endpoint Packet size */ 
 
#define USB_CDC_CONFIG_DESC_SIZ                     67
#define CDC_DATA_HS_IN_PACKET_SIZE                  CDC_DATA_HS_MAX_PACKET_SIZE
#define CDC_DATA_HS_OUT_PACKET_SIZE                 CDC_DATA_HS_MAX_PACKET_SIZE
 
#define CDC_DATA_FS_IN_PACKET_SIZE                  CDC_DATA_FS_MAX_PACKET_SIZE
#define CDC_DATA_FS_OUT_PACKET_SIZE                 CDC_DATA_FS_MAX_PACKET_SIZE
cs


usbd_cdc.h  새로 수정된 내용(CDC_DATA_HS_MAX_PACKET_SIZE 값이 256 으로 초기설정됨)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/** @defgroup usbd_cdc_Exported_Defines
  * @{
  */ 
#define CDC_IN_EP                                   0x81  /* EP1 for data IN */
#define CDC_OUT_EP                                  0x01  /* EP1 for data OUT */
#define CDC_CMD_EP                                  0x82  /* EP2 for CDC commands */
 
/* CDC Endpoints parameters: you can fine tune these values depending on the needed baudrates and performance. */
#define CDC_DATA_HS_MAX_PACKET_SIZE                 256  /* Endpoint IN & OUT Packet size */
#define CDC_DATA_FS_MAX_PACKET_SIZE                 64  /* Endpoint IN & OUT Packet size */
#define CDC_CMD_PACKET_SIZE                         8  /* Control Endpoint Packet size */ 
 
#define USB_CDC_CONFIG_DESC_SIZ                     67
#define CDC_DATA_HS_IN_PACKET_SIZE                  CDC_DATA_HS_MAX_PACKET_SIZE
#define CDC_DATA_HS_OUT_PACKET_SIZE                 CDC_DATA_HS_MAX_PACKET_SIZE
 
#define CDC_DATA_FS_IN_PACKET_SIZE                  CDC_DATA_FS_MAX_PACKET_SIZE
#define CDC_DATA_FS_OUT_PACKET_SIZE                 CDC_DATA_FS_MAX_PACKET_SIZE
cs

그래서 수정할 내용은, 
1. #include 에서 usbd_cdc_if.h 추가하고,
1
2
#include "string.h"
#include "usbd_cdc_if.h"
cs

2. 저는 보통 cdc를 디버그 출력용으로만 사용해서 Txd 기능만 주로 사용합니다.
  - 그리고, 쓰기 편하게 printf() 함수를 사용하다 보니, string.h 파일을 include 해 줍니다.
    USB_FS 로  printf() 함수를 사용하기 위한 추가 코드는 다음과 같습니다. main.c 파일의 User code 에 추가해 주면 됩니다.
 main.c 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* USER CODE BEGIN 0 */
#ifdef __GNUC__
 #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
 #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
 
PUTCHAR_PROTOTYPE
{
 while(CDC_Transmit_FS((uint8_t *)&ch, 1) == USBD_BUSY);
 return ch;
}
 
/* USER CODE END 0 */
cs
  - JTAG 나 SSTLINK 디버거용 핀을 보드에 배치하면 보드 크기가 커져서, 저는 USB CDC를 디버깅 기능으로 사용합니다.
  - USB 만 연결해서, 프로그램 다운로드는 USB DFU 를 사용하고, 디버깅이 필요할 시 USB CDC 를 사용하면 편리합니다. ^^

3. 위 설정만 완료하면, USB COM Port 로 PC 와 통신하면 됩니다.




다음은 간단한 USB CDC 출력 테스트 프로그램입니다.
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
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_hal.h"
#include "usb_device.h"
 
/* USER CODE BEGIN Includes */
#include "string.h"
#include "usbd_cdc_if.h"
 
/* USER CODE END Includes */
 
/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;
 
/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);
 
/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/
 
/* USER CODE END PFP */
 
/* USER CODE BEGIN 0 */
#ifdef __GNUC__
 #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
 #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
 
PUTCHAR_PROTOTYPE
{
 while(CDC_Transmit_FS((uint8_t *)&ch, 1) == USBD_BUSY);
 return ch;
}
 
/* USER CODE END 0 */
 
int main(void)
{
 
  /* USER CODE BEGIN 1 */
 
  /* USER CODE END 1 */
 
  /* MCU Configuration----------------------------------------------------------*/
 
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* USER CODE BEGIN Init */
 
  /* USER CODE END Init */
 
  /* Configure the system clock */
  SystemClock_Config();
 
  /* USER CODE BEGIN SysInit */
 
  /* USER CODE END SysInit */
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_I2C1_Init();
  MX_USB_DEVICE_Init();
 
  /* USER CODE BEGIN 2 */
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
        printf("USB CDC Test ^^\r\n");
        HAL_Delay(500);
  /* USER CODE END WHILE */
 
  /* USER CODE BEGIN 3 */
 
  }
  /* USER CODE END 3 */
 
}
cs


터미날 프로그램으로 테스트한 내용입니다.



alpu_v100.zip


저작자표시 비영리

'STM32F4' 카테고리의 다른 글

[STM32F4xx] UART1 DMA Receive Test (s/w test)  (0) 2018.09.06
[STM32F4xx] UART2 DMA Receive Test (s/w test)  (0) 2018.09.06
[STM32F4xx] UART DMA Receive Test (H/W 및 CUBEMX 설정)  (0) 2018.09.06
[STM32F4xx] I2C DMA 프로그램 (CUBEMX)  (1) 2018.09.06
[STM32F4xx] I2C DMA 설정 (CUBEMX)  (0) 2018.09.06

지난 번의 IDLE IT 를 사용한 DMA 테스트는 UART2에서 한 테스트였고,

이번에는 UART1 에서 테스트를 해 봤다.

수정할 내용만 적어 보면 다음과 같다.

UART1 인터럽트함수의 코드는 다음과 같다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
    /* Check for IDLE flag */
    if (USART1->SR & UART_FLAG_IDLE) {         /* We want IDLE flag only */
        /* This part is important */
        /* Clear IDLE flag by reading status register first */
        /* And follow by reading data register */
        volatile uint32_t tmp;                  /* Must be volatile to prevent optimizations */
        tmp = USART1->SR;                       /* Read status register */
        tmp = USART1->DR;                       /* Read data register */
        (void)tmp;                              /* Prevent compiler warnings */
        __HAL_DMA_DISABLE(&hdma_usart1_rx);
    }    
    return;
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */
 
  /* USER CODE END USART1_IRQn 1 */
}
cs
 
UART1 의 DMA 인터럽트는 DMA2_Stream2_IRQHandler 함수를 사용한다.
코드는 다음과 같다.
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
void DMA2_Stream2_IRQHandler(void)
{
  /* USER CODE BEGIN DMA2_Stream2_IRQn 0 */
    size_t len, tocopy;
    uint8_t* ptr;
    
    /* Check transfer complete flag */
    if (DMA2->LISR & DMA_FLAG_TCIF2_6) {
        DMA2->LIFCR = DMA_FLAG_TCIF2_6;           /* Clear transfer complete flag */
        
        /* Calculate number of bytes actually transfered by DMA so far */
        /**
         * Transfer could be completed by 2 events:
         *  - All data actually transfered (NDTR = 0)
         *  - Stream disabled inside USART IDLE line detected interrupt (NDTR != 0)
         */
        len = DMA_RX_BUFFER_SIZE - DMA2_Stream2->NDTR;
        tocopy = UART_BUFFER_SIZE - Write;      /* Get number of bytes we can copy to the end of buffer */
        
        /* Check how many bytes to copy */
        if (tocopy > len) {
            tocopy = len;
        }
        
        /* Write received data for UART main buffer for manipulation later */
        ptr = DMA_RX_Buffer;
        memcpy(&UART_Buffer[Write], ptr, tocopy);   /* Copy first part */
                
        
        /* Correct values for remaining data */
        Write += tocopy;
        len -= tocopy;
        ptr += tocopy;
        
        /* If still data to write for beginning of buffer */
        if (len) {
            memcpy(&UART_Buffer[0], ptr, len);      /* Don't care if we override Read pointer now */
            Write = len;
        }
        
        /* Prepare DMA for next transfer */
        /* Important! DMA stream won't start if all flags are not cleared first */
        //DMA2->HIFCR = DMA_FLAG_DMEIF1_5 | DMA_FLAG_FEIF1_5 | DMA_FLAG_HTIF1_5 | DMA_FLAG_TCIF1_5 | DMA_FLAG_TEIF1_5;
        DMA2->LIFCR = DMA_FLAG_DMEIF2_6 | DMA_FLAG_FEIF2_6 | DMA_FLAG_HTIF2_6 | DMA_FLAG_TCIF2_6 | DMA_FLAG_TEIF2_6;
        DMA2_Stream2->M0AR = (uint32_t)DMA_RX_Buffer;
        DMA2_Stream2->NDTR = DMA_RX_BUFFER_SIZE;
        __HAL_DMA_ENABLE(&hdma_usart1_rx);
        //DMA1_Stream5->CR |= DMA_SxCR_EN;            /* Start DMA transfer */
    }
    return;
  /* USER CODE END DMA2_Stream2_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart1_rx);
  /* USER CODE BEGIN DMA2_Stream2_IRQn 1 */
 
  /* USER CODE END DMA2_Stream2_IRQn 1 */
}
cs

main() 함수 코드 내용은 다음과 같습니다.
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
int main(void)
{
 
  /* USER CODE BEGIN 1 */
  /* USER CODE END 1 */
 
  /* MCU Configuration----------------------------------------------------------*/
 
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* USER CODE BEGIN Init */
 
  /* USER CODE END Init */
 
  /* Configure the system clock */
  SystemClock_Config();
 
  /* USER CODE BEGIN SysInit */
 
  /* USER CODE END SysInit */
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();
 
  /* USER CODE BEGIN 2 */
    __HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart1,DMA_RX_Buffer,DMA_RX_BUFFER_SIZE);
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */
 
  /* USER CODE BEGIN 3 */
        if (Read != Write)
        { 
            __wfi();    // or __wfe();
            //__HAL_UNLOCK(&huart2);
            //__HAL_LOCK(&huart2);
            while (!(USART1->SR & USART_SR_TXE));   /* Wait till finished */
            USART1->DR = UART_Buffer[Read++];
            //HAL_UART_Transmit(&huart2,(uint8_t *)UART_Buffer[Read++],1,1);
            //while (!(USART2->SR & USART_SR_TC));   /* Wait till finished */
            //while (!(__HAL_UART_GET_FLAG(&huart2, UART_FLAG_TXE))){};
                    
                    
            if (Read > UART_BUFFER_SIZE) /* Check buffer overflow */
            {     
                    Read = 0;
            }
        }
        //while(HAL_GPIO_ReadPin(B1_GPIO_Port,B1_Pin) == GPIO_PIN_RESET);
        //while(HAL_GPIO_ReadPin(B1_GPIO_Port,B1_Pin) == GPIO_PIN_SET);
        
  }
  /* USER CODE END 3 */
 
}
cs


저작자표시 비영리

'STM32F4' 카테고리의 다른 글

[STM32F4xx] USB CDC 테스트 (STM32F411)  (0) 2018.09.06
[STM32F4xx] UART2 DMA Receive Test (s/w test)  (0) 2018.09.06
[STM32F4xx] UART DMA Receive Test (H/W 및 CUBEMX 설정)  (0) 2018.09.06
[STM32F4xx] I2C DMA 프로그램 (CUBEMX)  (1) 2018.09.06
[STM32F4xx] I2C DMA 설정 (CUBEMX)  (0) 2018.09.06

이전 글에 이어서, 프로그램 동작 테스트를 해 보겠습니다.


CUBEMX에 의해 생성된 기본 코드에서, 추가할 내용은 다음과 같습니다.
[main.c]
1. UART_IT_IDLE 인터럽트 설정.
2. UART RX DMA 설정.

[stm32f4xx_it.c]
1. USART2_IRQHandler 함수에서, HAL_UART_IRQHandler 를 사용하지 않고(너무 느림), 
   IDLE 인터럽트만 처리하도록 수정. IDLE 인터럽트 발생시, DMA rx 인터럽트 강제 발생 후, DMA Disable.
2. DMA1_Stream5_IRQHandler 함수에서 HAL_DMA_IRQHandler 함수를 쓰지 않고,
   FIFO 에서 데이터를 사용자 UART 버퍼로 copy 해온 후, DMA Enable.


다음은 위의 내용에 대한 상세 설명 입니다.
[main.c]
1. UART_IT_IDLE 인터럽트 설정.
2. UART RX DMA 설정.
[기본 변수, 및 define 설정 내용]
1
2
3
4
5
6
7
#define UART_BUFFER_SIZE         1024
#define DMA_RX_BUFFER_SIZE         1024
 
uint8_t UART_Buffer[UART_BUFFER_SIZE];
uint8_t DMA_RX_Buffer[DMA_RX_BUFFER_SIZE];
size_t Write, Read;
 
cs
버퍼 Size 는 대충 잡은 것이니 적당히 수정하시기 바랍니다. 많으면 스택하고 메모리가 많이 들어가니까요.
[설정 코드]
1
2
    __HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart2,DMA_RX_Buffer,DMA_RX_BUFFER_SIZE);
cs
링크 건, 블로그는 정말 복잡한데, HAL 로 하니 2줄이면 끝. (CUBEMX가 알아서 설정해 줘서 그렇습니다)

[stm32f4xx_it.c]
1. USART2_IRQHandler 함수에서, HAL_UART_IRQHandler 를 사용하지 않고(너무 느림), 
   IDLE 인터럽트만 처리하도록 수정. IDLE 인터럽트 발생시, DMA rx 인터럽트 강제 발생 후, DMA Disable.
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
/**
* @brief This function handles USART2 global interrupt.
*/
void USART2_IRQHandler(void)
{
  /* USER CODE BEGIN USART2_IRQn 0 */
    /* Check for IDLE flag */
    if (USART2->SR & UART_FLAG_IDLE) {         /* We want IDLE flag only */
        /* This part is important */
        /* Clear IDLE flag by reading status register first */
        /* And follow by reading data register */
        volatile uint32_t tmp;                  /* Must be volatile to prevent optimizations */
        tmp = USART2->SR;                       /* Read status register */
        tmp = USART2->DR;                       /* Read data register */
        (void)tmp;                              /* Prevent compiler warnings */
                __HAL_DMA_DISABLE(&hdma_usart2_rx);
 
        //DMA1_Stream5->CR &= ~DMA_SxCR_EN;       /* Disabling DMA will force transfer complete interrupt if enabled */
    }    
    return;
  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart2);
  /* USER CODE BEGIN USART2_IRQn 1 */
 
  /* USER CODE END USART2_IRQn 1 */
}
cs

위에서 HAL_UART_IRQHandler() 함수 전에 return; 을 사용해주면, 
간단히 이후의 코드 실행을 막을 수 있습니다. ^^

2. DMA1_Stream5_IRQHandler 함수에서 HAL_DMA_IRQHandler 함수를 쓰지 않고,
   FIFO 에서 데이터를 사용자 UART 버퍼로 copy 해온 후, DMA Enable.
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
/**
* @brief This function handles DMA1 stream5 global interrupt.
*/
void DMA1_Stream5_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Stream5_IRQn 0 */
    size_t len, tocopy;
    uint8_t* ptr;
    
    /* Check transfer complete flag */
    if (DMA1->HISR & DMA_FLAG_TCIF1_5) {
        DMA1->HIFCR = DMA_FLAG_TCIF1_5;           /* Clear transfer complete flag */
        
        /* Calculate number of bytes actually transfered by DMA so far */
        /**
         * Transfer could be completed by 2 events:
         *  - All data actually transfered (NDTR = 0)
         *  - Stream disabled inside USART IDLE line detected interrupt (NDTR != 0)
         */
        len = DMA_RX_BUFFER_SIZE - DMA1_Stream5->NDTR;
        tocopy = UART_BUFFER_SIZE - Write;      /* Get number of bytes we can copy to the end of buffer */
        
        /* Check how many bytes to copy */
        if (tocopy > len) {
            tocopy = len;
        }
        
        /* Write received data for UART main buffer for manipulation later */
        ptr = DMA_RX_Buffer;
        memcpy(&UART_Buffer[Write], ptr, tocopy);   /* Copy first part */
        
        /* Correct values for remaining data */
        Write += tocopy;
        len -= tocopy;
        ptr += tocopy;
        
        /* If still data to write for beginning of buffer */
        if (len) {
            memcpy(&UART_Buffer[0], ptr, len);      /* Don't care if we override Read pointer now */
            Write = len;
        }
        
        /* Prepare DMA for next transfer */
        /* Important! DMA stream won't start if all flags are not cleared first */
                DMA1->HIFCR = DMA_FLAG_DMEIF1_5 | DMA_FLAG_FEIF1_5 | DMA_FLAG_HTIF1_5 | DMA_FLAG_TCIF1_5 | DMA_FLAG_TEIF1_5;
                DMA1_Stream5->M0AR = (uint32_t)DMA_RX_Buffer;
                DMA1_Stream5->NDTR = DMA_RX_BUFFER_SIZE;
                __HAL_DMA_ENABLE(&hdma_usart2_rx);
        //DMA1_Stream5->CR |= DMA_SxCR_EN;            /* Start DMA transfer */
    }
        return;
  /* USER CODE END DMA1_Stream5_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_usart2_rx);
  /* USER CODE BEGIN DMA1_Stream5_IRQn 1 */
 
  /* USER CODE END DMA1_Stream5_IRQn 1 */
}
cs


이렇게 하면, STM32 의 UART RX 에서 FIFO 가 없어서, 데이터를 놓칠 걱정은 더 이상 하지 않아도 됩니다. ^^

주의할 점이 하나 있는데, IDLE 인터럽트를 걸리도록 데이터를 PC 나 다른 장치에서 송신해야 한다는 점입니다.
파일을 전송하는 테스트를 진행해 본 결과, 
DMA RX Buffer 보다 큰 크기와 설정한 DMA 길이 보다 큰 데이터 스트링을 보낼 경우는 다음과 같이, 
송신하는 측에서 딜레이를 약간 줘야 합니다.

그래야, STM32 에서 DMA 데이터를 USER buff에 copy할 수 있습니다. 
저는 tera term 에서 line 당 지연을 1ms 줬습니다.







main.c 의 main() 에서 받은 데이터가 있으면, 그대로 term에 뿌리도록 해서,
파일을 전송 해 보니, 잘 수신 되었음을 알 수 있었습니다.





또 하나, 정말 모르겠던 부분이 있습니다.
HAL_UART_Transmit 함수로 사용해도 되긴 하는데, 너무 내부 코드가 많아서 바꿔 봤는데,
바꾼 코드가 아무리 해도 실행이 안되서, 앞에 __wfi() 나 __wfe() 를 넣어 보니 잘 돌아가더라고요.
순전히 ,  여러가지 넣어 보면서 허송 세월을 보내 버렸네요.
왜 이렇게 되는지 혹시 아시는분 댓글 부탁합니다. 
1
2
3
__wfi();    // or __wfe();
while (!(USART2->SR & USART_SR_TXE));   /* Wait till finished */
USART2->DR = UART_Buffer[Read++];
cs

위와 동일한 코드
1
HAL_UART_Transmit(&huart2,(uint8_t *)UART_Buffer[Read++],1,1);
cs


전체 main() 함수 내용.
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
int main(void)
{
 
  /* USER CODE BEGIN 1 */
  /* USER CODE END 1 */
 
  /* MCU Configuration----------------------------------------------------------*/
 
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* USER CODE BEGIN Init */
 
  /* USER CODE END Init */
 
  /* Configure the system clock */
  SystemClock_Config();
 
  /* USER CODE BEGIN SysInit */
 
  /* USER CODE END SysInit */
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART2_UART_Init();
 
  /* USER CODE BEGIN 2 */
    __HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart2,DMA_RX_Buffer,DMA_RX_BUFFER_SIZE);
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */
 
  /* USER CODE BEGIN 3 */
        if (Read != Write)
        { 
            __wfi();    // or __wfe();
            //__HAL_UNLOCK(&huart2);
            //__HAL_LOCK(&huart2);
            while (!(USART2->SR & USART_SR_TXE));   /* Wait till finished */
            USART2->DR = UART_Buffer[Read++];
            //HAL_UART_Transmit(&huart2,(uint8_t *)UART_Buffer[Read++],1,1);
            //while (!(USART2->SR & USART_SR_TC));   /* Wait till finished */
            //while (!(__HAL_UART_GET_FLAG(&huart2, UART_FLAG_TXE))){};
                    
                    
            if (Read > UART_BUFFER_SIZE) /* Check buffer overflow */
            {     
                    Read = 0;
            }
        }
        //while(HAL_GPIO_ReadPin(B1_GPIO_Port,B1_Pin) == GPIO_PIN_RESET);
        //while(HAL_GPIO_ReadPin(B1_GPIO_Port,B1_Pin) == GPIO_PIN_SET);
        
  }
  /* USER CODE END 3 */
 
}
cs


keil 5 로 만든 코드와, cubemx ioc 파일을 첨부합니다.

uart_rx_dma.zip


저작자표시 비영리

'STM32F4' 카테고리의 다른 글

[STM32F4xx] USB CDC 테스트 (STM32F411)  (0) 2018.09.06
[STM32F4xx] UART1 DMA Receive Test (s/w test)  (0) 2018.09.06
[STM32F4xx] UART DMA Receive Test (H/W 및 CUBEMX 설정)  (0) 2018.09.06
[STM32F4xx] I2C DMA 프로그램 (CUBEMX)  (1) 2018.09.06
[STM32F4xx] I2C DMA 설정 (CUBEMX)  (0) 2018.09.06

휴, 밤새 테스트해보다 겨우 됐네요.


이번에 다룰 내용은, STM32F4xx 의 uart Rx 에서 DMA 함수를 사용하면 발생하는 불편함을 수정하는 내용입니다.
DMA를 사용하면, RX data를 수신할 때, 1-Byte마다 인터럽트가 걸리지 않으므로 그 시간만큼 다른 일을 할 수가 있습니다.
일종의 코프로세서라고 말하는 사람도 있습니다. 또는 듀얼코어..

그런데 UART DMA RX 는 HAL 함수에서, 또는 다른 라이브러리 함수에서(다른 함수들은 안써봐서 잘 모름),
지정한 길이 만큼만 받아야 인터럽트가 발생해서,
지정한 길이만큼 받지 않으면 데이터를 갖고 올 수가 없었습니다.

또한 UART RX 시에는 언제, 몇개의 데이터가 들어 올지 미리 알 수가 없는 상황이 대부분이라,
저 같은 경우에는 UART RX DMA를 쓰는 경우는 전혀 없습니다. 쓰려면 TX DMA 를 쓰죠.

예를 들자면 
HAL_UART_Receive_DMA(&huart2,DMA_RX_Buffer,10); 
위와같이 특정 개수 만큼(10개) DMA 로 받겠다고 하면, 
10개 이하는 DMA 인터럽트가 안 떠서 데이터를 못 받고,
10개 이상 받으면, 10개는 받고 나머지 10개 이상은 받지 못하게 됩니다.

이와 같은 점을 수정한 방법이 UART_IDLE 인터럽트를 쓰는 방법입니다.
UART_IDLE 인터럽트는 데이터를 수신하다가 1개 이상 데이터가 수신되지 않을 시 걸리는 인터럽트입니다.
보통 연속으로 데이터가 오다가, 다 보냈을 경우 1개 이상의 데이터가 수신되지 않는 경우가 무조건 발생하게 됩니다.
이 때, UART RX DMA 인터럽트를 강제로 발생시키도록 하는 원리 입니다.

이 내용은, 예전부터 외국 블로그에서 공개한 내용인데 실제로 사용할 수 있도록 테스트를 해 보지 못했습니다.
참고로 한 사이트 주소는 다음과 같습니다.


사용한 H/W 는 ST 의 NUCLEO-F411RE 입니다.
UART만 테스트 하는 거라, 이미 내부 디버거(ST-LINK)에 의해 USB-to-UART 연결된 UART2를 사용했습니다.

H/W 구성 및 CUBEMX 설정은 다음과 같습니다.




저작자표시 비영리

'STM32F4' 카테고리의 다른 글

[STM32F4xx] UART1 DMA Receive Test (s/w test)  (0) 2018.09.06
[STM32F4xx] UART2 DMA Receive Test (s/w test)  (0) 2018.09.06
[STM32F4xx] I2C DMA 프로그램 (CUBEMX)  (1) 2018.09.06
[STM32F4xx] I2C DMA 설정 (CUBEMX)  (0) 2018.09.06
[STM32F4xx] I2C Device Address 찾기  (0) 2018.09.06

저도 예전부터 고민하던 내용인데,

UART 는 TX는 고민 거리가 아니죠. 
내보낼 데이터 개수는 미리 알 수 있어서 DMA로 보내면 CPU에 무리를 안주고 보낼 수 있으니까요.

그런데, 다양한 프로토콜이 있어서 길이가 재각각이거나, 데이터가 깨져서 길이(데이터 개수)가 틀려질 경우,
DMA 로 수신시에 받을 데이터의 개수를 알 수 없죠.
DMA는 미리 '몇 개 받겠다' 라고 선언하고 실행하도록 되어 있습니다. - 덜 받거나, 더 받으면 문제가 생기죠.

이와 같은 부분을 해결하는 솔루션이 다음 링크에 나와 있습니다.
시간이 안되서 못 해보는데, 사용할 생각 입니다. ^^ 


저작자표시 비영리

'STM32F4' 카테고리의 다른 글

[STM32F4xx] Over clocking (100MHz->160MHz)  (0) 2018.09.06
[STM32F4x9] DMA2D(Chrom-Art Accelerator) 는 어떻게/어디에 쓰는가?  (0) 2018.09.06
[STM32F4xx] USB MSC 에서 파일 깨짐 현상  (0) 2018.09.06
[STM32F4xx] USB MSC (SD-Card FAT32) 의 속도 비교.  (0) 2018.09.06
[STM32F4xx] USB MSC & Multiple File Open  (0) 2018.09.06
[2017.04.19] - 내용 추가 
최근에 겪었던 내용을 추가합니다.
얼마전에 여러 기능을 갖고 있는 APP에 UART Rx Interrupt 코드를 추가했는데, 천천이 데이터를 받으면 괜찮은데, 빨리 데이터를 받으면 UART RX Interrupt 기능이 동작하지 않았습니다. 
고전적인 방법을 쓰지 않고 HAL 라이브러리에 의해 프로그램을 만들어서 그런지, 느리고 무거운 느낌이 들었습니다.
HAL 드라이버가 다양한 기능을 한 번에 처리하고 , 사용하기 쉽다고 하지만 인터럽트 처리에 있어서는 효율이 떨어지는 것 같습니다.

위와 같이 죽었던 문제점은 HAL 드라이버를 사용하지 않았더니 없어졌습니다.
다음의 글을 참고로 코드를 작성했습니다. 설명이 아주 작 되어 있으니 참고하시기 바랍니다.


어쩌면 USB-to-UART 프로그램으로 ESP8266 에 다운로드가 안되는 문제도 위와 같이 수정하면, 잡힐 것도 같습니다.
----------------------------------------------------------------------------------------------

안녕하세요,

글을 쓸 소재들이 요즘 많아 졌는데, 올릴 시간이 없군요.

얼마 전에 PSOC5로, 
1. 일반 TR(MMBT3904)의 내부 다이오드에 정전류를 흘려서 전압을 재서 온도를 측정한 것도 있고,
2. 열전대로 온도 측정 및 열전대 측정값 디지탈 필터로 노이즈 제거,
3. PSOC5 의 새로운 콤포넌트인 LED Driver 로 7-SEGMENT 7개와 8개의 LED 다이나믹 스캔 제어(DMA로 구성되어 CPU에 부하를 주지 않음)
4. 다이오드 상온 측정값과 열전대의 목표지점의 온도를 측정하면서, PID로 전열기를 제어,
5. STM32F4xx 로 USB VCP 를 통해서 UART로 ESP-8266의 프로그램을 Upload (테스트 완료 예정)
6. ESP-8266으로 FTP 서버 만들기(SPIFF:완료,SD-CARD:테스트 중,SOFT AP FTP Server:테스트 중)의 글을 올릴 생각입니다.

이번에는 5. STM32F4xx 로 USB CDC 를 통해서 UART로 ESP-8266의 프로그램을 Upload (테스트 완료 예정) 을 
테스트하기위해 우선, STM32F4xx로 USB-to-UART 통신 테스트를 했습니다.


예전에 USB CDC 로 Tx 테스트를 해서 글을 올려 놓았는데 (http://cafe.naver.com/cortexsh/997),
USB CDC Rx(데이터를 USB Serial Port로 받는) 테스트는 정말 구현하기 힘들었습니다.

여기저기 인터넷을 뒤지고 뒤져서 겨우 단서를 하나 찾았습니다. (http://www.openstm32.org/forumthread2250)




다음의 사이트에서 STM32Cube_FW_F4_Vxx 라는 펌웨어 예제(링크)들이 있는데, 
다운 받은 zip 파일을 풀어, 
그 중에서 STM324xG EVAL/Application/USB_Device/CDC_Standalone 의 프로젝트를 참고하라고 되어 있었습니다.
이 예제를 많이 참고해서 STM32F4xx 보드로 USB-to-UART 를 구현할 수 있었습니다.

STM32F4xx 에서 사용한 내부 기능은 다음과 같습니다.
1. UART2 : UART TX (DMA 전송) , UART RX (RX Interrupt)
2. TIM2 : 5ms 마다 USB Rx로 수신된 데이터를 UART2 로 DMA 전송
3. USB Device Only : USB CDC(Communication Device Class) 초기화 함수를 실행하면,
 데이터가 자동으로(인터럽트에 의해) 수신되면서 CDC_Receive_FS() 함수가 실행됨.




[사용하지 않는 핀 설명]
위의 그림에서 
- ESP_RST(GPIO_OUT) , ESP_FLASH(GPIO_OUT) 은 나중에 ESP-8266 에 프로그램을 업로드하기 위해,
모드를 RUN-MODE,FLASH-MODE 로 변경하기 위해 설정해 놓았고 현재는 사용하지 않는다.
- 또, UART1 Rx/Tx 핀은 ESP-8266 에 프로그램을 Upload 할 때 사용하는 UART 핀으로 설정한 것으로,
현재는 사용하지 않는다.


개략적으로 프로그램 동작을 설명하자면, 
1. STM32F4xx Nucleo 보드에 UART2 와 USB CDC, TIM2 Update Interrupt 기능을 
   CUBEMX 툴로 사용하도록 설정하고 KEIL MDK 5.0 소스코드를 생성.



2. UART2 , USB CDC , TIM2 초기화.
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
// usb_device.c
/* init function */                        
void MX_USB_DEVICE_Init(void)
{
  /* Init Device Library,Add Supported Class and Start the library*/
  USBD_Init(&hUsbDeviceFS, &FS_Desc, DEVICE_FS);
 
  USBD_RegisterClass(&hUsbDeviceFS, &USBD_CDC);
 
  USBD_CDC_RegisterInterface(&hUsbDeviceFS, &USBD_Interface_fops_FS);
 
  USBD_Start(&hUsbDeviceFS);
 
}
 
------------------------------------------------------------------------------
 
// main.c 
/* USART2 init function */
static void MX_USART2_UART_Init(void)
{
 
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
 
}
 
static void MX_DMA_Init(void) 
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();
 
  /* DMA interrupt init */
  /* DMA1_Stream6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
 
}
 
/* TIM2 init function */
static void MX_TIM2_Init(void)
{
 
  TIM_ClockConfigTypeDef sClockSourceConfig;
  TIM_MasterConfigTypeDef sMasterConfig;
 
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 0;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 960000/2;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
 
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
}
 
cs

3. UART2 RX인터럽트에 의해 데이터 수신시 USB CDC TX 큐버퍼에 데이터 저장. (in main.c)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
  /* Increment Index for buffer writing */
  UserTxBufPtrIn++;
  
  /* To avoid buffer overflow */
  if(UserTxBufPtrIn == APP_RX_DATA_SIZE)
  {
    UserTxBufPtrIn = 0;
  }
  
  /* Start another reception: provide the buffer pointer with offset and the buffer size */
  HAL_UART_Receive_IT(huart, (uint8_t *)(UserTxBufferFS + UserTxBufPtrIn), 1);
  /* NOTE: This function Should not be modified, when the callback is needed,
           the HAL_UART_TxCpltCallback could be implemented in the user file
   */
}
cs

4. 5ms 마다 TIM2 Update 인터럽트가 걸리면 UART2 RX로 받은 데이터가 있는지 체크해서  
USB CDC TX 큐버퍼에 있는 데이터를 USB CDC Tx 핀으로 모두 송신. (in main.c)
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
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    uint32_t buffptr;
    uint32_t buffsize;
 /* Prevent unused argument(s) compilation warning */
    if (htim->Instance == TIM2)
    {
  
  if(UserTxBufPtrOut != UserTxBufPtrIn)
  {
    if(UserTxBufPtrOut > UserTxBufPtrIn) /* Rollback */
    {
      buffsize = APP_TX_DATA_SIZE - UserTxBufPtrOut;
    }
    else 
    {
      buffsize = UserTxBufPtrIn - UserTxBufPtrOut;
    }
    
    buffptr = UserTxBufPtrOut;
    
    USBD_CDC_SetTxBuffer(&hUsbDeviceFS, (uint8_t*)&UserTxBufferFS[buffptr], buffsize);
    
    if(USBD_CDC_TransmitPacket(&hUsbDeviceFS) == USBD_OK)
    {
      UserTxBufPtrOut += buffsize;
      if (UserTxBufPtrOut == APP_RX_DATA_SIZE)
      {
        UserTxBufPtrOut = 0;
      }
    }
  }
    }
    else if (htim->Instance == TIM1)
    {
    }
  /* NOTE : This function Should not be modified, when the callback is needed,
            the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
   */
}
cs

5. USB CDC Rx로 인터럽트에 의해 Rx 큐버퍼에 데이터가 수신되면,
 바로 UART2 로 데이터를 DMA 방식으로 전송. (in usbd_cdc_if.c)
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
/**
  * @brief  CDC_Receive_FS
  *         Data received over USB OUT endpoint are sent over CDC interface 
  *         through this function.
  *           
  *         @note
  *         This function will block any OUT packet reception on USB endpoint 
  *         untill exiting this function. If you exit this function before transfer
  *         is complete on CDC interface (ie. using DMA controller) it will result 
  *         in receiving more data while previous ones are still not sent.
  *                 
  * @param  Buf: Buffer of data to be received
  * @param  Len: Number of data received (in bytes)
  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
  */
static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len)
{
  /* USER CODE BEGIN 6 */
 
  USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
  USBD_CDC_ReceivePacket(&hUsbDeviceFS);
    HAL_UART_Transmit_DMA(&huart2, Buf, *Len);
  return (USBD_OK);
  /* USER CODE END 6 */ 
}
 
cs

6. 1~5번 항목을 무한 반복.


다음은 실제 Nucleo 보드와 USB 케이블 연결된 사진 입니다.





다음 그림은 프로그램을 실행함에 따라서, 장치관리자로 COM 포트가 생성된 모습입니다.




다음은 테라텀 프로그램으로 각각의 COM 포트에 연결해서 송수신 테스트를 해 본 사진입니다.




다음은 실시간 테스트 영상입니다.


마지막으로 이 프로젝트의 소스 파일을 첨부합니다.


저작자표시 비영리

'STM32F4' 카테고리의 다른 글

[STM32F4xx] Nucleo 보드 테스트 #27 (embedded DFU 모드 테스트 : S/W)  (0) 2018.09.02
[STM32F4xx] Nucleo 보드 테스트 #26 (embedded DFU 모드 테스트 : H/W)  (0) 2018.09.02
[STM32F4xx] Nucleo 보드 테스트 #24 (STLINK 테스트 : KEIL)  (0) 2016.12.15
[STM32F4xx] Custom 보드 테스트 #23 (USB CDC.STM32F446 : KEIL)  (2) 2016.12.15
[STM32F4xx] Nucleo 보드 테스트 #22 (DFU Bootloadable APP프로그램 : KEIL)  (0) 2016.12.01

다음은 USE_LFN(Use Long Filename) 설정하는 방법에 대해서 알아 보겠습니다.


아주 오래 전에 윈도우에서 dir 하고 command line 명령을 치면,
파일명이 xxxxx~1 라고 나온 경험이 좀 있으실 겁니다.

파일 이름이 긴 파일을 표시하지 못하는 경우입니다. 
이것을 해결하는 방법은 간단합니다.

큐브 툴에서 Configuration 을 클릭해서 창이 하나 뜨고 거기에서 FATFS 를 클릭합니다.
그러면 다시 FATFS Configuration 창이 하나 뜨는데, 
여기서 Locale and Namespace Parameters 의 USE_LFN 항목을 클릭하여 Disable 되어 있던 것을 
Enable with static working buffer on the BSS(1) 로 바꿔 주면 됩니다.



그런 다음 project > Generate Code 하시고 Keil 컴파일러에서 컴파일해서 STM32f4xx 보드에 다운로드하고 실행하면
다음과 같이 긴 파일 이름을 쓰실 수 있습니다.


아래 13번 글과 함께 사용했던 소스 파일 첨부합니다.

sd_LEDSigne_v100.zip


'STM32F4' 카테고리의 다른 글

[STM32F4xx] Nucleo 보드 테스트 #16 (mem to GPIO DMA:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #15(uSD Card Read(DMA,4Bit):KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #13(FATFS : f_read 함수 와 stack:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #12(printf 함수 사용:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #11(GPIO 병렬 출력:KEIL)  (0) 2016.12.01

안녕하세요,


요 근래, 파일 시스템 테스트 하다가 안되서 고생고생 했네요.

그 고생한 내용은 다음과 같습니다.

파일 관련 함수는 거의 다 테스트를 했는데, f_read() 함수만 유독 실행이 될 때도 있고, 
어떤 때는 계속 실행이 안되고 Hardfault Error 인터럽트로 점프해서 멈춰 있었습니다.

같은(거의 비슷한?) 입력 파라메터를 갖고 있는 f_write() 함수는 또 잘 된다.
FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from a file */
FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to a file */

하~.., 그래서 사용자 함수를 하나 만들어서 파라메터를 f_read() 와 같이 정의를 해서 테스트를 해보니 f_read()함수와 같은 증상이 발생. ㅜㅜ

안되는 원인을 찾아 보려고 f_read()함수의 파라메터의 입력을 각각 1가지씩 사용자 함수에 적용해서 테스트를 해 봤더니,
입력 인자 중 void* buff 가 문제였습니다.

원인은 입력 인자인 배열(void *buff)을 f_write()에서 보다 많이 잡아서 Stack overflow 가 걸리는 것이었습니다.

에러가 나면 스택 오버플로우 인지 확인도 못하고(혹시 아시는 분 있으시면 방법을 알려 주시면 감사하겠습니다),
그냥 프로그램이 멈춰버리니.. 며칠을 밤새고 나서야 찾을 수 있었습니다.

이번 글의 요점은, 파일 시스템 관련 함수를 사용할 경우에는 스텍을 충분히 확보하라 입니다.

그럼, 다음은 스텍을 늘리는 방법입니다. 방법은 2가지가 있네요.
1. startup_stm32f411xe.s 파일을 열어서 다음과 같이 스택 사이즈를 변경합니다.



2. CUBE 툴에서 project > Setting 메뉴에서 수정할 수도 있습니다. (저는 큐브 툴로 KEIL 소스를 만들어서 이런 방법도 있음을 알려 드립니다)



스택이 0x400 일 때 멈춰버린 프로그램이..



스택을 0x800 으로 고치니까 아주 잘 됩니다. 잘 되서 f_lseek()함수도 사용해서 파일의 offset를 막 이동해 가면서 읽어서 UART로 마구마구 뿌려 댔습니다. ^^



그런데, 나중에 알게된 사실인데... 

큐브 툴의 Help 메뉴를 누르면 UM1718.pdf 파일이 열리는데, 이 곳의 7번의 제목의 글에 스택을 충분이 할당하라는 내용이 약간 나옵니다. ㅜㅜ 저와 같은 문제로 고생하는 사람이 많진 않지만 약간 있나 봅니다.
많았으면 반드시 스택을 많이 잡고 시작하라고 했을 텐데.





그리고 이 PDF의 파일 시스템 예제가 인터넷에 돌아다니는 예제 보다, 가장 잘 나온 것 같습니다.
참고하시면 도움이 될 것 같습니다.


'STM32F4' 카테고리의 다른 글

[STM32F4xx] Nucleo 보드 테스트 #15(uSD Card Read(DMA,4Bit):KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #14(FATFS : USE_LFN:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #12(printf 함수 사용:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #11(GPIO 병렬 출력:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 #10 (crome 에서 바로 동작하는 무료 컴파일러)  (0) 2016.12.01

STM32F4xx에서 uart2 로 printf()함수를 사용하는 방법을 테스트 해보고 정보를 공유합니다.


다음과 같은 코드를 main.c 파일에 추가하면 됩니다.

/* USER CODE BEGIN 0 */
#ifdef __GNUC__
 #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
 #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
 
PUTCHAR_PROTOTYPE
{
 HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 1);
 return ch;
}
/* USER CODE END 0 */



이 코드를 추가하기 전에 huart2 는 정의를 해야겠죠.
그리고 uart HAL 함수 HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 1); 를 사용해서 폴링으로 1Byte 전송하도록 되어 잇습니다.


'STM32F4' 카테고리의 다른 글

[STM32F4xx] Nucleo 보드 테스트 #14(FATFS : USE_LFN:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #13(FATFS : f_read 함수 와 stack:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #11(GPIO 병렬 출력:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 #10 (crome 에서 바로 동작하는 무료 컴파일러)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #9(SPI Polling:KEIL)  (0) 2016.12.01

I2C 통신으로 간단하게 EEPROM(AT24C04) 를 읽기/쓰기 테스트 해 봤습니다.


예전에 PSOC4로 해 놓은 자료가 있으니까, 자세한 설명은 빼고 동작 테스트만 해 보겠습니다.

먼저 I2C 인터럽트를 사용하여 데이터를 보내고 받는 함수들은 다음과 같습니다. 
1. HAL_I2C_Master_Transmit_IT()
   : I2C 인터럽트를 사용하여 데이터를 보내는(Write) 함수
2. HAL_I2C_MasterTxCpltCallback()
   : I2C 인터럽트를 사용하여 데이터를 보내고 다 보내면 인터럽트에 의해 호출되는 함수
3. HAL_I2C_Master_Receive_IT()
   : I2C 인터럽트를 사용하여 데이터를 받는(Receive) 함수
4. HAL_I2C_MasterRxCpltCallback()
   : I2C 인터럽트를 사용하여 정해진 개수의 데이터를 다 받으면 인터럽트에 의해 호출되는 함수

위의 함수들은 stm32f4xx_hal_i2c.c 파일에 정의되어 있습니다. 
HAL_I2C_MasterTxCpltCallback(), HAL_I2C_MasterRxCpltCallback() 과 같은 콜백함수는 __weak 키워드를 없애고
main.c 파일에 복사해서 내부 내용을 바꿔서 쓰면 인터럽트가 걸릴때 마다 콜벡함수를 호출하게 됩니다.

이 파일의 위치는 다음과 같습니다.



친구 돌잔치를 가봐야 해서 main.c 에서 EEPROM 읽고 쓰는 부분을 그림으로 올려 놓겠습니다.







[16 Byte Write 오실로 스코프 파형]





[Word Address Write 오실로 스코프 파형]





[16 Byte Read 오실로 스코프 파형]



소스 파일 첨부합니다.

I2C_test (2).zip


'STM32F4' 카테고리의 다른 글

[STM32F4xx] Nucleo 보드 테스트 #8(SDIO CLK 설정:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #7 (u-SD - SDIO-4Bit :KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #5(I2C 1/2 :KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #4(UART2 Interrupt:KEIL)  (0) 2016.12.01
[STM32F4xx] Nucleo 보드 테스트 #3 (Cube 사용법&Timer3 Interrupt:KEIL)  (0) 2016.12.01

+ Recent posts

티스토리툴바