单片机直流电机调速系统仿真+源代码

Taio · 发表于 2018-11-7 09:58

EDA365欢迎您登录！

您需要登录才可以下载或查看，没有帐号？注册

x

单片机直流电机调速系统仿真+源代码

直流电机调速仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

#include <reg52.h>
/*********************************************
* 定时器初值
*********************************************/
#define T0HIGH       0xec
#define T0LOWW       0x8a

/*********************************************
*
*********************************************/
typedef unsigned char       u8;
typedef unsigned int       u16;
typedef unsigned long       u32;
typedef bit                               BOOL;

/*********************************************
* 单片机管脚定义
*********************************************/
sbit KEY_ON_PIN = P2^0;
sbit KEY_INC_PIN = P2^1;
sbit KEY_DEC_PIN = P2^2;

sbit MOTO_LEFT = P3^6;
sbit MOTO_RIGHT = P3^7;

/*********************************************
* 按键定义
*********************************************/
#define KEY_NULL             0xff
#define KEY_LONG_PERIOD       25
#define KEY_CONTINUE_PERIOD       20

#define KEY_DOWN             0x80
#define KEY_CONTINUE       0x40
#define KEY_UP                      0x20

#define KEY_STATE_INIT             0
#define KEY_STATE_WOBBLE       1
#define KEY_STATE_PRESS             2
#define KEY_STATE_LONG             3
#define KEY_STATE_CONTINUE       4
#define KEY_STATE_RELEASE       5

#define KEY_ON_VALUE             1
#define KEY_INC_VALUE             2
#define KEY_DEC_VALUE             3

#define KEY_ON             (KEY_ON_VALUE | KEY_DOWN)
#define KEY_INC             (KEY_INC_VALUE | KEY_DOWN)
#define KEY_INC_CON       (KEY_INC_VALUE | KEY_CONTINUE)
#define KEY_DEC             (KEY_DEC_VALUE | KEY_DOWN)
#define KEY_DEC_CON       (KEY_DEC_VALUE | KEY_CONTINUE)
/*********************************************
* 常量定义
*********************************************/
#define true       1
#define false       0

#define MOTO_ON             MOTO_LEFT = false;\
                                    MOTO_RIGHT = true
#define MOTO_OFF       MOTO_LEFT = true;\
                                    MOTO_RIGHT = true
/*********************************************
* 全局变量定义
*********************************************/
code u8 DisCode[] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90, 0xff};

u8 PWMpercent = 0;
u8 DisNum[4] = {0x0a, 0x0a, 0x0a, 0x00};
u8 DisPosition = 0;
u8 SecCount = 0;
u8 u10msNum = 0;

BOOL b10msEvent = false;
BOOL b100msEvent = false;
BOOL b1secEvent = false;
BOOL MotoStart = false;
BOOL MotoRun = false;

void Key_Prosess(void);
void Dynamic_Display(void);
void Speed_Display(void);

/*********************************************
* 主函数
*********************************************/
main()
{
      TMOD = 0x01;
      TH0 = T0HIGH;
      TL0 = T0LOWW;
      TR0 = 1;
      ET0 = 1;
      EA = 1;
      P1 = 0x00;

      while(1)
      {
            if(true == b10msEvent)       //10毫秒定时标志
            {
                     b10msEvent = false;
                     Key_Prosess();             //按键扫描
                     Dynamic_Display();             //动态显示

                     if(true == MotoStart)       //如果电机启动
                     {
                              if(true == MotoRun)
                              {
                                    if(--u10msNum == 0)             //如果电机转动时间到,停止电机
                                    {
                                             MotoRun = false;
                                             MOTO_OFF;
                                    }
                              }
                              if(true == b1secEvent)             //PWM周期为1秒,1秒钟时间到,开始下一个周期
                              {
                                    b1secEvent = false;
                                    MotoRun = true;
                                    MOTO_ON;
                                    u10msNum = PWMpercent;
                              }
                     }
            }
      }
}
/*********************************************
* 清显示
*********************************************/
void Num_Clear(void)
{
      u8 i;
      for(i=0; i<3; i++)
      {
            DisNum = 0x0a;
7 A! S& ~6 B2 D1 L' f  i9 c3 M8 d       }7 a) L1 p+ f6 t
      DisNum[3] = 0x00;
# x, G3 L# ~, [2 n8 r}' [  t) y& {, J# z
/*********************************************. z) a$ ~: ?+ P" i
* 读键值
7 a; w5 n/ F2 n  c: v*********************************************/
* V+ `: p; Z; Y0 v# eu8 Key_Scan(void)& h6 x/ O) j. f/ ?
{
2 Z  c5 {: m4 k       if(KEY_ON_PIN == false)) S1 G1 d7 A; I! o3 d/ E
            return KEY_ON_VALUE;% G! H$ R* Q& Q+ a4 X' T: g
      if(KEY_INC_PIN == false)
5 H# @7 x0 _8 F# A  x             return KEY_INC_VALUE;" v+ O( Y+ l. J( W' z7 Y/ R
      if(KEY_DEC_PIN == false)
! F$ s7 ]  B4 |6 J1 [; `: P             return KEY_DEC_VALUE;
8 @# V3 O$ U6 q/ d; s       return KEY_NULL;
% c! u* J, {. _5 e) ?' j4 Z}
- z* _9 M2 `# C! ]8 v/*********************************************
- u! m8 T4 U3 J2 i* 按键状态扫描
; @, K7 ?7 x. h% D0 Z! i*********************************************/3 }% b) M! X7 O# p
u8 GetKey(void)
: D2 S* O  D, ~' Z# Z- D8 f{
( t  P# x$ Z/ y. V7 r" L. g$ S       static u8 KeyState = KEY_STATE_INIT;
* H! {% o' |, T/ ?3 U# |       static u8 KeyTimeCount = 0;& @, h5 ~; ?. H# L
      static u8 LastKey = KEY_NULL;       //保存按键释放时候的键值
/ H* x- }, l/ }       u8 KeyTemp = KEY_NULL ;4 c; t4 g6 e) u4 s( I* ?9 k

+ K" K1 V' u: p! H/ ?  M" h3 j7 w/ i       KeyTemp = Key_Scan();
6 r5 C$ ^% o. r( V$ G, w# ^
5 H: o3 ]/ u0 w* A  @1 z- v- `- e0 F       switch(KeyState)' i  u9 Y# t0 W1 Y. x3 a
      {& ]8 I6 V' P5 i8 G( V8 o
            case KEY_STATE_INIT:       //初始状态  V2 k' r7 }0 A$ Q2 q' h
                     if(KEY_NULL != KeyTemp)       //有键按下- G2 C; C" z: u6 d! q( x& {4 g
                     {& b& d  j- H  K
                              KeyState = KEY_STATE_WOBBLE;       //进入消抖
* w% q" f" d/ C& |% `                      }6 U5 W5 C. f1 S! a" r
                     break;3 V1 t& ]+ d6 J" X% W

* c9 L9 O5 R/ V1 N             case KEY_STATE_WOBBLE:       //消抖
( X( ?. ^" F, E7 t                      KeyState = KEY_STATE_PRESS;
& q) g8 B6 e* o: s. N& l                      break;# ~% @6 r7 u3 Y( v" ]* j

4 l0 @1 S/ a! F+ X& ]             case KEY_STATE_PRESS:) \; s, K) W% N2 D9 s& N
                     if(KEY_NULL != KeyTemp)
2 H) K* X9 {4 U. S1 }. Y                      {6 J3 v* E) ^: H0 r8 E! [0 g, J
                              LastKey = KeyTemp;       //保存键值,以便在释放按键状态返回键值& ]1 V% X; G! {4 J9 ]& ^* l
                              KeyTemp |= KEY_DOWN;       //按键按下
! V: Y5 i5 K' {; b3 W8 c! x                               KeyState = KEY_STATE_LONG;/ T' }! w* }/ N- E( s0 S5 p; Z
                     }6 i( ?/ P+ G) G+ b7 a0 O
                     else
' S# c; }5 Z- j' G. ]                      {6 S9 ]- z) w. _/ L+ L
                              KeyState = KEY_STATE_INIT;
& i  T! R5 ^3 N; |3 n- }9 K                      }
/ @6 n: {7 m/ C" a7 g1 Z& G  j                      break;8 f8 e7 n/ n) d" M# g

+ d* P2 Y7 L' q5 B5 {, H& ], W- _             case KEY_STATE_LONG:- @. x  W0 z$ t1 S* p" X5 G$ ]
                     if(KEY_NULL != KeyTemp)- |- S. J. @: z5 y6 z
                     {, a/ E5 V  Q- [* M- C
                              if(++KeyTimeCount >= KEY_LONG_PERIOD)9 }' A( c6 P0 h# h  R
                              {& C- q7 `: w/ ?* y5 W7 f
                                    KeyTimeCount = 0;/ O4 ]/ H- I2 h1 w3 L# p! y
                                    KeyState = KEY_STATE_CONTINUE;
2 k" {$ V3 N2 F7 @6 L                               }
6 ]  p9 j* [# I, e* C( b                      }" Q% P* O+ h5 z7 R+ k" h, r
                     else; p8 I5 I9 f) c3 y, q
                     {
# T" ]* G) d6 L& x8 ?7 M3 [                               KeyState = KEY_STATE_RELEASE;/ @! O5 Z5 j" L' U7 Y1 }; k
                     }0 I+ V( |4 a2 P
                     break;
, J# J' b# F% a9 r2 X* Q$ K* i
) A) p1 v$ _% p             case KEY_STATE_CONTINUE:
9 t- G! ~8 k3 |                      if(KEY_NULL != (KeyTemp)); d$ X5 L+ G  e! P& ~  T$ u) I& w
                     {
9 H8 p; ]! X* S  b( J- I                               if(++KeyTimeCount >= KEY_CONTINUE_PERIOD)
2 p4 f2 g) w% N$ d$ H" J$ x" t# F5 R                               {
8 m6 d/ R4 h0 T9 r                                     KeyTimeCount = 0;
* _$ Y+ Z! ~# p                                     KeyTemp |= KEY_CONTINUE;  //连击按键事件发生
5 A4 f- J/ M2 p' K  [/ n( d' e) z                               }* ~3 d/ d" L/ y! S) ^
                     }4 W( J$ @  S( Q0 ~2 ]
                     else6 z4 N- r( ?' T: `' j7 E/ m( W) H3 d$ `
                     {
0 v3 T' ]% H: o3 [                               KeyState = KEY_STATE_RELEASE;
; e& b/ b8 ~+ l                      }
8 V& N" o- I; j3 |! o                      break;2 K; e- _- [4 e  h* {
. z; }. g, W. O! L
            case KEY_STATE_RELEASE:- h7 d, Z+ G( L& M" x
                     LastKey |= KEY_UP;       //按键释放
0 E2 |9 P; R, d9 {: m+ I                      KeyTemp = LastKey;
' z: O$ T) m( c8 F& A0 [7 t                      KeyState = KEY_STATE_INIT;
0 S2 g$ H# Z* @. _1 o* o& e2 h                      break;
! C5 K" j1 Y  f' }3 w0 V- C# X& h2 B2 e$ ^
            default:; z  _" v' A5 n% u8 S
                     break;0 [6 b+ X% H  r) `2 d1 X# \
      }) z' x3 i$ P, L9 U
      return KeyTemp;
) k* e1 ]' t# u9 c}% |7 e$ R  d+ I; a, B  F# X
/*********************************************
" O; K8 |% L) {% ?* 按键功能处理7 X1 Q; `$ \: \! x8 t
*********************************************/) `' K* a" A+ z0 T
void Key_Prosess(void)! _; l5 r) M3 Y7 W- Q9 l
{
& K2 F" l7 w+ s  v/ d) _" ?9 @       u8 KeyData;
8 Q* V/ `6 c# U$ c# D  K3 X) f0 O, [# X, N: i  U3 Q
      KeyData = GetKey();0 s3 ]% H$ N& l7 w+ q6 j3 ^

, q, g0 z1 D3 M; ]- o7 a' F1 j) {3 }2 e       switch(KeyData)
3 i7 }0 @: D5 ?       {5 G! f$ w& m7 p% {# f7 |! H  F% W
            case KEY_ON:       //开关电机
& Q0 E; J' |* v2 ?0 F! T+ E                      if(true == MotoStart)
5 ^% ^0 R( O6 F                      {  g+ I" ]5 [7 v( k% X! z/ ^* r$ L
                              MotoStart = false;
- ~8 w5 C8 D" ]: l% D9 N1 o                               Num_Clear();
0 h6 ^& ~$ |, w                               MOTO_OFF;, m. _! h5 L4 Y$ N
                              MotoRun = false;
7 h2 n8 j' s" Q$ D0 H4 Z                               PWMpercent= 0;8 ]0 N# r' ^3 \9 {8 Y
                     }
$ O2 N+ d6 }8 r3 }& \& \1 F2 e                      else; D+ O1 X+ o3 r- D3 E/ }' g8 t4 n
                     {3 Y: q# [* Q/ P! S0 L) \
                              MotoStart = true;
7 e! p, U2 X, R                               MOTO_ON;
0 o5 x4 y; t  k2 j2 Z) ^0 E                               MotoStart = true;8 Z8 ^8 @3 T* `, O8 x' B/ O; ?
                              MotoRun = true;
* p3 _* I" r- Z' }; @# V                               u10msNum = PWMpercent = 1;
6 x2 m5 A! E) k1 [                      }
% s: c) {. I! }  Q$ r+ ]                      break;7 J2 |- m+ `  o7 b. h$ M/ A

( A( ~$ V: r; U             case KEY_INC:       //单步增加( j3 q- G+ L" `2 T  w8 A
            case KEY_INC_CON:       //连续增加4 s0 h; D7 q6 ?4 v
                     if((PWMpercent < 100) && MotoStart)             //PWM从1%~100%
5 x- F! C5 ~+ E2 D' C                               PWMpercent++;) _) q; F7 u- ^$ ~1 d( t8 s3 n
                     break;
, t1 `! w2 {, B$ c, ?* P' S. c3 k: B) H8 l4 Q, Z
            case KEY_DEC:       //单步减小1 O; R- C- \) S: Q  f' b
            case KEY_DEC_CON:       //连续减小
, r5 ]; a9 ?- x/ R+ N/ i9 D; f: T0 e! t                      if((PWMpercent > 1) && MotoStart)             //PWM从1%~100%( ?& V$ T! C+ D' b
                              PWMpercent--;; g5 u# I* u( `' h( a9 \
                     break;
' f% L3 P# l2 W) O; h1 `) K
/ ~+ q) z( w: u; B             default:
9 Q3 c' g7 L) J  N1 ~6 N                      break;
2 O5 `, t+ g1 Y       }
. L6 T) k2 W1 h. W3 L; ~$ P6 z( x       Speed_Display();/ y# X4 S. j$ _' J
}
) }- H* |, [: P( ]1 R3 C, _. j/*********************************************
5 t1 h- N. }: t; h! ~) u2 ?1 P: h* 速度转换成十进制数2 w) r# Q* F  f
*********************************************// M. a) ^& o, m/ e: i: D6 V5 G
void Speed_Display(void)$ M+ g' p- @) W
{
+ e& i2 g. \9 B) |* u0 c       u8 i;
! K9 b- c# q! U9 W' K( t9 M
9 G( ]; C! C+ {6 s4 I& M" k6 S       DisNum[1] = PWMpercent / 100;1 ~" y7 o+ e7 x& v$ C
      DisNum[2] = PWMpercent % 100 / 10;
* s2 b; R" l) R% L# t8 F- K       DisNum[3] = PWMpercent % 10;
) e- s) C9 |, s5 m  ~       for(i=1; i<3; i++), m4 \0 @- W( q/ {- f+ f
      {" L6 s7 D. e# a2 E
            if(DisNum != 0)" p0 i& e- u9 T" X3 ~
                     break;3 `- Z( P# \; v( u2 N
            DisNum = 0x0a;
( z: H. s! Z+ Z" l4 t& h2 d……………………7 Q) p9 X0 p+ l- T+ c; E; J2 c( H* _

8 }/ N/ X% _/ f' ~) I6 n. s" L…………限于本文篇幅余下代码请从eda365.com下载附件…………& T8 F9 g5 o4 k( {" n6 N% Z
# C0 ?* Q& t" ^  c2 E1 C2 J0 w

游客，如果您要查看本帖隐藏内容请回复
: C& |: j2 b4 ^. K- r! M

3 Y8 l+ p( @5 d

姗姗的shanshan · 发表于 2018-11-7 23:02

谢谢分享

sunygd · 发表于 2019-1-23 15:55

看看楼主的代码，谢谢分享

帐号		自动登录	找回密码
密码			注册

单片机直流电机调速系统仿真+源代码

EDA365欢迎您登录！

推荐内容 /1