Compensating

the dead time of the

voltage inverters

with the ADMCF32X

ANF32X-50Table of Contents SUMMARY (3)

1DEAD TIME EFFECTS AND THEIR COMPENSATION (3)

2IMPLEMENTATION OF THE FEED FORWARD DEAD TIME COMPENSATION..5 2.1Using the dt_comp routines (5)

2.2Using the dt_comp routine (6)

2.3The program code (7)

3EXAMPLE: TESTING THE VALIDITY OF THE FEED FORWARD DEAD TIME COMPENSATION (7)

3.1The construction of an inverter (7)

3.2The software program used to test the feed forward dead time compensation (8)

3.3The main include file: main.h (11)

3.4The program offset.dsp and its header offset.h (11)

3.5Experimental results (14)

4REFERENCES (16)Summary

Due to the finite switching time, in order to prevent the appearance of short circuits, the power devices of an inverter must be commanded introducing a delay between their active times. This delay, called dead time because in this period no power device is active, introduces small voltage errors, which are sufficient to produce distorted motor currents, oscillations of the motor torque and therefore even the motor controllability may be lost [1].

This paper presents one method to compensate the effects of the dead time, the experimental hardware on which this method was tested and the assembly program associated with it.

1 Dead Time effects and their compensation

Consider a voltage inverter with a motor connected at its output terminals (Figure 1).

V

d

Figure 1: Voltage source inverter

The effects of the dead time may be examined by considering only the first phase of the inverter. On this

v presented in Figure 2a. The signals used to phase it is desired to obtain the reference PWM signal *

1

command the power devices are assumed to be active HIGH, which means that when they are HIGH, the power devices conduct (Figures 2b and 2c). These are the type of signals the DSP motor controllers ADMCF32X use. The output signal obtained at the motor terminal depends on the sense of the current flowing in this phase:

In the case of the current flowing from inverter to the motor (assumed positive sense), when T2 conducts,

v is 0. During the dead time period, when both the phase terminal is linked to the GND and the voltage

1

power devices are turned OFF, the current continues to flow into the motor using the reverse recovery v will continue to be 0. When the upper power device T1 conducts, the phase terminal is diode D2, so

1

connected to d V and 1v is equal to d V . During the second half cycle, the phenomenon repeats itself symmetrically. The final behaviour of 1v is presented in Figure 2d. It may be observed that the average value of 1v is less than the reference value by an amount determined by the dead time:

d s

V T DT v v ⋅−=*11 (1)

*1v 1

T 2

T 0 11≥s i when

v 0 11v a)

b)

c)d)

e)

d

V d

V Figure 2: The influence of the dead time over the output phase voltage

In the case of the current flowing from the motor to the inverter, when T2 conducts, the phase terminal is linked to the GND and the voltage 1v is 0. During the dead time period, the current continues to flow from the motor using the reverse recovery diode D1, so 1v will become equal to d V . When the upper power device T1 conducts, the phase terminal is connected to d V and 1v will continue to be equal to d V . During the second half, the phenomenon repeats itself symmetrically. The final behaviour of 1v is presented in

Figure 2e. It may be observed that the average value of 1v is greater than the reference value by an amount determined by the dead time:

d s V T DT v v ⋅+=*11(2)

Equations (1) and (2) provide the first method to compensate for the dead time: the feed-forward compensation. In relation of the current sense, the inverter phase will be commanded with a reference

voltage **1v such that the voltage 1v at the inverter terminal will become equal with the reference voltage *1v :

d s

V T DT v v ⋅+=*1**1when 0≥i (3)d s V T DT v v ⋅−=*1**1when 0These expressions mean that when the phase current is positive, the duty cycle *1T correspondent to *1

v has to be increased by the dead time and when the phase current is negative, the duty cycle has to be decreased by the dead time. The only drawback of this method appears when the current changes its sign,because this moment cannot be foreseen. It is easily seen that when the sign is not correctly applied, an error of two times the dead time is introduced.

Another method to compensate the dead time is the following: The actual inverter voltages are measured

on every phase. The compensation is done adding to the reference phase voltage *1

v a term proportional to the voltage error on that phase:

)]()([)1()1(1*1*1**1k v k v K k v k v −⋅++=+(4)

where:

-)1(**1+k v is the voltage which will be commanded on the first inverter phase;

-)1(*

1+k v is the reference voltage which would have been commanded if the dead time compensation had not been considered;

-K is the gain of the compensator, usually less than or equal to 1;

-)(*1k v is the reference voltage which would have been commanded during the previous PWM cycle if the dead time compensation had not been considered;

-)(1k v is the inverter phase voltage measured during the previous PWM cycle.

The drawback of this method is that all the inverter phase voltages have to be measured. It is possible to measure only two inverter phases if the PWM modulation is space vector type or sinusoidal.2 Implementation of the feed forward dead time compensation

2.1 Using the dt_comp routines

The routines are developed as an easy-to-use library, which has to be linked to the user’s application. The library consists of two files. The file “dt_comp.dsp” contains the assembly code of the subroutines. The

block has to be compiled and then linked to an application. The user has to include the header file dt_comp.h, which provides the function-like calls to the subroutines. The example file in Section 3 will demonstrate the usage of all the routines.Operation Usage

Compute On-times compensating the dead time

DeadTime_Comp (StatorCurrent_struct, Dutycycles_struct)Table 1 Implemented routine

The input vector StatorCurrents_struct consists of three elements, the three inverter phase currents.Because their sum is always zero, only two of them need to be measured. They have to be scaled because the DSP uses fixed point formats. The scaling factor is max 2I ⋅, where max I represents the maximum current which may be placed at the input pin of the A/D converter. The 2 factor is used to prevent overflows when the currents are used in arithmetical operations.

The vector Dutycycles_struct is an input and also an output: It represents the duty cycles for each phase,previously computed by the PWM modulator. After the compensation, they represent the duty cycles effectively commanded to the inverter. Their values have to be between 0 and PWMTM, the number which controls the PWM switching frequency.

DeadTime_comp represents a macro, which must be introduced into the program code if the dead time compensation is desired. The format of inputs and outputs are explained in more detail in the next section.The routines do not require any configuration constants from the main include-file “main.h” that comes with every application note. For more information about the general structure of the application notes and including libraries into user applications refer to the Library Documentation File. Section 2.2 shows an example of usage of this library. In the following sections each routine is explained in detail with the relevant segments of code which is found in either “dt_comp.h” or “dt_comp.dsp”. For more information see the comments in those files.

2.2 Using the dt_comp routine

The macro listed in the Table 1 is based on a subroutine called DeadTime_Comp _. It is described in detail in the next section. The following table gives an overview of what DSP registers are used in this macro:

Table2. DSP core registers used in the macro

1

^vector stands for ‘address of vector’.2 N/A: The output values are stored in the output vector in the Data memory. No DSP core register is used.

This macro has to be placed in the main program after the PWM reference duty cycles are computed, but prior to the program that saves them into the duty cycle registers PWMCHA, PWMCHB, PWMCHC.

2.3 The program code

The following code contained in the file dt_comp.dsp describes the routine DeadTime_Comp _mentioned in the previous section.

The routine is organised as a loop managed by the loop counter cntr. At each iteration, one phase current from the buffer StatorCurrents_struct is tested and the compensation is done function of its sign. In the end, the new duty cycle number is tested to ensure it is positive and less than the maximum admissible value, PWMTM. The last instruction saves the number back into the buffer Dutycycles_struct.DeadTime_Comp_:

AY0 = DM(PWMDT); { dead time normalized }

AY1 = dm(PWMTM);

CNTR = 3;

do dead_loop until ce;

ax0 = DM(I1, M1); { ax0 = Isk, k=1,2,3 }

mr1 = DM(I2, M3); { load Ta, Tb, Tc }

AR = MR1 + AY0;

none = pass ax0; {chek sign of the currents }

IF LT AR = MR1 - AY0;

none = pass AR;

if lt AR = PASS 0; { no negative values admitted}

af = AR - AY1;

if gt ar = pass ay1; { protection against overflows}

dead_loop:

DM(I2, M2) = ar;

rts;

3 Example: Testing the validity of the feed forward dead time

compensation

3.1 The construction of the inverter

The proposed compensation method was implemented on the ADMCF328 Processor Board mounted on an ADMC Connector Board . As inverter power part an evaluation platform produced by International Rectifier, IRPT2056D Driver-Plus Board was used. It is a three phase 230VAC 3HP board and it integrates all the processing components needed for a 3 HP motor drive. It is equipped with an IRPT2056A IGBT power module and an IR2133J driver. A PWM isolation board linked the Connector Board to the Power Board. This board produces an electric isolation between the digital part and the inverter power part and also inverts the signals used to drive the power devices (74HC240). This inversion is necessary because the signals used by the driver IR2133J are active LOW and the PWM outputs of the ADMCF328 are active HIGH. The inverter is driving an induction motor with the following characteristics: .13HP, 230V, 60Hz, 1725rpm, produced by Baldor . Because the power part is supplied with 110V, the maximum frequency the motor may be run in the constant torque regime is:c

f 32

1106032230⋅=⋅Hz f c 7.28230

60110=⋅=

Because the compensation needs the value of the inverter phase currents, two of them were sensed using current transducers HA 10-NP produced by LEM. They are capable to measure up to 20A and this value is used to scale down the measured values: A I 20max =. Also, an operational amplifier LM348 is used to obtain the signal into the range of A/D converter of ADMCF328: 0.3V ÷3.5V. On the ADMCF328Processor Board there are 5KHz filters that have an anti-aliasing role.

A block structure of the inverter is presented in Figure 3.

Figure 3. Inverter Block structure

3.2 The software program used to test the feed forward dead time compensation The purpose of this program is to demonstrate the improvement offered by the feed forward dead time compensation. It reads two motor currents, commands the motor to run at 14Hz, half of the cut frequency c f and compensates for the dead time.

The file main.dsp contains the root program. The batch file build.bat compiles every file of the project,links them together and builds the executable file main.exe . It may be applied either within DOS prompt or clicking on it from Windows Explorer. Main.exe may be run on the Motion Control Debugger.

A brief description of the program will be given in the following:

Start of code - declaring start location in the flash memory sector 2. Because the Boot From Flash Bit is set, the program counter will jump at 0x2200 after a reset and will begin execution from this point.

.MODULE/RAM/SEG=USERFLASH1/ABS=0x2200 Main_Program;

Next, the general systems constants and PWM configuration constants (main.h – see the next section) are included. Also included are the PWM library 2, the DAC interface 3 and the space vector modulation 4 module definitions. The header file offset.h declares some macros used to measure the offset introduced by the current transducers and selfcal.h declares the macros used to calibrate the ADMCF328 A/D converter.

{**************************************************************************************** Include General System Parameters and Libraries *

2

see AN331-03: Three-Phase Sine-Wave Generation using the PWM Unit of the ADMC3313

see AN331-06: Using the Serial Digital to Analog Converter of the ADMC Connector Board 4 see AN331-17: Implementing Space Vector Modulation with the ADMC331

#include ;

#include ;

#include ;

#include ;

#include ;

#include ;

#include ;

#include ; { Application Specific Module}

#include ;

#include ;

#include ;

#include ;

#include ;

Constants used in this program

{*************************************************************************************** * Constants Defined in the Module * ***************************************************************************************} .CONST CUT_FREQ = 28; {the cutting frequency of the tested motor} .CONST Delta = 32768*2*CUT_FREQ/PWM_freq; {the increment of the angle}

.CONST TwoPiOverThree= 0xffff / 3; { Hex equivalent of 2pi/3 }

.CONST ALLOFF = 0x3F; { Used to disable IGBTies into PWMSEG }

.CONST Half_PWMTM = 1000*Cry_clock/PWM_freq/2;

Here is where all the vectors for the program are declared. The buffer represents the three stator currents. The PWM duty cycles are stored in the buffer Dutycycles_struct. It may be observed the .INIT directives are no more used because the assembly program is saved in the flash memory. It has to be done an assembly program to initialise the variables in the data memory. First the macro InitDataMemory writes 0 in every cell of the memory segment available to the user USER_DM and then the macro InitDM_Variables initialises the variables that are not equal to 0.

{*************************************************************************************** * Local Variables Defined in this Module * ***************************************************************************************} .VAR/DM/RAM/SEG=USER_DM Theta; { Current angle }

.VAR/DM/RAM/SEG=USER_DM Vdq_ref[2]; { rotor ref.frame }

.VAR/DM/RAM/CIRC/SEG=USER_DM Valphabeta_ref[2];{ alphabeta frame }

.VAR/RAM/DM/SEG=USER_DM OnTime_struct[1*4];

.VAR/RAM/DM/SEG=USER_DM Dutycycles_struct[1*3];

.VAR/DM/RAM/SEG=USER_DM VrefA; { Voltage demands }

.VAR/DM/RAM/SEG=USER_DM VrefB;

.VAR/DM/RAM/SEG=USER_DM VrefC;

.VAR/DM/RAM/SEG=USER_DM StatorCurrents_struct[1*3]; { stator currents }

.VAR/DM/RAM/SEG=USER_DM Is1Offset[1];

.VAR/DM/RAM/SEG=USER_DM Is2Offset[1];

.VAR/DM/RAM/SEG=USER_DM TestVar1[1];

.VAR/DM/RAM/SEG=USER_DM TestVar2[1];

When the program begins, the wait states for the external memory are initialised with 0 because the flash memory is configured as external memory and the PWM output signals are disabled. Then, the following tasks are done: the management of the Boot-From-Flash Bit, the initialisation of the data memory, the power module is reset and the PWM block is set up to generate interrupts every 100µsec (see main.h in the next section). The auxiliary PWM outputs are initialised because after some filtering they may be used as D/A converters and then there is unmasked the IRQ2 interrupt (the interrupt which manages the peripheral interrupts on ADMCF328). The main loop just waits for interrupts.

{********************************************************************************************} { Start of program code } {********************************************************************************************} Startup:

DIS M_MODE, DIS AR_SAT;

ar=dm(SYSCNTL);

ay0=0xFF80;{Zero PM wait states}

ar=ar and ay0;

dm(SYSCNTL)=ar;ar=dm(MEMWAIT);

ar=ar and 0x8000; {Zero DM wait states}

dm(MEMWAIT)=ar;

Write_DM(PWMSEG, ALLOFF); { the IGBTies are disabled }

FLASH_erase_PIO(6); { Select PIO6 as clearing PIO Remember that sport1 is }

{ muxed with the PIO-lines If the bit is high Clear }

{ Memory and Boot from Flash bit }

{the data memory locations has to be initialized when the program is run only in the flash memory}

InitDataMemory; {the data memory is initialized with 0, flash_ct.h} InitDM_Variables; {every variable is initialized, main.h}

IR_reset_PIOx; { Reset PowIRTrain Module using PIO4}

PWM_Init(PWMSYNC_ISR, PWMTRIP_ISR);

Write_AUXDAC_Init; { Initialize the AUX0,1 as DAC outputs}

IFC = 0x80; { Clear any pending IRQ2 inter.}

ay0 = 0x200; { unmask irq2 interrupts.}

ar = IMASK;

ar = ar or ay0;

IMASK = ar; { IRQ2 ints fully enabled here}

ADC_Init; { ADC Counter will Operate at the DSP CLKOUT Frequency } AutoCal_INIT; { Initialize the Auto Calibration Routine }

Offset_Init; { offset.h }

Main: { Wait for interrupt to occur}

jump Main;

During the PWM_SYNC interrupt there are executed some routines which determine the internal offset of the A/D converter1, the external offsets introduced by the current transducers and the measurement of the currents. The successive routines generate three PWM signals of 14Hz obtained applying a continuous space vector modulation2. The dead time compensation is placed at the end of this block. Finally, the signals that will be provided to the D/A converter are computed.

{********************************************************************************************} { PWM Interrupt Service Routine

}

{********************************************************************************************} PWMSYNC_ISR:

ENA SEC_REG;

Auto_Calibrate;

OffsetDetermination(ADC1, ADC2, Is1Offset, Is2Offset); { offset.h }

ReadCurrents(Is1Offset, Is2Offset, StatorCurrents_struct, ADC1, ADC2); { offset.h } ar = DM (AD_IN );

mr = 0; {Clear mr }

mr1 = dm(Theta); {Preload Theta }

my0 = Delta;

mr = mr + ar*my0 (SS); {Compute new angle & store}

dm(Theta) = mr1;

DM(Vdq_ref )= ar; {Set constant Vdq reference (AD_IN,0)}

ar = pass 0;

DM(Vdq_ref+1)= ar;

refframe_Set_DAG_registers_for_transformations;

refframe_Forward_Park_angle(Vdq_ref,Valphabeta_ref,mr1);

{generate Vreference in alpha-beta frame }

SVPWM_Calc_Ontimes(Valphabeta_ref, OnTime_struct); { use SVPWM routines } SVPWM_Calc_Dutycycles(OnTime_struct, Dutycycles_struct);

DeadTime_Comp(StatorCurrents_struct, Dutycycles_struct);

SVPWM_Update_DutyCycles(Dutycycles_struct);

{********************************************************************************************} { Use the Write_AUXPWM macro to plot on AUXDAC for debugging }

{********************************************************************************************} AX0 = dm(Dutycycles_struct);

AY0 = Half_PWMTM;

1 See ANF32X-05: ADC-system on the ADMCF32X.

2 See ANF32X-17: Implementing Space Vector Modulation with ADMCF32XAR = AX0 - AY0;

MY0 = 0x41; {2/PWMTM=2/1000*2^15/2^7*2^15}

MR = AR * MY0 (SS);

SR = ASHIFT MR1 BY 7 (HI);

SR = SR OR LSHIFT MR0 BY 7 (LO);

dm(TestVar1) = SR1;

Write_AUXPWM(AUXCH0,TestVar1);

MR1 = dm(StatorCurrents_struct);

SR = ASHIFT MR1 BY 4 (HI); {2*Imax/2.5A=16=2^4}

dm(TestVar2) = SR1;

Write_AUXPWM(AUXCH1,TestVar2);

RTI;

3.3 The main include file: main.h

This file contains the definitions of ADMCF32X constants, general-purpose macros, the configuration parameters of the system and library routines. It should be included in every application. For more information refer to the Library Documentation File.

This file is mostly self-explaining. As already mentioned, the dt_comp library does not require any configuration parameters. The following table presents the parameters used to initialise the PWM block .It may be emphasized the dead time period set at 6µsec, a large value for the power devices used on the IRPT2056D.

{ Library: PWM block }

{ file : PWMF32X.dsp }

{ Application Note: Usage of the ADMCF32X Pulse Width Modulation Bloc }

.CONST PWM_freq = 10000;{Desired PWM switching frequency [Hz] }

.CONST PWM_deadtime = 6000; {Desired deadtime [nsec]}

.CONST PWM_minpulse = 1000; {Desired minimal pulse time [nsec] }

.CONST PWM_syncpulse = 1540; {Desired sync pulse time [nsec] } There is also declared a macro InitDM_Variables which initialises the variables that are not equal to 0.

{*************************************************************************************** * Type: Macro * * Call: Initialize the variables with values that are not equal with 0 * * -it has the role the .INIT declarations had in the other DSPies with only RAM * * Inputs :None * * Ouputs :None * * Modified:AR * ***************************************************************************************} .MACRO InitDM_Variables;

Write_DM(AD_IN, 0x3A0A); {initialize AD_IN with 0.906/2 }

.ENDMACRO;

3.4 The program offset.dsp and its header offset.h

The current transducers introduce an offset that has to be evaluated, otherwise the sign of the currents would be determined with large errors. These errors would definitely compromise the dead time compensation. For this reason, at the beginning of the program, for a certain number of PWM cycles (in this particular case 128, but may be more or less depending of the system) the A/D channels corresponding to the two phase currents, V1 and V2 are measured. The average of all measurements constitutes the offset of that current. Of course, this procedure may be applied to every channel, if the signal is zero at the beginning of the program.

The header file offset.h contains the macros that are used during this process. Generally, they call subroutines presented in the file offset.dsp.

This file begins declaring the variables OffsetCounter, TempOffset1 and TempOffset2 used in these routines.

{*************************************************************************************** * Global Variables Defined in this Module * ***************************************************************************************} .VAR/DM/RAM/SEG=USER_DM OffsetCounter[1];.GLOBAL OffsetCounter;

.VAR/DM/RAM/CIRC/SEG=USER_DM TempOffset1[2];

.GLOBAL TempOffset1;

.VAR/DM/RAM/CIRC/SEG=USER_DM TempOffset2[2];

.GLOBAL TempOffset2;

The subroutine Offset_Init_ initialises the variables used to evaluate the offsets of the current transducers. OffsetCounter is set to 128 because the offsets are considered the average of 128 measurements.

{*************************************************************************************

* Type: Routine *

* Call: Call Offset_Init_; *

* This subroutine initializes the variables initializes variables used to *

* evaluate the offsets of the current sensors *

* Inputs : None *

* Ouputs :None *

* Modified: AR *

**************************************************************************************}

Offset_Init_:

AR = Offset_Average;

dm(OffsetCounter) = AR;

AR = 0x0;

dm(TempOffset1) = AR;

dm(TempOffset1+1) = AR;

dm(TempOffset2) = AR;

dm(TempOffset2+1) = AR;

rts;

The subroutine EvaluateIs_offset_ computes the average of the measurements of a particular A/D channel.

{*************************************************************************************** * Type: Routine * * Call: Call EvaluateIs_offset_; * * This subroutine computes the average of the measurements of one A/D channel * * Inputs : AR = the lecture of the A/D channel * * I1 = placed at the begining of the buffer which is averaged * * M1 = 0, L1 = 0 * * Ouputs :None * * Modified:AY1, AY0, AR, SR, AX0 * ***************************************************************************************} EvaluateIs_offset_:

AY1 = dm(I1, M1);

AY0 = dm(I1, M1);

AR = 0x4000 - AR;

SR = ASHIFT AR BY -7 (HI);

AR = SR0 + AY0;

AX0 = AR, AR = SR1 + AY1 + C;

dm(I1, M1) = AR;

dm(I1, M1) = AX0;

RTS;

buffers and then calls the subroutine Offset_Init_ from offset.dsp.

{*************************************************************************************** * Type: Macro * * Call: Offset_Init; * * This macro initializes variables used to evaluate the offsets of the current sensors * * Input: none * * Output: none * * Modified: AR * ***************************************************************************************} .MACRO Offset_Init;

CALL Offset_Init_;

.ENDMACRO;

The macro EvaluateIs_offset reads one A/D channel and computes the average offset of that channel calling the subroutine EvaluateIs_offset_.

{*************************************************************************************** * Type: Macro *

* Call: EvaluateIs_offset; * * Routine to compute the offset of one phase * * Input: %0=the targeted AD channel * * %1=the offset structure dedicated to the phase * * %1=most significant word * * %1+1=less significant word * * Output: Current Offset structure * * Modified: * ***************************************************************************************} .MACRO EvaluateIs_offset(%0, %1);

ADC_Read(%0);

I1 = ^%1;

M1 = 1;

L1 = %%1;

CALL EvaluateIs_offset_;

.ENDMACRO;

The macro OffsetDetermination computes the offsets of the both A/D channels that measure the phase currents.

{*************************************************************************************** * Type: Macro * * Call: OffsetDetermination * * Routine to compute the offsets introduced by the current sensors * * Input: %0=ADC1 * * %1=ADC2 * * %2=Is1Offset * * %3=Is2Offset * * Output: Current Offsets structure * * Modified: * ***************************************************************************************} .MACRO OffsetDetermination(%0, %1, %2, %3);

AY0 = dm(OffsetCounter);

AR = AY0 - 1;

IF LT JUMP SaveOffsets;

dm(OffsetCounter) = AR;

EvaluateIs_offset(%0, TempOffset1);

EvaluateIs_offset(%1, TempOffset2);

RTI;

SaveOffsets:

AF = AR + 1;

IF NE JUMP ExitOffsetDet;

dm(OffsetCounter) = AR;

AR = dm(TempOffset1);

dm(%2) = AR;

AR = dm(TempOffset2);

dm(%3) = AR;

ExitOffsetDet:

.ENDMACRO;

The macro ReadCurrents reads the two phase currents, corrects them with the offset and finally computes the third phase current. It may be noted that the output of the A/D converter is always a positive number. Because of the presence of an inverting operational amplifier in the hardware, in order to obtain values between –1/2 and +1/2

2I⋅) the outputs of the A/D converter have to be offset by 1/2 (in fixed point the currents are scaled by max

(0x4000).

{*************************************************************************************** * Type: Macro * * Call: ReadCurrents; * * This macro reads ADC1(Is1), ADC2(Is2) and then evaluates Is1, Is2 and Is3 * * Input: %0 = offset of the first phase current * * %1 = offset of the second phase current * * %2 = the buffer of the 3 phase currents * * %3 = ADC1 * * %4 = ADC2 * * Output: none * * Modified: AY0, AR, MY0, MR, SR ,AF * ***************************************************************************************} .MACRO ReadCurrents(%0, %1, %2, %3, %4);

ADC_Read(%3); { read Is1/Imax }AR = 0x4000 - AR;

AY0 = dm(%0);

AR = AR - AY0;

dm(%2) = AR; { Is1/2Imax }

ADC_Read(%4); { read Is2/Imax }

AR = 0x4000 - AR;

AY0 = dm(%1);

AR = AR - AY0;

dm(%2+1) = AR; { Is2/2Imax }

AR = -AR;

AY0 = dm(%2); { Is1/2Imax }

AR = AR - AY0;

dm(%2+2) = AR; { Is3/2Imax=-Is2/2Imax-Is1/2Imax}

.ENDMACRO;

3.5 Experimental results

First of all, experiments without the dead time compensation were made. Figure 4 represents the inverter phase voltage compared to the reference voltage that is desired at the inverter terminal and the phase current. It may be seen that the behavior presented in chapter 1 is verified in practice: When the phase current is positive, the real inverter phase voltage is less than the commanded one by an amount determined by the dead time and when the phase current is negative, the real inverter phase voltage is greater than the commanded.

At last, Figure 5 displays the inverter phase voltage and the phase current obtained with the feed forward dead time compensation. It may be observed that the voltage still presents some distortions caused by the nature of feed forwarding: it is supposed that the current measured during the previous PWM cycle maintains its sign into the next PWM cycle; when the current changes the sign, this moment cannot be foreseen and the error is doubled. These voltage deformations cause also deformations in the current behaviour, and they may be prevented only implementing current controllers in a more accurate control strategy, like field-oriented control.

Figure 4. Reference and real inverter phase voltages and the phase current

Figure 5. Inverter phase voltage and phase current after the dead time compensation

4 References

[1]Pulse dead time compensator for PWM voltage inverters, David Leggate, Russel J. Kerkman, Industrial Electronics, Control, and Instrumentation, 1995, Proceedings of the 1995 IEEE IECON 21st International Conference on Volume: 1, Page(s): 474 -481 vol.1.下载本文