[11月DIY]打造最简STM32F0 USB开发板

cruelfox · 2015-11-23 16:44 上传

[11月DIY]打造最简STM32F0 USB开发板 [复制链接]

本帖最后由 cruelfox 于 2015-11-23 16:45 编辑

想学STM32，不知道从哪开始的有木有？想学ARM单片机，嫌买开发板、调试器费钱的有木有？买了STM32开发板没有资料不会玩，放在那里吃灰的有木有？买了开发板，照着例子跑通了几个程序，依然一头雾水的有木有？
我cruelfox是个非常抠门的人，搞DIY也省得很——一切从简。(太复杂了的搞不定，软件硬件都是如此) 所以正在玩的STM32也简化到底了，有兴趣的看看吧。

这是刚完成的STM32F072 USB开发板，使用48脚LQFP的STM32F072C8T6，也可以使用其它封装兼容的带USB型号，甚至是M3系的STM32F103C8T6这种。上半年从论坛买了块STM32F091 Nucleo, 但是不带USB，所以为了学习USB自己做一块咯。下面是电路图，除了一片1117 3.3V LDO，外围器件少到极致了吧，晶振不用的话是可以不装的。板子可以直接通过 USB mini口供电。外围引出的插针有一路 SPI, 一路 I2S, 一路 UART, 一路 I2C, 一路 8-bit GPIO, 一路 UART/I2C共用，以及几个零星的GPIO。这些已方便开发简单的USB设备了。

PCB layout 示意图

好，STM32F072 10块钱以内就可以搞定，整个开发板成本很低了吧。如果你有ST-Link, 或者是带有ST-Link的STM32 Discovery/Nucleo开发板，用SWD调试线连上就可以下载程序了。如果没有ST-Link, 还可以从串口下载程序，只需要把BOOT0跳线接上即可，因为STM32内带了Bootloader. 如果连串口线都没有？呵呵，要是像F072这样带USB的，还可以从USB直接下载，别的硬件也省了，怎么样，够简吧？

OK，来写第一个测试程序：定时控制LED闪烁。

#include "stm32f0xx.h"
int main(void)
{
RCC->AHBENR |= RCC_AHBENR_GPIOAEN; // enable GPIO port A & B clock
GPIOA->MODER = GPIO_MODER_MODER8_0; // PA8 as general output (LED)
RCC->APB1ENR |= RCC_APB1ENR_TIM6EN; // enable basic timer 6
TIM6->PSC = 9999; // prescaler
TIM6->ARR = 399; // auto reload value
TIM6->CR1 = TIM_CR1_URS|TIM_CR1_CEN; // start counter
while(1)
{
static char a=0;
if(TIM6->SR & TIM_SR_UIF) // check if overflow
{
TIM6->SR &= ~TIM_SR_UIF; // clear flag
if(a==0)
{
GPIOA->BSRR = (1<<8);
a=1;
}
else
{
GPIOA->BRR = (1<<8);
a=0;
}
}
}
}

复制代码

上面这个程序所做的事情，先是初始化GPIO, 设置PA8为输出口(板子上连了一个LED)，然后是设置定时器Timer 6, 这是一个自动重装的计数器，我把它调到0.5秒中溢出一次。在下面的循环里面，就是检测溢出标志，然后切换LED的亮和灭状态。学过C语言的，都应该看得懂；至于RCC, GPIOA, TIM6 这几个结构指针的定义，都在#include的头文件里面，这是和硬件相关的，具体请查阅"RM0091 STM32F0x1/STM32F0x2/STM32F0x8 Reference Manual"编程手册。

如何编译上面这个 C 程序，且听下回分解。这里暂且假定编译成功了，得到一个 HEX 文件，也就是要烧写的二进制代码。
如果你是使用KEIL, IAR等集成开发环境，那么用自带的烧写工具就可以进行写入了。如果是像我cruelfox这样追求精简，仅使用GCC命令行工具的，就需要再找下载程序用的软件了。

如果是使用ST-Link，可以使用ST自己的STVP (Visual Programmer)，这个东东在ST网站上可以下载到，不过是包含在九十兆左右的一个大包"ST Toolset"里面。(下载URL http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1533/PF210568 )这个软件的界面是这个样子的：

主菜单上面 Erase, Program, Verify, Read 功能很明了了，File-->Open可以加载HEX文件。第一次运行STVP的时候，要选择ST-LINK调试器，和 SWD接口。

如果没有ST-Link, 使用串口下载的话，需要"Flash Loader Demostrator"软件，这个也可以从ST网站直接下载(URL http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/demo_and_example/stsw-mcu005.zip)。下载前要把BOOT0跳线接上，使STM32进入Bootloader模式，USART1连接到PC的串口（我用的是FT232RL USB转串口），把MCU加电。运行软件，界面是这样的：

选择串口，然后点"Next"，如果成功连上了，则界面变成下面这样

点"Next"继续

这时已显示出识别出的STM32型号，点"Next"到下一步进行具体的操作。

OK, 下载HEX，擦除，上载(读Flash内容) 功能都一看就明白了吧。

第三种下载方式，从USB，需要ST的"DFUSe Demo"软件，也是从ST网站下载的(URL http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/demo_and_example/stsw-stm32080.zip)。也需要把BOOT0跳线接上，还必须连接USB口，然后PC提示找到了新硬件。安装好驱动以后，再启动软件，界面如下：

不过现在不能把HEX文件直接写入，而需要先生成dfu文件，使用一起安装得到的"DFU File Manager"程序，从HEX生成dfu.

至于 VID, PID 我还是保留和原来的一致，不然得重新安装驱动（为什么要使用DFU文件我还没理解清楚）。得到dfu文件就可以用上面的软件烧写了。

怎么样，我cruelfox的开发板够精简吧？二楼帖子会我会跟贴讲解怎么编译程序，上面的程序是怎么被STM32运行的。
六楼帖子里面，我分享我的第一个USB工程，mass storage 虚拟存储盘.

cruelfox · 2015-11-21 16:10 上传

本帖最后由 cruelfox 于 2015-11-21 16:18 编辑

STM32F0xx 系列是ARM Cortex-M0架构，地址空间32位，也就是4G Bytes的访问范围。数据和代码使用同一编址，下图是地址空间的布局：

实际上单片机用到的资源很少，地址空间大部分都没有内容。我使用的STM32F072C8T6带有64kB的Flash ROM, 16kB的SRAM，起始分别是 0x08000000 和 0x20000000. (由于有硬件映射功能，在0x00000000也就是最低地址，还可以访问ROM或者RAM的内容). 单片机片上外设的寄存器，则分布在更高的地址空间。读写这些寄存器，在CPU看来和读写内存(RAM)操作是一样的。

所以，C语言访问设备寄存器，和访问内存中的一个变量一样。只要知道寄存器的地址，通过一个指针访问就可以实现读写。上一贴子我的程序中引用了 RCC, GPIOA, TIM6 这三个(结构)指针，它们的值(也就是地址)以及类型(代表访问的内容)定义在 stm32f0xx.h 这个头文件中。因为设备寄存器太多了哇，如果每一个都定义一个指针就太烦琐了，所以把按功能划分定义成组，每组用一个C语言的结构类型表示，写起来也更清晰。而寄存器里面的位描述也可以定义成一些宏，在读程序的时候就知道是什么意思了。如果有兴趣，可以把 stm32f0xx.h 文件和STM32F0的手册对照着阅读。

好，假设已经熟悉寄存器操作了，知道怎么配置寄存器实现想要的功能，那么就可以写C程序让STM32工作了。现在需要一个工具来将C程序翻译成机器代码——编译器，或者是叫做工具链(Tool chain)。Keil MDK-ARM 或者 IAR-EWARM 开发环境都带有各自的编译器，不过我更偏向于用开源的GCC-ARM. 在launchpad.net上可以下载到编译好的arm-gcc工具链zip包，将它解压缩，加到PATH里面就可以直接用了，很方便(很精简吧)。

OK，现在来编译上面那个mini.c文件，命令行：
arm-none-eabi-gcc -c -Os -mcpu=cortex-m0 -mthumb mini.c
gcc的参数 -c 是表示仅编译，-Os 是优化代码大小，-mcpu=cortex-m0 -mthumb 是指定指令集的，因为ARM有不同的版本。对了，include的头文件还没弄到呢。要编译通过需要把 stm32f0xx.h 这个文件找来。我的建议是下载ST提供的 "STM32F0x2 USB FS Device Library" 程序库(URL http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/firmware/stsw-stm32092.zip)，把里面需要的头文件等等扒出来。在 stm32f0xx.h 中还包含了另外几个头文件，一并弄出来放到工程目录下。

如果编译成功，将得到 mini.o 目标文件。可以用 arm-none-eabi-objdump -S mini.o 反汇编看看翻译成什么代码了。

E:\arm\test072\mini>arm-none-eabi-objdump -S mini.o
mini.o: file format elf32-littlearm
Disassembly of section .text.startup:
00000000 <main>:
0: 4b16 ldr r3, [pc, #88] ; (5c <main+0x5c>)
2: 2280 movs r2, #128 ; 0x80
4: 6959 ldr r1, [r3, #20]
6: 0292 lsls r2, r2, #10
8: 430a orrs r2, r1
a: b510 push {r4, lr}
c: 2180 movs r1, #128 ; 0x80
e: 615a str r2, [r3, #20]
10: 2290 movs r2, #144 ; 0x90
12: 0249 lsls r1, r1, #9
14: 05d2 lsls r2, r2, #23
16: 6011 str r1, [r2, #0]
18: 69da ldr r2, [r3, #28]
1a: 2110 movs r1, #16
1c: 430a orrs r2, r1
1e: 61da str r2, [r3, #28]
20: 4b0f ldr r3, [pc, #60] ; (60 <main+0x60>)
22: 4a10 ldr r2, [pc, #64] ; (64 <main+0x64>)
24: 851a strh r2, [r3, #40] ; 0x28
26: 2290 movs r2, #144 ; 0x90
28: 32ff adds r2, #255 ; 0xff
2a: 62da str r2, [r3, #44] ; 0x2c
2c: 2205 movs r2, #5
2e: 801a strh r2, [r3, #0]
30: 4a0d ldr r2, [pc, #52] ; (68 <main+0x68>)
32: 7812 ldrb r2, [r2, #0]
34: 8a1c ldrh r4, [r3, #16]
36: 2101 movs r1, #1
38: 4809 ldr r0, [pc, #36] ; (60 <main+0x60>)
3a: 420c tst r4, r1
3c: d0fa beq.n 34 <main+0x34>
3e: 8a04 ldrh r4, [r0, #16]
40: 438c bics r4, r1
42: 8204 strh r4, [r0, #16]
44: 2090 movs r0, #144 ; 0x90
46: 2480 movs r4, #128 ; 0x80
48: 05c0 lsls r0, r0, #23
4a: 408c lsls r4, r1
4c: 2a00 cmp r2, #0
4e: d102 bne.n 56 <main+0x56>
50: 6184 str r4, [r0, #24]
52: 1c0a adds r2, r1, #0
54: e7ee b.n 34 <main+0x34>
56: 8504 strh r4, [r0, #40] ; 0x28
58: 2200 movs r2, #0
5a: e7eb b.n 34 <main+0x34>
5c: 40021000 .word 0x40021000
60: 40001000 .word 0x40001000
64: 0000270f .word 0x0000270f
68: 00000000 .word 0x00000000

复制代码

如上，其实里面就一个main函数。但是 main 的入口地址还没有确定，而且它还使用了一个static型的内存变量，地址也还没有确定。可以用 arm-none-eabi-nm mini.o 来查看模块里面的全局符号表:

E:\arm\test072\mini>arm-none-eabi-nm mini.o
00000000 b a.4686
00000000 T main

复制代码

那么，怎么让程序放到ROM中合适的地址，并运行呢？如果熟悉C语言编程就知道还有一步——链接，才能确定符号的地址。但是，到目前为止我们还没有告诉GCC地址的布局，也就是RAM从哪里开始，代码放在哪里。因为ARM的器件很多，这并不是统一的，所以需要提供一些信息给链接程序。具体地，需要一个Linker Script, 可以从软件包中找到 STM32F072C8_FLASH.ld (或者用近似的来修改得到)

/*
*****************************************************************************
** File : stm32_flash.ld
*****************************************************************************
*/
/* Entry Point */
ENTRY(Reset_Handler)
/* Highest address of the user mode stack */
_estack = 0x20003FFF; /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200; /* required amount of heap */
_Min_Stack_Size = 0x400; /* required amount of stack */
/* Specify the memory areas */
MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 64K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 16K
}
/* Define output sections */
SECTIONS
{
/* The startup code goes first into FLASH */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} >FLASH
/* The program code and other data goes into FLASH */
.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)
KEEP (*(.init))
KEEP (*(.fini))
. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */
} >FLASH
/* Constant data goes into FLASH */
.rodata :
{
. = ALIGN(4);
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
. = ALIGN(4);
} >FLASH
.ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
.ARM : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} >FLASH
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
} >FLASH
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
} >FLASH
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
} >FLASH
/* used by the startup to initialize data */
_sidata = LOADADDR(.data);
/* Initialized data sections goes into RAM, load LMA copy after code */
.data :
{
. = ALIGN(4);
_sdata = .; /* create a global symbol at data start */
*(.data) /* .data sections */
*(.data*) /* .data* sections */
. = ALIGN(4);
_edata = .; /* define a global symbol at data end */
} >RAM AT> FLASH
/* Uninitialized data section */
. = ALIGN(4);
.bss :
{
/* This is used by the startup in order to initialize the .bss secion */
_sbss = .; /* define a global symbol at bss start */
__bss_start__ = _sbss;
*(.bss)
*(.bss*)
*(COMMON)
. = ALIGN(4);
_ebss = .; /* define a global symbol at bss end */
__bss_end__ = _ebss;
} >RAM
/* User_heap_stack section, used to check that there is enough RAM left */
._user_heap_stack :
{
. = ALIGN(4);
PROVIDE ( end = . );
PROVIDE ( _end = . );
. = . + _Min_Heap_Size;
. = . + _Min_Stack_Size;
. = ALIGN(4);
} >RAM
/* Remove information from the standard libraries */
/DISCARD/ :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
}
.ARM.attributes 0 : { *(.ARM.attributes) }
}

复制代码

OK，下面就是链接了，使用命令 arm-none-eabi-ld mini.o -Le:\arm-2014q3\arm-none-eabi\lib\armv6-m -Le:\arm-2014q3\lib\gcc\arm-none-eabi\4.8.4\armv6-m -T STM32F072C8_FLASH.ld -o mini.elf
这里面 -L 参数是添加标准库文件的搜索路径，虽然暂时并没有用到C标准库里面的东西，但是Linker Script里面引用了标准库文件。-o 指定输出的目标文件。这么就快要得到最终的机器码了，不过好象还缺少了什么……
arm-none-eabi-ld: warning: cannot find entry symbol Reset_Handler; defaulting to 08000000

linker给了一个警告：找不到入口地址 Reset_Handler 的值，设成了默认 0x08000000. 下面再用objdump -S反汇编看一下

E:\arm\test072\mini>arm-none-eabi-objdump -S mini.elf
mini.elf: file format elf32-littlearm
Disassembly of section .text:
08000000 <main>:
8000000: 4b16 ldr r3, [pc, #88] ; (800005c <main+0x5c>)
8000002: 2280 movs r2, #128 ; 0x80
8000004: 6959 ldr r1, [r3, #20]
8000006: 0292 lsls r2, r2, #10
8000008: 430a orrs r2, r1
800000a: b510 push {r4, lr}
800000c: 2180 movs r1, #128 ; 0x80
800000e: 615a str r2, [r3, #20]
8000010: 2290 movs r2, #144 ; 0x90
8000012: 0249 lsls r1, r1, #9
8000014: 05d2 lsls r2, r2, #23
8000016: 6011 str r1, [r2, #0]
8000018: 69da ldr r2, [r3, #28]
800001a: 2110 movs r1, #16
800001c: 430a orrs r2, r1
800001e: 61da str r2, [r3, #28]
8000020: 4b0f ldr r3, [pc, #60] ; (8000060 <main+0x60>)
8000022: 4a10 ldr r2, [pc, #64] ; (8000064 <main+0x64>)
8000024: 851a strh r2, [r3, #40] ; 0x28
8000026: 2290 movs r2, #144 ; 0x90
8000028: 32ff adds r2, #255 ; 0xff
800002a: 62da str r2, [r3, #44] ; 0x2c
800002c: 2205 movs r2, #5
800002e: 801a strh r2, [r3, #0]
8000030: 4a0d ldr r2, [pc, #52] ; (8000068 <main+0x68>)
8000032: 7812 ldrb r2, [r2, #0]
8000034: 8a1c ldrh r4, [r3, #16]
8000036: 2101 movs r1, #1
8000038: 4809 ldr r0, [pc, #36] ; (8000060 <main+0x60>)
800003a: 420c tst r4, r1
800003c: d0fa beq.n 8000034 <main+0x34>
800003e: 8a04 ldrh r4, [r0, #16]
8000040: 438c bics r4, r1
8000042: 8204 strh r4, [r0, #16]
8000044: 2090 movs r0, #144 ; 0x90
8000046: 2480 movs r4, #128 ; 0x80
8000048: 05c0 lsls r0, r0, #23
800004a: 408c lsls r4, r1
800004c: 2a00 cmp r2, #0
800004e: d102 bne.n 8000056 <main+0x56>
8000050: 6184 str r4, [r0, #24]
8000052: 1c0a adds r2, r1, #0
8000054: e7ee b.n 8000034 <main+0x34>
8000056: 8504 strh r4, [r0, #40] ; 0x28
8000058: 2200 movs r2, #0
800005a: e7eb b.n 8000034 <main+0x34>
800005c: 40021000 .word 0x40021000
8000060: 40001000 .word 0x40001000
8000064: 0000270f .word 0x0000270f
8000068: 20000000 .word 0x20000000

复制代码

现在 main() 被放到ROM最开始去了，这好象是对的？如果了解ARM Cortex-M0下就知道这样错了，因为最开始应该是中断向量表。我们还没有编写Linker Script中的 .isr_vectors 段的内容。而且，一上来初始化堆栈指针等工作都没有做就直接运行 main() 了也不合适吧？还缺少了初始化代码。

在软件包中搜刮一个 startup_stm32f072.s 汇编文件

/**
******************************************************************************
* @file startup_stm32f072.s
* @author MCD Application Team
******************************************************************************
*/
.syntax unified
.cpu cortex-m0
.fpu softvfp
.thumb
.global g_pfnVectors
.global Default_Handler
/* start address for the initialization values of the .data section.
defined in linker script */
.word _sidata
/* start address for the .data section. defined in linker script */
.word _sdata
/* end address for the .data section. defined in linker script */
.word _edata
/* start address for the .bss section. defined in linker script */
.word _sbss
/* end address for the .bss section. defined in linker script */
.word _ebss
.section .text.Reset_Handler
.weak Reset_Handler
.type Reset_Handler, %function
Reset_Handler:
ldr r0, =_estack
mov sp, r0 /* set stack pointer */
/*Check if boot space corresponds to test memory*/
LDR R0,=0x00000004
LDR R1, [R0]
LSRS R1, R1, #24
LDR R2,=0x1F
CMP R1, R2
BNE ApplicationStart
/*SYSCFG clock enable*/
LDR R0,=0x40021018
LDR R1,=0x00000001
STR R1, [R0]
/*Set CFGR1 register with flash memory remap at address 0*/
LDR R0,=0x40010000
LDR R1,=0x00000000
STR R1, [R0]
ApplicationStart:
/* Copy the data segment initializers from flash to SRAM */
movs r1, #0
b LoopCopyDataInit
CopyDataInit:
ldr r3, =_sidata
ldr r3, [r3, r1]
str r3, [r0, r1]
adds r1, r1, #4
LoopCopyDataInit:
ldr r0, =_sdata
ldr r3, =_edata
adds r2, r0, r1
cmp r2, r3
bcc CopyDataInit
ldr r2, =_sbss
b LoopFillZerobss
/* Zero fill the bss segment. */
FillZerobss:
movs r3, #0
str r3, [r2]
adds r2, r2, #4
LoopFillZerobss:
ldr r3, = _ebss
cmp r2, r3
bcc FillZerobss
/* Call the application's entry point.*/
bl main
LoopForever:
b LoopForever
.size Reset_Handler, .-Reset_Handler
/**
* @brief This is the code that gets called when the processor receives an
* unexpected interrupt. This simply enters an infinite loop, preserving
* the system state for examination by a debugger.
*
* @param None
* @retval : None
*/
.section .text.Default_Handler,"ax",%progbits
Default_Handler:
Infinite_Loop:
b Infinite_Loop
.size Default_Handler, .-Default_Handler
/******************************************************************************
*
* The minimal vector table for a Cortex M0. Note that the proper constructs
* must be placed on this to ensure that it ends up at physical address
* 0x0000.0000.
*
******************************************************************************/
.section .isr_vector,"a",%progbits
.type g_pfnVectors, %object
.size g_pfnVectors, .-g_pfnVectors
g_pfnVectors:
.word _estack
.word Reset_Handler
.word NMI_Handler
.word HardFault_Handler
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word SVC_Handler
.word 0
.word 0
.word PendSV_Handler
.word SysTick_Handler
.word WWDG_IRQHandler
.word PVD_VDDIO2_IRQHandler
.word RTC_IRQHandler
.word FLASH_IRQHandler
.word RCC_CRS_IRQHandler
.word EXTI0_1_IRQHandler
.word EXTI2_3_IRQHandler
.word EXTI4_15_IRQHandler
.word TSC_IRQHandler
.word DMA1_Channel1_IRQHandler
.word DMA1_Channel2_3_IRQHandler
.word DMA1_Channel4_5_6_7_IRQHandler
.word ADC1_COMP_IRQHandler
.word TIM1_BRK_UP_TRG_COM_IRQHandler
.word TIM1_CC_IRQHandler
.word TIM2_IRQHandler
.word TIM3_IRQHandler
.word TIM6_DAC_IRQHandler
.word TIM7_IRQHandler
.word TIM14_IRQHandler
.word TIM15_IRQHandler
.word TIM16_IRQHandler
.word TIM17_IRQHandler
.word I2C1_IRQHandler
.word I2C2_IRQHandler
.word SPI1_IRQHandler
.word SPI2_IRQHandler
.word USART1_IRQHandler
.word USART2_IRQHandler
.word USART3_4_IRQHandler
.word CEC_CAN_IRQHandler
.word USB_IRQHandler
/*******************************************************************************
*
* Provide weak aliases for each Exception handler to the Default_Handler.
* As they are weak aliases, any function with the same name will override
* this definition.
*
*******************************************************************************/
.weak NMI_Handler
.thumb_set NMI_Handler,Default_Handler
.weak HardFault_Handler
.thumb_set HardFault_Handler,Default_Handler
.weak SVC_Handler
.thumb_set SVC_Handler,Default_Handler
.weak PendSV_Handler
.thumb_set PendSV_Handler,Default_Handler
.weak SysTick_Handler
.thumb_set SysTick_Handler,Default_Handler
.weak WWDG_IRQHandler
.thumb_set WWDG_IRQHandler,Default_Handler
.weak PVD_VDDIO2_IRQHandler
.thumb_set PVD_VDDIO2_IRQHandler,Default_Handler
.weak RTC_IRQHandler
.thumb_set RTC_IRQHandler,Default_Handler
.weak FLASH_IRQHandler
.thumb_set FLASH_IRQHandler,Default_Handler
.weak RCC_CRS_IRQHandler
.thumb_set RCC_CRS_IRQHandler,Default_Handler
.weak EXTI0_1_IRQHandler
.thumb_set EXTI0_1_IRQHandler,Default_Handler
.weak EXTI2_3_IRQHandler
.thumb_set EXTI2_3_IRQHandler,Default_Handler
.weak EXTI4_15_IRQHandler
.thumb_set EXTI4_15_IRQHandler,Default_Handler
.weak TSC_IRQHandler
.thumb_set TSC_IRQHandler,Default_Handler
.weak DMA1_Channel1_IRQHandler
.thumb_set DMA1_Channel1_IRQHandler,Default_Handler
.weak DMA1_Channel2_3_IRQHandler
.thumb_set DMA1_Channel2_3_IRQHandler,Default_Handler
.weak DMA1_Channel4_5_6_7_IRQHandler
.thumb_set DMA1_Channel4_5_6_7_IRQHandler,Default_Handler
.weak ADC1_COMP_IRQHandler
.thumb_set ADC1_COMP_IRQHandler,Default_Handler
.weak TIM1_BRK_UP_TRG_COM_IRQHandler
.thumb_set TIM1_BRK_UP_TRG_COM_IRQHandler,Default_Handler
.weak TIM1_CC_IRQHandler
.thumb_set TIM1_CC_IRQHandler,Default_Handler
.weak TIM2_IRQHandler
.thumb_set TIM2_IRQHandler,Default_Handler
.weak TIM3_IRQHandler
.thumb_set TIM3_IRQHandler,Default_Handler
.weak TIM6_DAC_IRQHandler
.thumb_set TIM6_DAC_IRQHandler,Default_Handler
.weak TIM7_IRQHandler
.thumb_set TIM7_IRQHandler,Default_Handler
.weak TIM14_IRQHandler
.thumb_set TIM14_IRQHandler,Default_Handler
.weak TIM15_IRQHandler
.thumb_set TIM15_IRQHandler,Default_Handler
.weak TIM16_IRQHandler
.thumb_set TIM16_IRQHandler,Default_Handler
.weak TIM17_IRQHandler
.thumb_set TIM17_IRQHandler,Default_Handler
.weak I2C1_IRQHandler
.thumb_set I2C1_IRQHandler,Default_Handler
.weak I2C2_IRQHandler
.thumb_set I2C2_IRQHandler,Default_Handler
.weak SPI1_IRQHandler
.thumb_set SPI1_IRQHandler,Default_Handler
.weak SPI2_IRQHandler
.thumb_set SPI2_IRQHandler,Default_Handler
.weak USART1_IRQHandler
.thumb_set USART1_IRQHandler,Default_Handler
.weak USART2_IRQHandler
.thumb_set USART2_IRQHandler,Default_Handler
.weak USART3_4_IRQHandler
.thumb_set USART3_4_IRQHandler,Default_Handler
.weak CEC_CAN_IRQHandler
.thumb_set CEC_CAN_IRQHandler,Default_Handler
.weak USB_IRQHandler
.thumb_set USB_IRQHandler,Default_Handler
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

原来是这样，中断向量表在这里进行了描述，还有设置堆栈，初始化全局变量的代码，然后跳转到 main 执行。好了，这样就该差不多了。这个汇编程序是GNU AS的语法，可以用 arm-none-eabi-gcc 来直接汇编
arm-none-eabi-gcc -c startup_stm32f072.s
链接两个目标模块
arm-none-eabi-ld mini.o startup_stm32f072.o -Le:\arm-2014q3\arm-none-eabi\lib\armv6-m -Le:\arm-2014q3\lib\gcc\arm-none-eabi\4.8.4\armv6-m -T STM32F072C8_FLASH.ld -o mini.elf
最后转换出一个 HEX 文件
arm-none-eabi-objcopy -Oihex mini.elf mini.hex
可以进行烧写了。

我这个是最简化的例子，使用最简化的软件工具，不过已经包含了基本的C语言框架。后面随着我本人的学习，我会继续分享怎么开发一个简单的 USB 设备。

zca123 · 发表于2015-11-21 13:44

ljj3166 · 发表于2015-11-21 15:03

好详细啊，顶一个

dcexpert · 发表于2015-11-21 23:30

很不错。

cruelfox · 2015-11-23 17:24 上传

本帖最后由 cruelfox 于 2015-11-23 17:25 编辑

第一个USB工程例子：USB存储盘。因为手边没有SPI或I2C接口的Flash, 就权且用单片机的RAM虚拟一下吧。这个"U盘"容量标成160kB, 实际上有效的存储只有10kB，用一点扇区映射的技巧骗过操作系统，当然存放文件只能几kB了。

ST官方提供了一个 STM32F0 的USB固件库，(URL http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/firmware/stsw-stm32092.zip)，包括了硬件库、核心库和类库的C头文件和源文件。我cruelfox琢磨了一整天，还是没搞清楚怎么调用这些函数，只好照着个Example改吧。

于是就用MassStorage类的例子来下手了，这个目录里面的主文件 app.c 非常简单

/**
* @file app.c
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_msc_core.h"
#include "usbd_usr.h"
USB_CORE_HANDLE USB_Device_dev ;
int main(void)
{
USBD_Init(&USB_Device_dev,
&USR_desc,
&USBD_MSC_cb,
&USR_cb);
while (1)
{
}
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t* file, uint32_t line)
{
while (1)
{}
}
#endif

复制代码

一切USB相关的东西都在 USBD_init() 这个函数里面了。追查源代码，可以发现这个函数调用其实是向库函数提供了一堆回调函数的接口，也就是说写一些子程序，让驱动程序在需要的时候调用。这样开发USB的我们就不用去管中断什么的了，要做的就是实现各种USB的请求——其实程序库里面已经把大部分的请求应答都实现了，而具体的类库(比如我这里用的MassStorage类)又处理了剩余的大部分，所以只剩下功能性的需要自己写。

在 usbd_desc.c 这个程序里面可以看到描述符是怎么创建和返回的

/**
******************************************************************************
* @file usbd_desc.c
* @author MCD Application Team
* @version V1.0.0
* @date 31-January-2014
* @brief This file provides the USBD descriptors and string formating method.
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.st.com/software_license_agreement_liberty_v2
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_desc.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define USBD_VID 0x0483
#define USBD_PID 0x5720
#define USBD_LANGID_STRING 0x409
#define USBD_MANUFACTURER_STRING "STMicroelectronics"
#define USBD_PRODUCT_FS_STRING "Mass Storage in FS Mode"
#define USBD_CONFIGURATION_FS_STRING "MSC Config"
#define USBD_INTERFACE_FS_STRING "MSC Interface"
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
char USBD_SERIALNUMBER_FS_STRING[26];
USBD_DEVICE USR_desc =
{
USBD_USR_DeviceDescriptor,
USBD_USR_LangIDStrDescriptor,
USBD_USR_ManufacturerStrDescriptor,
USBD_USR_ProductStrDescriptor,
USBD_USR_SerialStrDescriptor,
USBD_USR_ConfigStrDescriptor,
USBD_USR_InterfaceStrDescriptor,
};
/* USB Standard Device Descriptor */
const uint8_t USBD_DeviceDesc[USB_SIZ_DEVICE_DESC] =
{
0x12, /*bLength */
USB_DEVICE_DESCRIPTOR_TYPE, /*bDescriptorType*/
0x00, /*bcdUSB */
0x02,
0x00, /*bDeviceClass*/
0x00, /*bDeviceSubClass*/
0x00, /*bDeviceProtocol*/
USB_MAX_EP0_SIZE, /*bMaxPacketSize*/
LOBYTE(USBD_VID), /*idVendor*/
HIBYTE(USBD_VID), /*idVendor*/
LOBYTE(USBD_PID), /*idVendor*/
HIBYTE(USBD_PID), /*idVendor*/
0x00, /*bcdDevice rel. 2.00*/
0x02,
USBD_IDX_MFC_STR, /*Index of manufacturer string*/
USBD_IDX_PRODUCT_STR, /*Index of product string*/
USBD_IDX_SERIAL_STR, /*Index of serial number string*/
USBD_CFG_MAX_NUM /*bNumConfigurations*/
} ; /* USB_DeviceDescriptor */
/* USB Standard Device Descriptor */
const uint8_t USBD_DeviceQualifierDesc[USB_LEN_DEV_QUALIFIER_DESC] =
{
USB_LEN_DEV_QUALIFIER_DESC,
USB_DESC_TYPE_DEVICE_QUALIFIER,
0x00,
0x02,
0x00,
0x00,
0x00,
0x40,
0x01,
0x00,
};
/* USB Standard Device Descriptor */
const uint8_t USBD_LangIDDesc[USB_SIZ_STRING_LANGID] =
{
USB_SIZ_STRING_LANGID,
USB_DESC_TYPE_STRING,
LOBYTE(USBD_LANGID_STRING),
HIBYTE(USBD_LANGID_STRING),
};
uint8_t USBD_StringSerial[USB_SIZ_STRING_SERIAL] =
{
USB_SIZ_STRING_SERIAL, /* bLength */
USB_STRING_DESCRIPTOR_TYPE, /* bDescriptorType */
};
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
static void IntToUnicode (uint32_t value , uint8_t *pbuf , uint8_t len);
/**
* @brief return the device descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_DeviceDescriptor( uint8_t speed , uint16_t *length)
{
*length = sizeof(USBD_DeviceDesc);
return (uint8_t*)USBD_DeviceDesc;
}
/**
* @brief return the LangID string descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_LangIDStrDescriptor( uint8_t speed , uint16_t *length)
{
*length = sizeof(USBD_LangIDDesc);
return (uint8_t*)USBD_LangIDDesc;
}
/**
* @brief return the product string descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_ProductStrDescriptor( uint8_t speed , uint16_t *length)
{
USBD_GetString ( (uint8_t*)USBD_PRODUCT_FS_STRING, USBD_StrDesc, length);
return USBD_StrDesc;
}
/**
* @brief return the manufacturer string descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_ManufacturerStrDescriptor( uint8_t speed , uint16_t *length)
{
USBD_GetString ( (uint8_t*)USBD_MANUFACTURER_STRING, USBD_StrDesc, length);
return USBD_StrDesc;
}
/**
* @brief return the serial number string descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_SerialStrDescriptor( uint8_t speed , uint16_t *length)
{
*length = USB_SIZ_STRING_SERIAL;
return USBD_StringSerial;
}
/**
* @brief return the configuration string descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_ConfigStrDescriptor( uint8_t speed , uint16_t *length)
{
USBD_GetString ( (uint8_t*)USBD_CONFIGURATION_FS_STRING, USBD_StrDesc, length);
return USBD_StrDesc;
}
/**
* @brief return the interface string descriptor
* @param speed : current device speed
* @param length : pointer to data length variable
* @retval pointer to descriptor buffer
*/
uint8_t * USBD_USR_InterfaceStrDescriptor( uint8_t speed , uint16_t *length)
{
USBD_GetString ( (uint8_t*)USBD_INTERFACE_FS_STRING, USBD_StrDesc, length);
return USBD_StrDesc;
}
/**
* @brief Create the serial number string descriptor
* @param None
* @retval None
*/
void Get_SerialNum(void)
{
uint32_t Device_Serial0, Device_Serial1, Device_Serial2;
Device_Serial0 = *(uint32_t*)Device1_Identifier;
Device_Serial1 = *(uint32_t*)Device2_Identifier;
Device_Serial2 = *(uint32_t*)Device3_Identifier;
Device_Serial0 += Device_Serial2;
if (Device_Serial0 != 0)
{
IntToUnicode (Device_Serial0, &USBD_StringSerial[2] ,8);
IntToUnicode (Device_Serial1, &USBD_StringSerial[18] ,4);
}
}
/**
* @brief Convert Hex 32Bits value into char
* @param value: value to convert
* @param pbuf: pointer to the buffer
* @param len: buffer length
* @retval None
*/
static void IntToUnicode (uint32_t value , uint8_t *pbuf , uint8_t len)
{
uint8_t idx = 0;
for( idx = 0 ; idx < len ; idx ++)
{
if( ((value >> 28)) < 0xA )
{
pbuf[ 2* idx] = (value >> 28) + '0';
}
else
{
pbuf[2* idx] = (value >> 28) + 'A' - 10;
}
value = value << 4;
pbuf[ 2* idx + 1] = 0;
}
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

插一句: 开发USB设备，有很重要的一部分是编写描述符（当然也要借用已有的模板），设备叫什么，功能是什么等等都从描述符体现。只要设备向主机成功返回了描述符，主机就会提示找到硬件。

设计到U盘读写操作的部分在 usbd_storage_msd.c 里面，我就是在例子程序上改的

/**
******************************************************************************
* @file usbd_storage_msd.c
* @author MCD application Team
* @version V1.0.0
* @date 31-January-2014
* @brief This file provides the disk operations functions.
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.st.com/software_license_agreement_liberty_v2
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************
*/
#include <string.h>
/* Includes ------------------------------------------------------------------*/
#include "usbd_msc_mem.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define STORAGE_LUN_NBR 1
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* USB Mass storage Standard Inquiry Data */
const int8_t STORAGE_Inquirydata[] = {
/* LUN 0 */
0x00,
0x80,
0x02,
0x02,
(USBD_STD_INQUIRY_LENGTH - 5),
0x00,
0x00,
0x00,
'S', 'T', 'M', ' ', ' ', ' ', ' ', ' ', /* Manufacturer : 8 bytes */
'm', 'i', 'c', 'r', 'o', 'S', 'D', ' ', /* Product : 16 Bytes */
'F', 'l', 'a', 's', 'h', ' ', ' ', ' ',
'1', '.', '0' ,'0', /* Version : 4 Bytes */
};
__IO uint32_t count = 0;
/* Private function prototypes -----------------------------------------------*/
int8_t STORAGE_Init (uint8_t lun);
int8_t STORAGE_GetCapacity (uint8_t lun,
uint32_t *block_num,
uint32_t *block_size);
int8_t STORAGE_IsReady (uint8_t lun);
int8_t STORAGE_IsWriteProtected (uint8_t lun);
int8_t STORAGE_Read (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len);
int8_t STORAGE_Write (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len);
int8_t STORAGE_GetMaxLun (void);
USBD_STORAGE_cb_TypeDef USBD_MICRO_SDIO_fops =
{
STORAGE_Init,
STORAGE_GetCapacity,
STORAGE_IsReady,
STORAGE_IsWriteProtected,
STORAGE_Read,
STORAGE_Write,
STORAGE_GetMaxLun,
(int8_t *)STORAGE_Inquirydata,
};
USBD_STORAGE_cb_TypeDef *USBD_STORAGE_fops = &USBD_MICRO_SDIO_fops;
/* Private functions ---------------------------------------------------------*/
/**
* @brief Initialize the storage medium
* @param lun : logical unit number
* @retval Status
*/
uint8_t dummy_disk[20][512];
uint16_t sec_index[20]; // sector usage
int8_t STORAGE_Init (uint8_t lun)
{
static char init=0;
if(!init)
{
short int i;
for(i=0;i<20;i++)
sec_index[i]=0xffff;
init=1;
}
return (0);
}
/**
* @brief return medium capacity and block size
* @param lun : logical unit number
* @param block_num : number of physical block
* @param block_size : size of a physical block
* @retval Status
*/
int8_t STORAGE_GetCapacity (uint8_t lun, uint32_t *block_num, uint32_t *block_size)
{
*block_size = 512;
*block_num = 40*9;
return (0);
}
/**
* @brief check whether the medium is ready
* @param lun : logical unit number
* @retval Status
*/
int8_t STORAGE_IsReady (uint8_t lun)
{
static uint8_t status = 0;
return (0);
}
/**
* @brief check whether the medium is write-protected
* @param lun : logical unit number
* @retval Status
*/
int8_t STORAGE_IsWriteProtected (uint8_t lun)
{
return 0;
}
/**
* @brief Read data from the medium
* @param lun : logical unit number
* @param buf : Pointer to the buffer to save data
* @param blk_addr : address of 1st block to be read
* @param blk_len : number of blocks to be read
* @retval Status
*/
int8_t STORAGE_Read (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len)
{
short int i;
for(i=0;i<blk_len;i++)
{
short int j;
for(j=0;j<20;j++)
{
if(sec_index[j]==blk_addr+i)
{
memcpy(buf+i*512,dummy_disk[j],512);
break;
}
}
if(j>=20)
{
for(j=0;j<512;j++)
buf[i*512+j]=0x00;
}
}
/* if( SD_ReadMultiBlocks (buf,
blk_addr * 512,
512,
blk_len) != 0)
{
return 5;
}
*/
return 0;
}
/**
* @brief Write data to the medium
* @param lun : logical unit number
* @param buf : Pointer to the buffer to write from
* @param blk_addr : address of 1st block to be written
* @param blk_len : number of blocks to be read
* @retval Status
*/
int8_t STORAGE_Write (uint8_t lun,
uint8_t *buf,
uint32_t blk_addr,
uint16_t blk_len)
{
short int i;
for(i=0;i<blk_len;i++)
{
short int j;
char zero=1;
unsigned char avail=0xff;
for(j=0;j<512;j++)
if(buf[j+i*512])
zero=0;
for(j=0;j<20;j++)
{
if(sec_index[j]==blk_addr+i)
break;
if(avail==0xff && sec_index[j]==0xffff)
avail=j;
}
if(zero)
{
if(j<20)
sec_index[j]=0xffff; // free
return 0;
}
if(j>=20)
{
if(avail<20)
j=avail;
else // No free sectors
{
j=1+rand()%19;
}
}
memcpy(dummy_disk[j],buf+i*512,512);
sec_index[j]=blk_addr+i;
}
return (0);
}
/**
* @brief Return number of supported logical unit
* @param None
* @retval number of logical unit
*/
int8_t STORAGE_GetMaxLun (void)
{
return (STORAGE_LUN_NBR - 1);
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

主要是需要完成报告容量、读、写三个函数。如果有可实现存储的硬件，接口连起来即可。我上面是用了10kB的RAM来存放，动态分配20个扇区来存储。如果检测到要写的整个扇区都是0，那么就忽略。于是这样就做成了虚拟的U盘。

附件包含了所有需要的程序源代码，USB库的部分在lib子目录下面。build.bat 中是编译的命令。依靠这个USB函数库开发起来还算不难吧，只要看懂了例子，mass storage class还比较简单，因为硬件涉及就是读扇区、写扇区。 USB HID设备五花八门，就不是这么简单了，继续研究去。

liutogo · 发表于2015-11-23 23:06

膜拜大神！

damiaa · 发表于2015-11-24 09:22

楼主辛苦了。

hdt45 · 发表于2015-11-24 13:25

其实淘宝上STM32F072比STM32F103C8卖得贵而少吧。。。

ddllxxrr · 发表于2015-11-24 13:42

写得挺好顶

maken

楼主有做USBHID功能的开发么？？

cruelfox

maken 发表于 2016-1-18 15:15
楼主有做USBHID功能的开发么？？

还没。这个用库里的例子应该不难，我还没时间弄。

sblpp

可以用它来做JLink OB啦

bush4023

看起来很牛逼的样子，学习ing

bush4023

cruelfox 发表于 2016-1-19 08:09
还没。这个用库里的例子应该不难，我还没时间弄。

楼主，我现在想把STM321系列的HID程序移植到072上来，找你探讨一下，望见信回复下

cruelfox

bush4023 发表于 2016-1-22 13:29
楼主，我现在想把STM321系列的HID程序移植到072上来，找你探讨一下，望见信回复下

有何见教？
STM321我倒是没有用过。

bush4023

cruelfox 发表于 2016-1-22 16:27
有何见教？
STM321我倒是没有用过。

方便留个企鹅号不？或者你加我233030352

maken

bush4023 发表于 2016-1-22 16:39
方便留个企鹅号不？或者你加我233030352

层主，请问你在做USB HID stm32f070开发么？

cruelfox

maken 发表于 2016-1-27 13:41
层主，请问你在做USB HID stm32f070开发么？

没有哈，没有时间暂时顾不上了。

feiyinglala

哇，这个想法好，初入门用这个看起来棒棒的

[11月DIY]打造最简STM32F0 USB开发板 [复制链接]

最新回复

赞赏

C程序是如何运行的

点评

点评

点评

测评达人

荣誉会员勋章