最近整理东西，突然发现以前买的一个步进电机模块，以前使用5V单片机驱动的。突然想试试能不能用STM32F103单片机的3.3V直接驱动ULN2003这个芯片。
6 l& U' n" H2 W+ ?, Z


! A" G. c- |1 o9 J9 ~试了一下ULN2003可以用3.3V电压直接驱动。下面分享下电机驱动的过程。
# V6 O6 K3 `' c& J7 E
先看看实物图
+ t3 ]' ?; w+ B1 D


9 B' u5 i9 J1 t7 @& w单片机使用的是STM32F103C8T6最小系统。电机和驱动板是网上买的整套模块。

+ m8 ?5 M1 Q! \% M4 o$ _驱动板的原理图如下

- c; b  x/ f# y" C$ u" D$ {
( b2 C$ d( {+ h; H% m( n
3 i* X8 n4 A# i        步进电机使用的是5线4相直流减速步进电机   直径：28mm  电压：5V  步进角度：5.625 x 1/64  减速比：1/64
" b1 O% m# k* E$ F
8 j9 O' U7 e( O       步距角：5.625 / 64 = 0.087度 （也就是说理论上，你给一个脉冲，电机外部轴转动0.087度）也就是说一个脉冲内部转子转5.625度，但是由于减速64倍，所以外部轴只转了0.087度那么外部轴要转一圈的话，需要360/0.087=4096个脉冲。采用4相8拍驱动的话，8个脉冲是一个周期，那么就需要4096/8=512个周期，外部轴刚好转一圈。

/ G9 @- m# |% C  W1 o    电机的驱动一般分为3种方法

    一.  1相励磁法：每一瞬间只有一个线圈相通，其它休息。
3 C& U3 E; _- r4 ?/ j  \
8 B; Q" Q+ o; e          （优点）简单，耗电低，精确性良好。
9 U4 I. z7 a  a0 K) N0 e
         （缺点）力矩小，振动大，每次励磁信号走的角度都是标称角度。  1相励磁法  A->B->C->D
- s  V/ a5 P$ _+ r$ V  `
& \  p5 Y0 Z+ U   二、 2相励磁法：每一瞬间有两个线圈导通。
0 @# l7 [4 W9 j  {* e! r2 K
8 u- k  c" D/ ~+ @, t         （优点）力矩大，震动小。

$ J/ [0 ~: X& @  U. Q$ b4 D3 Y0 G; _6 z         （缺点）每励磁信号走的角度都是标称角度。2相励磁法  AB->BC->CD->DA
0 l- k: l4 K: d* p6 C" y
8 Z5 L" }/ t; n   三、 1-2相励磁法：1相和2相交替导通。
, l% N" I; t7 t. G, x) g& x
           （优点）精度较高，运转平滑，每送一个励磁信号转动1/2标称角度，称为半步驱动。（前两种称为4相4拍，这一种称为4相8拍）

            1-2相励磁法  A-->AB-->B->BC->C-->CD->D-->DA
5 D! ^: y. Q7 f3 p! b% R
. y# p0 m. K( A$ i2 b6 ?下面就用代码来实现这三种方式
- h# `+ N3 \9 s; i) n
! g1 n+ {+ l- S       ULN2003这个小驱动板上IN1、IN2、IN3、IN4四个插针和单片机的 IO口直接用杜邦线连接，为了方便控制，首先定义好要使用的 IO口。就直接在LED的工程上修改。

0 e( O; |0 R; v6 r' k9 m" ~. m       首先新建一个bsp_motor.h的头文件，在头文件里面进行端口声明。

1. #define LA    PBout(6)                         //A 相
   - d  M, \# p8 k& i2 b+ x
2. #define LB    PBout(7)                         //B 相
   6 O5 y; ]: E. X6 _: f! L
3. #define LC    PBout(8)                         //C 相
   ; t" p9 @4 k8 K& X
4. #define LD    PBout(9)                         //D 相
   
5. 
   7 ?- D% s7 v" [! u$ N" d& H3 ]
6. /* 定义电机连接的GPIO端口, 用户只需要修改下面的代码即可改变控制电机的引脚 */
   , r1 m; K% H' C" G- @; ~3 l2 o
7. #define LA_GPIO_PORT            GPIOB                                /* GPIO端口 */
   * o  T% j; i6 \
8. #define LA_GPIO_CLK             RCC_APB2Periph_GPIOB                /* GPIO端口时钟 */
   
9. #define LA_GPIO_PIN                        GPIO_Pin_6
   4 C4 l. m! w, r8 Z' x  {$ R! X
10. 
    # {$ g& {# _  d6 f7 L$ O9 R! G
11. #define LB_GPIO_PORT            GPIOB
    ) A2 Z! e& S" C1 T" ?; @8 Y
12. #define LB_GPIO_CLK             RCC_APB2Periph_GPIOB
    / s- s- L$ ?. {! ]) m: C
13. #define LB_GPIO_PIN                    GPIO_Pin_7
    7 k) H* G# Y1 V/ X& n
14. 
    ) _* [2 N% e7 ^  q, ^2 j
15. #define LC_GPIO_PORT            GPIOB
    
16. #define LC_GPIO_CLK             RCC_APB2Periph_GPIOB
    
17. #define LC_GPIO_PIN                    GPIO_Pin_8
    
18. 
    6 s) ^% g) s% g* n2 W5 a2 |, U8 ?
19. #define LD_GPIO_PORT            GPIOB
    
20. #define LD_GPIO_CLK             RCC_APB2Periph_GPIOB
    / }" r9 O8 f' w
21. #define LD_GPIO_PIN                    GPIO_Pin_9

复制代码

       这里使用PB口的6、7、8、9四个端口来控制，端口使用了位带定义的方法，这样用程序控制起来更方便。关于位带定义可以自己查阅相关资料。端口和时钟都使用了宏定义重新命名。这样以后需要更改IO口的时候，只需要在头文件中更改，不需要更改程序中的代码，方便程序移植。  

      下面开始编写驱动代码，首先使用1相励磁法，也就是使4个IO口轮流为高电平，可以直接使用位带操作，依次给LA、LB、LC、LD给高电平。但是这样写的话每一种驱动方式都要写一个驱动函数，为了使操作起来更方便，将这4个口的值组成一个字节，并存在数组中，通过下标轮流调用数组中的数就行。这里将LA作为字节得最低位bit0，将LD作为字节第3位bit3。

       这样电机导通相序为  D-C-B-A时，定义数组中的值为
$ y1 \0 d) P4 |, X; p9 k
- V* k2 P3 D% C% }  K: b6 X/ J+ G

1. u8 phasecw[4] = {0x08, 0x04, 0x02, 0x01};

复制代码

       电机导通相序为   A-B-C-D 是，数组中的值为
) [0 L! n0 X" d

1. u8 phaseccw[4] = {0x01, 0x02, 0x04, 0x08};

复制代码

0 o7 G3 h# I5 v" u' U2 ?( t+ y下面新建bsp_motor.c文件，并在里面编写一个函数来调用这个数组就行了

6 J" _7 [) L4 H2 b( r  ~

1. void MotorCW( void )
   
2. {
   
3.     u8 i;
   
4.     u8 temp = 0;
   
5.     for( i = 0; i < 4; i++ )
   
6.     {
   
7.         temp = phasecw;
   4 ~8 f, n3 S5 D6 Y% ?% I1 F
8. 
   / c9 Q0 E8 t7 f8 M# x, n
9.         LD = ( temp >> 3 ) & 0x01;                                                        //取bit4的值
   
10.         LC = ( temp >> 2 ) & 0x01;
    
11.         LB = ( temp >> 1 ) & 0x01;
    
12.         LA = ( temp >> 0 ) & 0x01;                                                        //取bit0的值
    3 `. E/ ]" s1 h  m
13.         delay_ms( 2 );                                                                                 
    - t- q# r. V2 v$ s
14.     }
    
15. }

复制代码

        通过一个for循环，依次读取数组中的值，然后根据A、B、C、D四相的位置，去读取对应位的值，直接赋值给 IO口。这样电机驱动的函数就写好了，在主程序中直接调用这个函数就可以控制电机转动了。

       如果要改成 2相励磁法驱动的话，直接替换数组中的数据就行。
) O% Q& Q/ S$ J7 u/ x

1. u8 phasecw[4] = {0x0c, 0x06, 0x03,0x09};   //正转 电机导通相序  DC-CB-BA-AD
   
2. u8 phaseccw[4] = {0x03, 0x06, 0x0c, 0x09}; //反转 电机导通相序  AB-BC-CD-DA

复制代码

       如果要改成 1-2相励磁法，依然是直接修改数组中的值就行。

1. u8 phasecw[8] = {0x08, 0x0c, 0x04, 0x06, 0x02, 0x03, 0x01, 0x09}; //正转 电机导通相序  D-DC-C-CB-B-BA-A-AD
   6 ]7 Q- T3 h( v4 ^  V
2. u8 phaseccw[8] = {0x01, 0x03, 0x02, 0x06, 0x04, 0x0c, 0x08, 0x89}; //反转 电机导通相序  A-AB-B-BC-C-CD-D-DA

复制代码

7 W8 o2 I7 _% F, b      通过 1-2相励磁法控制的话，每次需要发送8个脉冲，也就是4相8拍，这样一个周期需要发送8个数组，要在for循环中将循环数量改为8。

1. void MotorCW( void )
   
2. {
   $ U& Y9 }! w, }# D- K
3.     u8 i;
   
4.     u8 temp = 0;
   - u9 U/ b0 \. J
5.     for( i = 0; i < 8; i++ )
   " e' K5 O3 p, |5 Z% X/ ?/ |- `
6.     {
   4 {5 z( l8 f3 L( `6 ?) {+ S
7. <i>        temp = phasecw;
   
8.         LD = ( temp >> 3 ) & 0x01;                                                        //取bit4的值
   6 {- `# C2 f, t  p
9.         LC = ( temp >> 2 ) & 0x01;
   * [; p$ p$ N# Z$ |1 F) N
10.         LB = ( temp >> 1 ) & 0x01;
      }( M: s5 p7 `. }7 l5 C! Z
11.         LA = ( temp >> 0 ) & 0x01;                                                        //取bit0的值
    2 q2 }( u( M1 n
12.         delay_ms( 2 );                                                                                 
    % g% P& e8 I" t7 R
13.     }
    - `3 V7 X' W- M0 z9 ^
14. }</i>

复制代码

) S  g' ~7 P: `# e, ^4 V然后在主程序中直接调用这个函数就可以让电机转起来了。
8 }" I) s1 u' q4 G+ v: \; y
2 f" i9 j5 X$ V* b( D2 ]1 x

1. int main( void )
   2 `: \# w  E2 T5 A) c( t+ I& E) c
2. {
   
3. 
   
4.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
   , F: B6 f# b' U8 Y; ~
5. 
   ' V% G$ M* {$ f' P  r  l- l
6.     Motor_GPIO_Config();
   % S* @3 I/ |! V' m; [
7.     while ( 1 )
   , j; p! Y$ b. S9 w+ j( N
8.     {      
   
9.       MotorCW();   
   
10.     }
    
11. }

复制代码

4 O3 B- N+ c- X0 \这样看来驱动电机是很简单的用keil模拟的仿真波形

1相励磁法  D-C-B-A

5 N; Q/ c2 @$ y# s# W
) t$ e3 o, k/ \0 ^8 c" C
3 _0 N8 ^0 [# D2相励磁法 DC-CB-BA-AD


6 I3 p7 i  r/ c. ]
) i. @: m" C' D4 n$ Y  L1-2相励磁法 D-DC-C-CB-B-BA-A-AD


  E1 i4 H/ @" U8 I
3 R  a' I3 P& C8 i; ~波形和理论相符，说明驱动是正确的。
; K3 a# O* D' K6 q! f
# `' Y2 Z7 a" y( `到这里应该就结束了，但是又手贱的给主程序加了个LED闪灯的程序，这一加出事了。

- U! g3 t0 _5 i& H7 ]

1. int main( void )
   
2. {
   3 }* Z% S% T& B& a! k6 C
3.     u16 cnt = 0;
   & Z% a- M' P, E1 B
4.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
   
5.     LED_GPIO_Config();
   2 `8 Z1 j: R) u, x
6.     Motor_GPIO_Config();
     I& y/ D/ {. @3 P- F
7.     while ( 1 )
   
8.     {
   
9.         LED1_TOGGLE;
   3 K" r, Q0 l4 i3 {- m+ M$ |7 K; h
10.         MotorCW();
    " Y" Y# q& D% ?. L3 N4 o0 \) R
11.             delay_ms(20);
    
12.     }
    ; p- Q/ y: N! x0 O* F
13. }

复制代码

/ U, Y% m! s6 h& E$ C2 z主程序中加了一个20ms的延时，同时让LED灯翻转。程序烧进去之后，发现电机不转了。这是怎么回事？赶紧看看仿真波形。


& s9 O4 Q; {+ `
& S9 Y, C1 g: `0 P       这一看发现了问题，A项的波形怎么高电平突然变长了？

5 |5 s6 S% E$ Z, m# `! ]: c' w

1. u8 phasecw[4] = {0x08, 0x04, 0x02, 0x01};

复制代码

        数组中依次给的值是8、4、2、1，也就是D、C、B、A相依次为高电平，其他三相高电平只持续了2ms，但是A相的电平持续了20多ms，这是什么原因？仔细分析程序执行流程后发现了问题所在。在for循环中依次给4个相赋值，A相位最后一个赋值，当给A项赋值时，其他3项为低电平，A项为高电平，然后程序退出for循环，回到主程序中，此时又执行了20ms的延时，这时A项的电平还是最后一次赋值的高电平。将这20ms延时去掉后，电机正常运转，波形也正常了。也就是说就是这个延时影响了电机的转动。
! k' E7 d' x6 H7 t
       那么主程序中就不能用延时了吗？LED闪烁功能都实现不了了吗？还能让一个电机驱动程序把单片机霸占了不成？这当然是不行了，一定要将这个问题的根源找到，既然是最后一次给A项赋值后，A项高电平没有复位，那么就手动让A项复位。强制让A项的电平归零。
: ]$ q3 b# L1 H, r
9 d$ J' J% ]9 ^8 T% w    在增加一个复位的函数
* d6 I& ~* x- E. R

1. void MotorStop( void )
   : B! d9 j8 A5 B  j$ i6 ?
2. {
   
3.     LA = 0;
   
4.     LB = 0;
   3 u# p, Z( u7 N2 T8 _
5.     LC = 0;
   * e  O9 r6 s% d7 D/ Y: `: Y* r5 ^# @9 d
6.     LD = 0;
   
7. }

复制代码

      这个函数强制的将四相复位，然后在电机驱动的时候，每次执行完一个周期，就强制让这4项复位。
$ _# u% H- J, ]6 E: e" g2 k
4 I0 {% c: _; Z6 x, J8 @

1. void MotorCW( void )
   " w. Z4 a; p4 l& I
2. {
   & P1 w6 h3 H3 F2 ?1 V
3.     u8 i;
   1 [! T) S9 d1 f
4.     u8 temp = 0;
   
5.     for( i = 0; i < 4; i++ )
   
6.     {
   
7.         temp = phasecw;
   
8. 
   
9.         LD = ( temp >> 3 ) & 0x01;                                                        //取bit4的值
   ) Z) A( F( q+ [0 D. K
10.         LC = ( temp >> 2 ) & 0x01;
    
11.         LB = ( temp >> 1 ) & 0x01;
    
12.         LA = ( temp >> 0 ) & 0x01;                                                        //取bit0的值
    ! E+ T! X. r% z: N
13.         delay_ms( 2 );                                                                                                         
    
14.     }
    + M/ V" M: L/ P1 l5 i5 @5 E( w; f
15.     MotorStop(); //一个周期转动结束后需要复位所有相，否则最后一项如果被设置为高电平后会持续维持高电平。
    0 t: `* g* x: ^; L& ~
16. }

复制代码

5 c% V% ~. A, f' V9 r$ @2 w2 A     增加复位功能后，主程序中依然加上20ms延时，继续仿真查看波形。
& u2 U% j( N  ~0 ]; Y; e# s: ~0 {

- e: V7 U1 r7 D
' w! f- A4 A8 P% M" j" p        这下波形正常了，下载程序后电机也缓慢转动起来了，LED灯也开始闪烁了。说明刚开始驱动时只想到了相位的逻辑，但是没有考虑到相位复位的问题，考虑问题还是不全面。

       下来在主程序中加上电机正反转功能，让电机正转一圈，然后又反转一圈。

1. int main( void )
   & E+ J" N2 a" k1 R" \0 j" F" J0 t
2. {
   % Z) P  i$ v$ L+ C. V
3.     u16 cnt = 0;
   
4.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
   $ H! F- z6 \7 z
5.     LED_GPIO_Config();
   
6. 
   
7.     Motor_GPIO_Config();
   
8.     while ( 1 )
     O" J6 f. [& Z! T5 L
9.     {
   ( z' c$ V: r: u( e
10.         cnt++;
    
11. 
    4 j- U5 w" w5 s9 Z
12.         if( cnt <= 512 )                                                        //采用4相8拍，512个周期刚好是一圈
    
13.             MotorCW();                                                                //正转
    
14.         else if( cnt <= 1024 )
    ; I  Q$ [* `: l5 B- }
15.             MotorCCW();                                                                //反转
    
16.         else
    " |+ z' |" W3 l
17.         {
    5 [# K9 y, w$ d' N
18.             cnt = 0;
    
19.             LED1_TOGGLE;
    % h- ]8 c/ F5 V; f! D9 i7 ~
20.             delay_ms( 500 );
      b; }5 W( ^3 @- `! `1 Q4 r
21.         }
    
22.     }
    # i! |3 _! A- z% G- d+ z5 `5 d
23. }

复制代码

/ m) \9 F$ A& O) t       这里采用4相8拍驱动，8个脉冲是一个周期，那么就需要4096/8=512个周期，外部轴刚好转一圈。计数器小于512时正转，计时器在512和1024之间时反转。然后LED灯翻转一次，在延时500ms。 这里还要注意一个问题，在电机驱动函数中，每个脉冲的延时时间经过实际测试不能小于2ms，延时太小的时候，电机抖动严重，但是不会转动。延时越大，电机转动越慢。
2 r% B  e7 G4 R- ~
     到此电机驱动程序已经完美运行了。

5 u/ Q5 b) Q4 n4 Y- @1 p3 M& J* \