[12] STM32F4 - CubeMx - USB podłączenie pendriva

Ten post dotyczy obsługi pendriva za pomocą mikrokontrolera STM32F4 zamontowanego na płytce Discovery. Przygotowany program będzie tworzył na pendrivie plik tekstowy, do którego wprowadzone zostaną dane.

Aby tego dokonać należy jeszcze zakupić kabel USB OTG, który z jednej strony ma złącze microUSB, które można podłączyć do płytki Discovery, z drugiej natomiast jest wyposażone w złącze USB żeńskie do którego zostaje podłączony pendrive.

Poniżej przykładowy link do sklepu z takim kablem. Jest on w każdym sklepie z takimi akcesoriami w różnych wariantach cenowych, jakościowych jak i o różnym wyglądzie (w postaci kabla, bądź jednolitej wtyczki).

Zdjęcie pobrane ze strony: www.euro.com.pl

Cube Mx:

Przygotowanie projektu poprzez program CubeMx jest mało skomplikowane. Składa się ono tylko z kilku mało skomplikowanych kroków.

Na samym początku należy włączyć w klasie USB_OTG_FS jako Host Only. Następnie w zakładce USB_HOST, Class for FS IP należy włączyć Mass Storage Host Class.

Następnym krokiem, związanym z potrzebą operacji na plikach, jest włączenie biblioteki FATFS z zaznaczoną opcją USB-Disk.

Dalej to już standardowa konfiguracja zegara:

Dalej w konfiguracji zwiększony zostaje bufor danych w układzie:

Po tej konfiguracji można przejść do wygenerowania projektu.

Program:

Wygenerowany kod wprowadziłem do programu Keil, ponieważ w Eclipsie miałem problem z działaniem aplikacji, takie problemy w keilu sie nie pojawiły w związku z tym przeniosłem program do innego środowiska.

Na samym początku należy dodać bibliotekę ff_gen_drv.h. do pliku usb_host.c

1. /* Includes ------------------------------------------------------------------*/
3. #include "usb_host.h"
4. #include "usbh_core.h"
5. #include "usbh_msc.h"
7. /* USB Host Core handle declaration */
8. USBH_HandleTypeDef hUsbHostFS;
9. ApplicationTypeDef Appli_state = APPLICATION_IDLE;
11. /**
12. * -- Insert your variables declaration here --
13. */
14. /* USER CODE BEGIN 0 */
15. #include "ff_gen_drv.h"
16. /* USER CODE END 0 */

Kolejnym etapem jest modyfikacja funkcji USBH_UserProcess. W niej zdefiniowane są odpowiednie działania dla różnych stanów działania aplikacji odpowiadającej za USB.

1. /*
2.  * user callbak definition
3. */
4. static void USBH_UserProcess  (USBH_HandleTypeDef *phost, uint8_t id)
5. {
7.   /* USER CODE BEGIN 2 */
8.   switch(id)
9.   {
10.   case HOST_USER_SELECT_CONFIGURATION:
11.   break;
12.    
13.   case HOST_USER_DISCONNECTION:
14.   //Appli_state = APPLICATION_DISCONNECT;
15.   Appli_state = APPLICATION_IDLE;
16.     f_mount(NULL,(TCHAR const*)"",0);
17.   break;
18.    
19.   case HOST_USER_CLASS_ACTIVE:
20.   Appli_state = APPLICATION_START;
21.   break;
23.   case HOST_USER_CONNECTION:
24.   //Appli_state = APPLICATION_START;
25.   break;
27.   default:
28.   break;
29.   }
30.   /* USER CODE END 2 */
31. }

Nasza aplikacja właściwe działanie otrzyma dla dwóch stanów. Opcja Disconnect powoduje zmienienie stanu działania aplikacji oraz HOST_USER_CLASS_ACTIVE, gdzie stan pracy aplikacji zostanie włączony jako Start. Dzięki temu zostanie włączona biblioteka i zamontowany dysk zewnętrzny.

Teraz właściwie można przejść do głównego elementu programu czyli pliku main.c gdzie zdefiniuje funkcje tworzącą plik wraz z wpisaniem tekstu oraz taką która pozwoli na otwarcie danych z pliku.

1. void WriteData(void)
2. {
3.     FRESULT res;
4.     uint8_t write_buffer[]="Zapis do pliku stm32f4\n\r";
5.     char write_buffer2[]="Dalsza czesc zapisu danych do pliku\n\r";
6.    
7.     if(f_mount(&USBDISKFatFs,(TCHAR const*)USBH_Path,0) == FR_OK)
8.     {
9.          if(f_open(&MyFile, "testowy plik.txt" , FA_OPEN_ALWAYS | FA_WRITE | FA_READ) == FR_OK)
10.          {
11.               sprintf(write_buffer2, "ja %d wwwww %d muuuu\n\r", 11, 12);
13.               res = f_lseek(&MyFile, f_size(&MyFile));
15.               res = f_printf(&MyFile, write_buffer2, sizeof(write_buffer2)/sizeof(char));
16.               res = f_printf(&MyFile, (const TCHAR*)write_buffer, sizeof(write_buffer)/sizeof(uint8_t));
17.              
18.               HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12 | GPIO_PIN_13, GPIO_PIN_SET);
19.           }
20.           f_close(&MyFile);
21.            
22.           f_mount(NULL, "", 0);
23.     }
24.     else
25.     {
26.          HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
27.     }
28. }

W niej przygotowywane są bufory danych, i dane są wprowadzane do przygotowanego pliku. Operacji dokonuje się w taki sam sposób oraz w takim samym ciągu co w przypadku karty SD.

Teraz czas na odczytanie danych z pliku.

1. void ReadData(void)
2. {
3.     FRESULT res;
4.     uint32_t bytes_to_write, bytes_to_read;
5.     uint8_t read_buffer[100];
6.     uint8_t write_buffer[]="Zapis do pliku stm32f4\n\r";
7.     char write_buffer2[]="Dalsza czesc zapisu danych do pliku\n\r";
8.    
9.     if(f_mount(&USBDISKFatFs,(TCHAR const*)USBH_Path,0) == FR_OK)
10.     {
11.          if(f_open(&MyFile, "testzap.txt" , FA_READ) == FR_OK)
12.          {
13.                 res = f_read(&MyFile,read_buffer,sizeof(read_buffer),(void*)bytes_to_read);
14.                 if((bytes_to_read==0)||(res!=FR_OK))
15.                 {
16.                     HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_SET);
17.                 }
18.                 else
19.                 {
20.                     read_buffer[bytes_to_read]=0;
21.                     f_close(&MyFile);
22.                 }
23.               HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12 | GPIO_PIN_13, GPIO_PIN_SET);
24.           }
25.           f_close(&MyFile);
26.            
27.           f_mount(NULL, "", 0);
28.     }
29.     else
30.     {
31.          HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_SET);
32.     }
33. }

Główna część programu, bez funkcji przedstawionych powyżej.

1. /* Includes ------------------------------------------------------------------*/
2. #include "stm32f4xx_hal.h"
3. #include "fatfs.h"
4. #include "usb_host.h"
6. /* USER CODE BEGIN Includes */
7. #include "main.h"
8. //#include "lcd.h"
9. /* USER CODE END Includes */
11. /* Private variables ---------------------------------------------------------*/
12. I2C_HandleTypeDef hi2c1;
14. /* USER CODE BEGIN PV */
15. /* Private variables ---------------------------------------------------------*/
16. extern ApplicationTypeDef Appli_state;
17. FATFS USBDISKFatFs;
18. FIL MyFile;
19. extern USBH_HandleTypeDef hUsbHostFS;
20. /* USER CODE END PV */
22. /* Private function prototypes -----------------------------------------------*/
23. void SystemClock_Config(void);
24. void Error_Handler(void);
25. static void MX_GPIO_Init(void);
26. static void MX_I2C1_Init(void);
27. void MX_USB_HOST_Process(void);
29. /* USER CODE BEGIN PFP */
30. /* Private function prototypes -----------------------------------------------*/
32. /* USER CODE END PFP */
34. /* USER CODE BEGIN 0 */
35. void WriteData(void)
36. {
37.     //...
38.     //...
39.     //...
40. }
42. void ReadData(void)
43. {
44.     //...
45.     //...
46.     //...
47. }
48. /* USER CODE END 0 */
50. int main(void)
51. {
53.   /* USER CODE BEGIN 1 */
54.     char str[100];
55.   /* USER CODE END 1 */
57.   /* MCU Configuration----------------------------------------------------------*/
59.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
60.   HAL_Init();
62.   /* Configure the system clock */
63.   SystemClock_Config();
65.   /* Initialize all configured peripherals */
66.   MX_GPIO_Init();
67.   MX_I2C1_Init();
68.   MX_FATFS_Init();
69.   MX_USB_HOST_Init();
71.   /* USER CODE BEGIN 2 */
72.   /* USER CODE END 2 */
74.   /* Infinite loop */
75.   /* USER CODE BEGIN WHILE */
76.   while (1)
77.   {
78.   /* USER CODE END WHILE */
79.     MX_USB_HOST_Process();
81.   /* USER CODE BEGIN 3 */
82.         if(Appli_state==APPLICATION_START)
83.         {
84.             WriteData();
85.         }
86.         else if(Appli_state==APPLICATION_IDLE)
87.         {
88.         }
89.     }  
90.   /* USER CODE END 3 */
91. }

Program do postu można pobrać z dysku Google pod tym linkiem.