添加味道，上午对STM32F042做了比较简单的介绍，现在我们来让nucleo32跑起来！
    为了省时，我使用了CubeMx作为架构生成平台：
STEP 1：
        打开CubeMx软件，并且选择Board Selector，Verdor选择默认，Type of board 选择Nucleo32，Mcu Series选择STM32F0，然后确定完成
芯片，板型号选择步骤。


STEP 2：
进行引脚，外设配置，在这里，芯片默认会使用内部RC8M作为系统时钟，哥不喜欢，哥喜欢快，所以点击Clock Configuration：显示时钟配置界面，
然后选用HSI RC 48Mhz作为系统时钟，详细配置如图所示：

然后，我们继续进行芯片外设引脚配置，第一，使用uart2（nuceleo32 F042使用usart2连接stlink 的vcp）所以我们不需要另外的转串口工具。
配置如图所示：

我们采用异步串口，所以选用Asynchronous，这里我们还没有完毕，我们还需要配置uart的参数，我们采用115200,8-n-1配置
1、点击configuration：
2、双击connectivity中的USART2
3、Baud Rate选项输入115200
4、Word Length 选择8bit，其他保持默认
5、点击Apply，OK
6、此时我们已经完成了串口的发送，接收功能配置


接下来，我们配置LED，板载LED连接PB3
所以我直接配置PB3为output，其实我们可以看出，芯片默认已经有串口的引脚配置了，我们只需要使能Usart2即可，如果没有
我们也可以设置PA2为USART2_TX，PA15为USART2_RX
配置好后，如下图所示

SETP 3：
这样，板子硬件我们已经配置好了，接下来就是生成工程，点击toolbar上的齿轮符号（Generate source code based on user settings），
会弹出Project settings窗口，分别输入project name（项目名） project location（项目路径） IDE（项目工作平台），
然后切换到Code Generator界面并且按照如下如所示设置即可：

最后我们按确定，open project，项目环境就建立好了

STEP 4：
编辑User Code：
编辑LED的翻转函数

1. #define LED_PORT            GPIOB
   
2. #define LED_PIN             GPIO_PIN_3
   
3. #define LED_GREEN_TOGGLE    HAL_GPIO_TogglePin(LED_PORT,LED_PIN)

复制代码

编辑main函数：

1. /* USER CODE BEGIN WHILE */
   
2.   while (1)
   
3.   {
   
4.     uint32_t wSysClock;
   
5.     /* USER CODE END WHILE */
   
6. 
   
7.     /* USER CODE BEGIN 3 */
   
8.     wSysClock = HAL_RCC_GetSysClockFreq();
   
9.     printf("System Clock is :%ld\r\n",wSysClock);
   
10.     HAL_UART_Transmit(&huart2,"my name is inc\r\n",sizeof("my name is inc\r\n"),1000);
    
11.     LED_GREEN_TOGGLE;
    
12.     HAL_Delay(1000);
    
13.   }
    
14.   /* USER CODE END 3 */

复制代码

因为我们在main中使用了printf，所以我们需要重定向printf函数：
我们打开usart.c
在user code区域中添加一下代码：

1. #pragma import(__use_no_semihosting)            
   
2.             
   
3. struct __FILE
   
4. {
   
5.         int handle;
   
6.         /* Whatever you require here. If the only file you are using is */
   
7.         /* standard output using printf() for debugging, no file handling */
   
8.         /* is required. */
   
9. };
   
10. /* FILE is typedef’ d in stdio.h. */
    
11. FILE __stdout;      
    
12. 
    
13. void _sys_exit(int x)
    
14. {
    
15.         x = x;
    
16. }
    
17. 
    
18. int fputc(int ch, FILE *f)
    
19. {      
    
20.         while((USART2->ISR&0X40)==0);  
    
21.         USART2->TDR = (uint8_t) ch;      
    
22.         return ch;
    
23. }

复制代码

最后我们编译工程，并且下载，对于软件生成的工程，默认是没有设置stlink下载后的工作的，所以我们可以点击option，debug，stlink，setting，flash download，然后勾选reset and run，最后确定返回。
最后一步，下载工程。
一下是运行现象：




相关推荐
STM32单片机官方开发工具一览
STM32评估开发板列表
ARM Cortex-M内核STM32 单片机产品全览
STM32微控制器参考设计

不错，跟着楼主学习。

楼主玩过HAL库下SPI驱动TF卡吗？

yklstudent-1794 发表于 2016-3-10 12:56
楼主玩过HAL库下SPI驱动TF卡吗？

有空我再写个帖子吧，SPI通了，其他其实没有任何难度的，你可以看我下一个帖子，就关于SPI设置的

楼主有没有 STM32F042 ，串口2 的demo，固件不要用CubMX的（非常繁复）。我对照调通的串口1，修改，但是串口2就是不能通信。
[cod，]void RCC_Configuration(void)
{   
        /* Enable SYSCFG clock */
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); //EXTI 等时钟
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA |RCC_AHBPeriph_GPIOB |RCC_AHBPeriph_GPIOF, ENABLE);
        //允许串口1/2的时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);        
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);               
      
}[/code]

1. void Usart_Config(UI32 usart1_baud, UI32 usart2_baud)
   
2. {
   
3.         GPIO_InitTypeDef    GPIO_InitStructure;
   
4.         USART_InitTypeDef   USART_InitStructure;
   
5.         
   
6.     //USART1     
   
7.          GPIO_PinAFConfig(GPIOA, GPIO_PinSource9,GPIO_AF_1);
   
8.         GPIO_PinAFConfig(GPIOA, GPIO_PinSource10 ,GPIO_AF_1);
   
9.            
   
10.         // Configure USART1_Tx
    
11.         GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_9  ;
    
12.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
13.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
14.         GPIO_InitStructure.GPIO_OType=GPIO_OType_PP;
    
15.         GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;        
    
16.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
17.         
    
18.         // Configure USART1_Rx
    
19.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 ;
    
20.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
21.         GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;
    
22.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
23.         
    
24.         USART_DeInit(USART1);
    
25.    
    
26.         //初始化第一个串口
    
27.         USART_InitStructure.USART_BaudRate = usart1_baud;
    
28.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
29.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
30.         USART_InitStructure.USART_Parity = USART_Parity_No;
    
31.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
32.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
33.         USART_Init(USART1, &USART_InitStructure);
    
34. 
    
35.         USART_Cmd(USART1, ENABLE);
    
36.     USART_ClearFlag(USART1, USART_FLAG_TC);
    
37. 
    
38.     //USART2   
    
39.          GPIO_PinAFConfig(GPIOA, GPIO_PinSource2,GPIO_AF_1);
    
40.         GPIO_PinAFConfig(GPIOA, GPIO_PinSource3 ,GPIO_AF_1);
    
41.            
    
42.         // Configure USART2_Tx
    
43.         GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_2  ;
    
44.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
45.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
46.         GPIO_InitStructure.GPIO_OType=GPIO_OType_PP;
    
47.         GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;        
    
48.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
49.         
    
50.         // Configure USART2_Rx
    
51.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;
    
52.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
53.         GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;
    
54.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
55.         
    
56.         USART_DeInit(USART3);
    
57.    
    
58.         //初始化第二个串口
    
59.         USART_InitStructure.USART_BaudRate = usart2_baud;
    
60.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
61.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
62.         USART_InitStructure.USART_Parity = USART_Parity_No;
    
63.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
64.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
65.         USART_Init(USART1, &USART_InitStructure);
    
66. 
    
67. //        USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    
68. 
    
69.         USART_Cmd(USART2, ENABLE);
    
70.     USART_ClearFlag(USART2, USART_FLAG_TC);
    
71. }

复制代码

代码如上，很怀疑串口二有什么特殊，关于042的资料和很少！！
望回复！！多谢

小温点秋香 发表于 2017-4-13 11:57
楼主有没有 STM32F042 ，串口2 的demo，固件不要用CubMX的（非常繁复）。我对照调通的串口1，修改，但是串 ...

1. /**
   
2.   ******************************************************************************
   
3.   * @file    printf.c
   
4.   * @author  Inc Li
   
5.   * @version V0.0.1
   
6.   * @date    5-April-2017
   
7.   * @brief   Driver of GPIO
   
8.   * @modify
   
9.   ******************************************************************************
   
10.   */
    
11. 
    
12. /* Includes ------------------------------------------------------------------*/
    
13. #include <stdio.h>
    
14. #include "../devices.h"
    
15. #include "stm32f0xx.h"
    
16. 
    
17. /* Private typedef -----------------------------------------------------------*/
    
18. /* Private define ------------------------------------------------------------*/
    
19. #ifndef NULL
    
20.     #define NULL 0
    
21. #endif
    
22. /* Private macro -------------------------------------------------------------*/
    
23. #ifdef __GNUC__
    
24.   /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
    
25.      set to 'Yes') calls __io_putchar() */
    
26.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    
27.   #define GETCHAR_PROTOTYPE int __io_getchar(void)
    
28. #else
    
29.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    
30.   #define GETCHAR_PROTOTYPE int fgetc(FILE *f)
    
31. #endif /* __GNUC__ */
    
32. /* Private variables ---------------------------------------------------------*/
    
33. static usart_dev print;
    
34. /* Private function prototypes -----------------------------------------------*/
    
35. static int usart2_open(usart_param *property);
    
36. static int usart2_close(usart_param *property);
    
37. static int usart2_send_char(char dat);
    
38. static char usart2_get_char(void);
    
39. 
    
40. /* Private functions ---------------------------------------------------------*/
    
41. int printf_dev_open(usart_param *property)
    
42. {
    
43.     return usart_open(&print, property);
    
44. }
    
45. 
    
46. char printf_dev_get(void)
    
47. {
    
48.     return usart_get(&print);
    
49. }
    
50. 
    
51. static int usart2_open(usart_param *property)
    
52. {
    
53.     USART_InitTypeDef uart;
    
54.     GPIO_InitTypeDef gpio;
    
55. 
    
56.     /* Enable GPIO Clock */
    
57.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
    
58. 
    
59.     /* Enable USART Clock */
    
60.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    
61. 
    
62.     /* Connect PXx to USARTx_Tx */
    
63.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_1);
    
64. 
    
65.     /* Connext PXx to USARTx_Rx */
    
66.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource15, GPIO_AF_1);
    
67. 
    
68.     /* Configure USART Tx as alternate function push-pull */
    
69.     gpio.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_15;
    
70.     gpio.GPIO_Mode = GPIO_Mode_AF;
    
71.     gpio.GPIO_Speed = GPIO_Speed_10MHz;
    
72.     gpio.GPIO_OType = GPIO_OType_PP;
    
73.     gpio.GPIO_PuPd = GPIO_PuPd_UP;
    
74.     GPIO_Init(GPIOA, &gpio);
    
75. 
    
76.     uart.USART_BaudRate = property->baudrate;
    
77.     switch (property->word_lenth) {
    
78.         case USART_WORD_LENTH_7BIT:
    
79.             uart.USART_WordLength = USART_WordLength_7b;
    
80.             break;
    
81.         case USART_WORD_LENTH_8BIT:
    
82.             uart.USART_WordLength = USART_WordLength_8b;
    
83.             break;
    
84.         case USART_WORD_LENTH_9BIT:
    
85.             uart.USART_WordLength = USART_WordLength_9b;
    
86.             break;
    
87.         default:
    
88.             goto err;
    
89.     }
    
90. 
    
91.     switch (property->stopbit) {
    
92.         case USART_STOP_BIT_1:
    
93.             uart.USART_StopBits = USART_StopBits_1;
    
94.             break;
    
95.         case USART_STOP_BIT_1_5:
    
96.             uart.USART_StopBits = USART_StopBits_1_5;
    
97.             break;
    
98.         case USART_STOP_BIT_2:
    
99.             uart.USART_StopBits = USART_StopBits_2;
    
100.             break;
     
101.         default:
     
102.             goto err;
     
103.     }
     
104. 
     
105.     switch (property->parity) {
     
106.         case USART_PARITY_NONE:
     
107.             uart.USART_Parity = USART_Parity_No;
     
108.             break;
     
109.         case USART_PARITY_EVEN:
     
110.             uart.USART_Parity = USART_Parity_Even;
     
111.             break;
     
112.         case USART_PARITY_ODD:
     
113.             uart.USART_Parity = USART_Parity_Odd;
     
114.             break;
     
115.         default:
     
116.             goto err;
     
117.     }
     
118. 
     
119.     switch (property->usart_mode) {
     
120.         case USART_MODE_RX:
     
121.             uart.USART_Mode = USART_Mode_Rx;
     
122.             break;
     
123.         case USART_MODE_TX:
     
124.             uart.USART_Mode = USART_Mode_Tx;
     
125.             break;
     
126.         case USART_MODE_RX_TX:
     
127.             uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
     
128.             break;
     
129.         default:
     
130.             goto err;
     
131.     }
     
132. 
     
133.     switch (property->hardware_flow_control) {
     
134.         case USART_HARDWARE_CONTROL_NONE:
     
135.             uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
     
136.             break;
     
137.         case USART_HARDWARE_CONTROL_RTS:
     
138.             uart.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS;
     
139.             break;
     
140.         case USART_HARDWARE_CONTROL_CTS:
     
141.             uart.USART_HardwareFlowControl = USART_HardwareFlowControl_CTS;
     
142.             break;
     
143.         case USART_HARDWARE_CONTROL_RTS_CTS:
     
144.             uart.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS_CTS;
     
145.             break;
     
146.         default:
     
147.             goto err;
     
148.     }
     
149. 
     
150.     USART_DeInit(USART2);
     
151.     USART_Cmd(USART2, DISABLE);
     
152.     USART_Init(USART2, &uart);
     
153.     USART_Cmd(USART2, ENABLE);
     
154.     USART_ClearFlag(USART2, USART_FLAG_TC);
     
155.     return 0;
     
156. err:
     
157.     return 1;
     
158. }
     
159. 
     
160. int printf_dev_send(char *str)
     
161. {
     
162.     while (*str != 0) {
     
163.         print.send_char(*str++);
     
164.     }
     
165.     return 0;
     
166. }
     
167. 
     
168. static int usart2_close(usart_param *property)
     
169. {
     
170.     return 0;
     
171. }
     
172. 
     
173. static int usart2_send_char(char dat)
     
174. {
     
175.     USART_SendData(USART2, (uint8_t)dat);
     
176.     while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET) {
     
177.     }
     
178.     return 0;
     
179. }
     
180. 
     
181. static char usart2_get_char(void)
     
182. {
     
183.     while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET);
     
184. 
     
185.     return (char)USART_ReceiveData(USART2);
     
186. }
     
187. 
     
188. /**
     
189.   * @brief  重定向c库函数printf到USART1
     
190.   * @param  
     
191.   * @retval
     
192.   */
     
193. PUTCHAR_PROTOTYPE
     
194. {
     
195.     //while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);               
     
196.     //USART_SendData(USART2, (uint8_t) ch);
     
197.     while((USART2->ISR & USART_FLAG_TXE) == 0);
     
198.     USART2->TDR = ch;
     
199.     return (ch);
     
200. }
     
201. 
     
202. 
     
203. /**
     
204.   * @brief  重定向c库函数scanf到USART1
     
205.   * @param  
     
206.   * @retval
     
207.   */
     
208. GETCHAR_PROTOTYPE
     
209. {
     
210.     while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET);
     
211. 
     
212.     return (int)USART_ReceiveData(USART2);
     
213. }
     
214. 
     
215. static usart_dev print = {
     
216.     .open = usart2_open,
     
217.     .close = usart2_close,
     
218.     .send_char = usart2_send_char,
     
219.     .get_char = usart2_get_char,
     
220. };
     
221. /******************* (C) COPYRIGHT 2016 Inc *****END OF FILE*******************/
     
222. 
     

复制代码

小温点秋香 发表于 2017-4-13 11:57
楼主有没有 STM32F042 ，串口2 的demo，固件不要用CubMX的（非常繁复）。我对照调通的串口1，修改，但是串 ...

我也遇到了同样的问题，你找到原因了吗？

Inc_brza 发表于 2017-4-13 16:46

这个我试了一下，用不了