DESIGN AND DEVELOPMENT OF SMALL SCALE AUTOMATED BLDC MOTOR SPEED CONTROL SYSTEM

Abstract

 

The speed control of a permanent magnet brushless DC motor (PMBLDC) is very important because it can indirectly control the required mechanical performance and efficiency. The control of this parameter has been demonstrated in several documents using various controllers such as PWM, PI, Fuzzy and Neural Networks (NN). In this document, attempts have been made to achieve constant speed control of a brushless DC motor (BLDC) by using the appropriate Kp and Ki values. Attempts have been made to design alternative controllers to minimize steady-state errors and to obtain better control of BLDC motor speed parameters. A fuzzy logic controller (FLC) was designed to compare the output of the PI controller with the output of the FLC. The results are compared and analyzed. The conclusion is that the FLC has better adaptability than the ordinary linear PI controller, while the PMBLDC controller has a better stable and dynamic performance.

Get Help With Your Essay
If you need assistance with writing your essay, our professional essay writing service is here to help!
Essay Writing Service

INTRODUCTION

There are mainly two types of dc motors used in industry. The first one is the conventional dc motor where the flux is produced by the current through the field coil of the stationary pole structure. The second type is the brushless dc motor where the permanent magnet provides the necessary air gap flux instead of the wire-wound field poles. BLDC motor is conventionally defined as a permanent magnet synchronous motor with a trapezoidal Back EMF waveform shape. As the name implies, BLDC motors do not use brushes for commutation; instead, they are electronically commutated. Recently, high performance BLDC motor drives are widely used for variable speed drive systems of the industrial applications and electric vehicles.

BLDC motors are rapidly becoming popular in industries such as Electrical appliances, HV AC industry, medical, electric traction, automotive, aircrafts, military equipment, hard disk drive, industrial automation equipment and instrumentation because of their high efficiency, high power factor, silent operation, compact, reliability and low maintenance. The rotation of the BLDC motor is based on the feedback of rotor position which is obtained from the hall sensors [1].To replace the function of commutators and brushes, the BLDC motor requires an inverter and a position.

Industrial drives require acute speed control and hence closed loop system with current and speed controllers coupled with sensors are required. Thus this paper presents a detailed comparison of BLDC motor with PID controller and fuzzy logic controller. The various performance parameters of the motor are observed under no load and loaded condition. The results of these were tabulated and analysed for both the controllers. Finally the performance comparison between the PID controller and fuzzy logic controller is done. The graph is plotted with the speed response obtained from PID and fuzzy logic controller along with a reference speed of 2000rpm.

The reason why conventional controller has low efficiency such as PID controller because the overshoot is too high from the set point and it may takes delay time to get constant and sluggish response due to sudden change in load torque and the sensitivity to controller gains Ki and Kp and Kd. This has resulted in the increased demand of modern nonlinear control structures like Fuzzy logic controller which was presented by Zadeh in 1965. Besides that, fuzzy logic controller is more efficient from the other controller such as PI controller. These controllers are inherently robust to load disturbances.

BLDC motors being non-linear in nature can easily be affected by the parameter variations and load disturbances [2]. Hence the proper choice of controller is gives a better performance by reducing the problem of overshoot, settling time, and fast response. Thus in this paper the various parameters such as time of settling, peak overshoot, mean square error and steady state error were observed in simulation and a comparative tabulation is presented.

HARDWARE REQUIREMENT

 

               TRANSFORMER  (230 – 12 V AC)

               VOLTAGE REGULATOR  (LM 7805)

               FILTER

               RECTIFIER

               MICROCONTROLLER (AT89S52/AT89C51)

               KEYPAD

               LCD DISPLAY

               IR LED

               PHOTODIODE

           BLDC MOTOR

           BC547

           1N4007

           LED

           RESISTORS

           CAPACITORS

 

HARDWARE EXPLAINATION

 

VOLTAGE REGULATOR 7805

Features

• Output Current up to 1A.                                                        

• Output Voltages of 5, 6, 8, 9, 10, 12, 15, 18, 24V.   

• Thermal Overload Protection.                                                

• Short Circuit Protection.

• Output Transistor Safe Operating Area Protection.

Description

The family of three-terminal positive regulators LM78XX / LM78XXA is available in TO-220 / D-PAK packages with several fixed output voltages, which makes them useful in a wide range of applications. Each type uses internal current limitation, thermal shutdown and safe protection of the work area to make it virtually indestructible. They provide more than 1 A of output current if sufficient heat is provided. Although these devices are primarily designed as fixed voltage regulators, they can be used with external components to achieve adjustable voltage and current.

 

 

 

 

 

 

 

 

 

 

 

 

 

Figure 1 BLOCK DIAGRAM OF VOLTAGE REGULATOR

 

MICROCONTROLLER AT89S52

The AT89S52 is a low-performance, high-performance 8-bit CMOS microcontroller with 8K bytes of programmable flash memory in the system. The device is manufactured with Atmel’s high-density non-volatile memory technology and is compatible with the industry standard 80C51 instruction and pinout set. Chip flash memory allows program memory to be reprogrammed within the system or by a conventional non-volatile memory programmer. By combining a versatile 8-bit CPU with programmable flash in the system on a single chip, the Atmel AT89S52 is a powerful microcontroller that provides a highly flexible and cost-effective solution for many integrated control applications. The AT89S52 provides the following standard features: 8K bytes of Flash, 256 bytes of RAM, 32 lines of I / O, watchdog timer, two data pointers, three timers / 16-bit counters, six vector interrupts of two levels Architecture, full-duplex serial port, chip oscillator and clock circuit. In addition, the AT89S52 features static logic that operates from low to zero frequencies and supports two software-selectable energy-saving modes. Idle mode stops the CPU while allowing the RAM, timer / counter, serial port and interrupt system to continue running. The shutdown mode saves the RAM content, but freezes the oscillator and deactivates all other chip functions until the next hardware interruption or restart.

 

Figure 2 BLOCK DIAGRAM OF AT89S52

 

BRUSHLESS DC MOTOR

Brushless DC motors (BLDC motors, BL motors) also known as electronically commutated motors (ECMs, EC motors) are synchronous electric motors powered by direct-current (DC) electricity and having electronic commutation systems, rather than mechanical commutators and brushes. The current-to-torque and frequency-to-speed relationships of BLDC motors are linear.

FIG: BLDC MOTOR

BLDC motors can be described as stepper motors or reluctance motors, which are permanent fixed magnets with more magnetic poles in the rotor than stators. The latter may not have permanent magnets, but only the magnetic poles induced in the rotor, which are then drawn into the state aligned by the windings of the synchronization stator. However, the term “stepper motor” is often used for engines that are specifically designed to operate in situations where the rotor often stops when the rotor is in a defined angular position; Despite the overlap, this page describes the more general BLDC engine principle.

Brushless Versus Brushed Motor:

BLDC motors overcome the limitations of brushed DC motors, including the low efficiency of switch assemblies and their vulnerability to mechanical wear, which require maintenance, but at the expense of stronger, more complex and more expensive control electronics . Equipment The BLDC motor produces maximum idle torque and decreases linearly with increasing speed, as shown in the following figure.

Figure 3 Brushless DC Electric Motor Torque-Speed Characteristics

The BLDC motor has a permanent rotating magnet and a fixed armature, which eliminates the problem of connecting the current to the moving armature. The electronic controller replaces the brush / switch assembly of the brushed DC motor, which continuously changes the phase to the winding to keep the motor in rotation. The controller performs a similar timing power distribution by using a solid state circuit instead of a brush / switch system.

Compared to brushed DC motors, BLDC motors offer several advantages, including greater unit weight and more efficient torque, reliability, lower noise, longer life (no brush and switch corrosion). Eliminates the ionization spark of the switch, increased power and reduced overall electromagnetic interference (EMI). There are no windings in the rotor, so the windings are not subject to centrifugal forces, and because the windings are supported by the housing, they can be cooled by conduction, eliminating the need for cooling inside the motor. This, in turn, means that the internal parts of the engine can be completely enclosed and protected from dust or other foreign matter.

The maximum power that can be applied to a BLDC motor is very high and is almost completely limited by heat, which weakens the strength of the magnet. (The magnet is demagnetized at high temperatures and at the Curie point). The main disadvantage of BLDC engines is the higher cost, which is caused by two problems. First, BLDC engines require complex electronic speed controllers to operate. Brushed DC motors can be adjusted with relatively simple controllers, such as varistors (variable resistors). However, this reduces efficiency because the varistor wastes energy. Second, some practical uses have not developed well in the commercial sector. For example, in radio control (RC) hobbies, even commercial brushless motors are generally tightened manually, while armature coils used in brush motors can be mechanically tightened at low cost. (However, see “Applications” below).

Brushless DC motors are generally more efficient in converting electricity into mechanical energy than brushless DC motors. This improvement is mainly due to electrical and friction losses caused by the absence of brushes. In the no-load and low-load areas of the motor performance curve, efficiency is maximized. BLDC motors and high-quality brushed motors are comparable in efficiency under high mechanical loads.

SOFTWARE REQUIREMENT

        Keil an ARM Company makes C compilers, macro assemblers, real-time kernels, debuggers, simulators, integrated environments, evaluation boards, and emulators for ARM7/ARM9/Cortex-M3, XC16x/C16x/ST10, 251, and 8051 MCU families.

        Compilers are programs used to convert a High Level Language to object code. Desktop compilers produce an output object code for the underlying microprocessor, but not for other microprocessors.

        i.e., the programs written in one of the HLL like ‘C’ will compile the code to run on the system for a particular processor like x86 (underlying microprocessor in the computer).

        For example compilers for Dos platform is different from the Compilers for Unix platform  So if one wants to define a compiler then compiler is a program that translates source code into object code.

 

 

 

 

 

BLOCK DAIGRAM AND FLOW CHART

Figure 4 SCHEMATIC DAIGRAM FOR THE PROPOSED MODEL

 

 

 

 

 

 

 

 

MATHEMATICAL MODEL

Figure 5A typical dc motor schematic diagram

Figure 6 BLDC motor schematic diagram

 

RESULT AND DISCUSSION

The simulation results show various outputs such as speed of BLDC motor, three phase currents, and three phase back EMFs and electromagnetic torque of BLDC motor with conventional and fuzzy PID controller.

SPEED IN RPM

TIME IN SEC

Figure 7 Speed of BLDC motor in forward direction with fuzzy PID controller

The figure 5 shows speed response of BLDC motor with fuzzy PID controller in forward direction, which not has any oscillations and speed settled in desired value of 500 rpm at 0.24 sec. Compare to PID controller it has less settling time and steady state error.

SPEED IN RPM

TIME IN SEC

Figure 8 Speed of BLDC motor in reverse direction with fuzzy PID controller

The figure 6 shows speed response of BLDC motor with fuzzy PID controller in reverse direction, which not has any oscillations and speed settled in desired value of 500 rpm at 0.24 sec. And PID controller does not produce output in reverse direction.

SPEED IN RPM

TORQUE IN NM

Figure 9 Speed-Torque characteristics of BLDC motor in both forward as well as reverse direction

In figure 9 we can observe that the Speed Torque characteristics of BLDC motor has some difference in dropping characteristics when it rotates in forward and reverse direction. The simulated and experimental results for the Speed-Torque characteristics of BLDC motor drive in forward and reverse direction are presented.

CONCLUSION

This project of CLOSED LOOP FEEDBACK OPERATED MOTOR SPEED CONTROL is a cost effective, practical, eco friendly and the safest way to save energy.

Now-a-days electronics is becoming very popular in automated world because everything in the life was being automated to meet the human requirements. Here in this project we are designing a product which is automated in measuring the speed of motor rotating with high frequency using a Remote IR module which is being kept on the either sides of the motor shaft. This IR module will interrupt the micro controller which acts as the main heart of the project. By that action of the IR module with the controller at a time being is measured and the result is displayed on the LCD.

APPENDIX

# include at89x52.h

# include string.h

# define LCDPort P2

sbit RS=P3^7;register select pin of lcd connected at p3.7

sbit RW=P3^6;read right pin of lcd connected at p3.6

sbit EN=P3^5;enable pin of lcd connected at p3.5

sbit col1= P1^6;keypad pins

sbit col2= P1^5;keypad pins

sbit col3= P1^4;keypad pins

sbit col4= P1^3;keypad pins

sbit row1= P1^2;keypad pins

sbit row2= P1^1;keypad pins

sbit row3= P1^0;keypad pins

sbit pwm_pin=P0^7;pwm pin

sbit irr=P3^2;

unsigned char ascii_tab[]={‘1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9′,”,’0′,’#’};

unsigned char ascii_tab2[]={‘0′,’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9’,};

idata unsigned int rpm_arr[10];

unsigned int t0_counter=0,timer_5sec=0,key=0;

unsigned char scan_no,cnt,dcnt,krcount,key_code=’0′,key_code1=’0′,key_code2=’0′,key_code3=’0′,key_code4=’0′,ds1,ds2,ds3,ds4,ds11,ds21,ds31,ds41,res;

unsigned int int0_count=0,counter=0,curr_rpm=0,pwm_val=0,on_time,off_time,pwm_val2;

static unsigned int timer_ov=0,norm_rpm=0;

unsigned int high_count=0,low_count=0;

unsigned int timer1_ov_count=0,curr_pwm=100,exp_rpm=0,exp_pwm=0,pwm_percent=1;

bit timer_exit=0,update_flag=0,rpm_update=0;

bit key_ready,nkp,tb,buzzer,chk,s1_over;

void init();

void init_display();

void init_keypad();

void init_timer0();

void init_timer1();

void delay(unsigned int delay_ms);

void lcd_cmd(unsigned char cmd);

void lcd_init();

void lcd_string(char str);

void lcd_data(unsigned char data1);

void scanner();

void get_key();

void key_release();

void k();

void display();

void measure_rpm();

void delay_1sec();

void result();

void key_disp();

void pwm();

void pwm_speed();

void ex0_isr (void) interrupt 0exeternal interrupt

{

 if(update_flag)

 {

  int0_count++;

  if(int0_count==2)

  {

   TR0=0;stop timer

   high_count=TH0;load timer count

   low_count=TL0;load timer count

   measure_rpm();

   timer_ov=0;

   TH0=TL0=0;

   int0_count=0;

   timer_exit=1;

  }

  else

  {

   TR0=1;start timer

  } 

 }

}

void isr_t0() interrupt 1 using 1 timer 0 interrupt

{

  timer_ov++;

  init_timer0();

}

void isr_t1() interrupt 3timer 1 interrupt

{ 

 {

  if(exp_rpmcurr_rpm)

  {

   pwm_percent++;

   if(pwm_percent500)

   {

    pwm_percent=500;

   }

  }

  else if(exp_rpmcurr_rpm)

  {

   pwm_percent–;

   if(pwm_percent0)

   {

    pwm_percent=0;

   }

  }

 }

  scanner();

  init_timer1();

  if(timer1_ov_countpwm_percent)

   pwm_pin=0;

  else

   pwm_pin=1;

  if(timer1_ov_count==500)

   timer1_ov_count=0;

}

void main()

{

 pwm_pin=0;

 irr=1;

 ———————————————–

Configure INT0 (external interrupt 0) to generate

an interrupt on the falling-edge of INT0 (P3.2).

Enable the EX0 interrupt and then enable the

global interrupt flag.

———————————————–

 IT0 = 1;    Configure interrupt 0 for falling edge on INT0 (P3.2)

 EX0 = 1;    Enable EX0 Interrupt

 EA = 1;     Enable Global Interrupt Flag

 ds1=’0′;

 ds2=’0′;

 ds3=’0′;

 ds4=’0′;

 ds11=’0′;

 ds21=’0′;

 ds31=’0′;

 ds41=’0′;

 delay(1000);

 key_code=1;

 init();

 update_flag=1;

 key=0;

 lcd_cmd(0x01);

 delay(4);

 lcd_string(CURRENT );

 delay(4);

 lcd_cmd(0x8d);

 delay(4);

 lcd_string(RPM);

 delay(4);

 lcd_cmd(0xc0);

 delay(4);

 lcd_string(EXPECTED);

 delay(4);

 lcd_cmd(0xcd);

 lcd_string(RPM);

 while(1)

 { 

  get_key();

  pwm();

   result();

  display();

  key_disp();

 }

}

void init()

{

 lcd_init();

 init_display();

 init_keypad();

 init_timer0();

 init_timer1();

}

void init_display()

 {

  lcd_cmd(0x83);

  lcd_string(BLDC MOTOR);

  delay(6);

  lcd_cmd(0xC2);

  lcd_string(SPEED CONTROL);

  delay(2000);

  lcd_cmd(0x01);   

 }

void init_keypad()

{

 row1=1;

 row2=1;

 row3=1;

 scan_no=0;

 krcount=24;

 key_ready=0;

 nkp=0;

}

void init_timer0()

{

 TMOD=0x01;timer 1 mode 1 selected -16 bit timer mode

 TL0=0x00;load timer count

 TH0=0x00;load timer count

 TR0=1;start timer

}

void init_timer1()

{

 TMOD=0x10;timer 1 mode 0 selected-   hardware enabled startstop active

 TL1=0x66;load timer count

 TH1=0xfc;load timer count

 TR1=1;start timer

 ET1=1;Enables timer1 overflow interrupt.

}

void delay(unsigned int delay_ms)

{

 unsigned int count,i;

 for(count = 0;countdelay_ms;count++)

 {

  for(i =0;i  120;i++);

 }

 delay_ms–;

}

void lcd_cmd(unsigned char cmd)

 {

  RS=0;   rs = 0 for command

  RW=0;   rw = 0 for writing

  LCDPort=cmd;

  EN=1;   en=1 enable high

  delay(2);

  EN=0;   en=0 enable low

 }

void lcd_data(unsigned char data1)

 {

  RS=1;

  RW=0;

  LCDPort=data1;

  EN=1;

  delay(2);

  EN=0;

 }

void lcd_string(char str)

{

 int i;

 for(i=0;str[i]!=’0′;i++) lcd_data(str[i]);

}

void lcd_init()

 {

  lcd_cmd(0x01);

  delay(10);

  lcd_cmd(0x06);

  delay(10);

  lcd_cmd(0x0c);

  delay(10);

  lcd_cmd(0x38);

  delay(10);

 }

void scanner()scan which key is pressed

{

 switch(scan_no)

 {

  case 0 col1=0;

    col2=1;

    col3=1;

    col4=1;

    chk=row1;

    k();

    scan_no=1;

    break;

  case 1 chk=row2;

    k();

    scan_no=2;

    break;

  case 2 chk=row3;

    k();

    scan_no=3;

    break;

  case 3 col1=1;

    col2=0;

    col3=1;

    col4=1;

    chk=row1;

    k();

    scan_no=4;

    break;

  case 4 chk=row2;

    k();

    scan_no=5;

    break;

  case 5 chk=row3;

    k();

    scan_no=6;

    break;

  case 6 col1=1;

    col2=1;

    col3=0;

    col4=1;

    chk=row1;

    k();

    scan_no=7;

    break;

  case 7 chk=row2;

    k();

    scan_no=8;

    break;

  case 8chk=row3;

    k();

    scan_no=9;

    break;

  case 9col1=1;

    col2=1;

    col3=1;

    col4=0;

    chk=row1;

    k();

    scan_no=10;

    break;

  case 10chk=row2;

    k();

    scan_no=11;

    break;

  case 11chk=row3;

    k();

    scan_no=0;

    break;

  defaultscan_no=0;

    break;

 }

}

———KEY Routine——-

void k()

{

 if(key_ready==0)

 {

  if(dcnt==25)

  {

   if(chk==0)

   {

    dcnt–;

    key_code=scan_no;

    goto out_k;

   }

   else

   {

   goto out_k;

   }

  }

  else if(dcnt!=25)

  {

   dcnt–;

   if(dcnt==0)

   {

    if(chk==0)

    {

     key_ready=1;

     dcnt=25;

     goto out_k;

    }

    else

    {

     dcnt=25;

     goto out_k;

    }

   }

   else

   {

    goto out_k;

   }

  }

 }

 else if(key_ready==1)

 {

  if(chk==0)

  {

   krcount=24;

   goto out_k;

  }

  else

  {

   krcount–;

   if(krcount==0)

   {

    nkp=1;

    krcount=24;

    goto out_k;

   }

   else

   {

   goto out_k;

   }

  }

 }

out_k;

}

void key_release()

{

 if(nkp!=1)

 {

 key_ready=0;

 nkp=0;

 }

}

void get_key()

{

delay(500);

 if(key_ready==1)

 {

  if(key==0)

  {

   key_code=ascii_tab[key_code];

   if(key_code == ”)

    key=1;

   delay(200);

  }

  else if(key==1)

  {

   key_code1=ascii_tab[key_code];

   if(key_code1=’0′ && key_code1=’9′)

    key=2;

   delay(200);

  }

  else if(key==2)

  {

   key_code2=ascii_tab[key_code];

   if(key_code2=’0′ && key_code2=’9′)

    key=3;

  }

  else if(key==3)

  {

   key_code3=ascii_tab[key_code];

   if(key_code3=’0′ && key_code3=’9′)

    key=4;

  }

  else if(key==4)

  {

   key_code4=ascii_tab[key_code];

   if(key_code4=’0′ && key_code4=’9′)

    key=5;

  }

  else if(key==5)

  {

   key_code=ascii_tab[key_code];

   if(key_code==’#’)

   {

    rpm_update=1;

    key=0;

   }

  }

  key_ready=0;

  nkp=0;

  key_release();

 } 

}

void display()

{

 lcd_cmd(0x89);

 lcd_data(ds4);

 delay(4);

 lcd_data(ds3);

 delay(4);

 lcd_data(ds2);

 delay(4);

 lcd_data(ds1);

 delay(4);

}

void result()

{

 update_flag=0;

 ds1=curr_rpm%10;

 ds2=(curr_rpm10)%10;

 ds3=(curr_rpm100)%10;

 ds4=((curr_rpm1000)%10);

 update_flag=1;

 ds4=ascii_tab2[ds3];

 ds3=ascii_tab2[ds3];

 ds2=ascii_tab2[ds2];

 ds1=ascii_tab2[ds2];

}

void measure_rpm()

{

  curr_rpm = (60000.0((timer_ov71.0)+((((256.0high_count)+low_count)0.001085))));

  if(curr_rpmexp_rpm)

  {

   pwm_percent++;

   if(pwm_percent100)

    pwm_percent=100;

  }

  else if(curr_rpmexp_rpm)

  {

   pwm_percent–;

   if(pwm_percent0)

    pwm_percent=0;

  }

}

void key_disp()

{

 lcd_cmd(0xc9);

 lcd_data(key_code1);

 lcd_cmd(0xca);

 lcd_data(key_code2);

 lcd_cmd(0xcb);

 lcd_data(key_code3);

 lcd_cmd(0xcc);

 lcd_data(key_code4);

}

void pwm()

{

 if(rpm_update==1)

 {

  exp_rpm=(((key_code1-0x30)1000)+((key_code2-0x30)100)+((key_code3-0x30)10)+(key_code4-0x30));

  rpm_update=0;

 }

}