UNIVERSITATEA „POLITEHNICA” TIMIȘOARA

FACULTATEA DE ELECTROTEHNICĂ ȘI
ELECTROENERGETICĂ

PROIECT: CONTROLUL UNUI INVERTOR

TRIFAZAT. (REFERINȚELE SINUSOIDALE SUNT
GENERATE INTERN)

STUDENTI:

MISCHIA SERGIU
STANESCU DORINEL PROF.: ING. HULEA DAN

Anul IV
SCHEMA ELECTRICĂ IN PROTEUS
SCHEMA IN MATLAB:
REZULTATUL DUPA FINALIZAREA SCHEMEI IN MATLAB:

CODUL IN MPLAB-X:
/*
* -------------------------------------------------------------------
* MPLAB 16-Bit Device Blocks for Simulink v3.38.
*
* Product Page: http://www.microchip.com/SimulinkBlocks
* Forum: http://www.microchip.com/forums/f192.aspx
* Wiki: http://microchip.wikidot.com/simulink:start
* -------------------------------------------------------------------
* File: mischia.c
*
* Code generated for Simulink model 'mischia'.
*
* Model version : 1.5
* Simulink Coder version : 8.11 (R2016b) 25-Aug-2016
* C/C++ source code generated on : Sat Apr 20 21:13:08 2019
 */

#include "mischia.h"
#include "mischia_private.h"

/* Block signals and states (auto storage) */

DW_mischia_T mischia_DW;

/* Real-time model */
RT_MODEL_mischia_T mischia_M_;
RT_MODEL_mischia_T *const mischia_M = &mischia_M_;

/* Model step function for TID0 */

void mischia_step0(void) /* Sample time: [0.001s, 0.0s] */
{
/* (no output/update code required) */
}

/* Model step function for TID1 */

void mischia_step1(void) /* Sample time: [100.0s, 0.0s] */
{
/* local block i/o variables */
boolean_T rtb_LogicalOperator;
real_T HoldSine;

/* Sin: '<Root>/Sine Wave1' */

if (mischia_DW.systemEnable != 0L) {
mischia_DW.lastSin = sin(314.0 * ((mischia_M->Timing.clockTick1) *
100.0));
mischia_DW.lastCos = cos(314.0 * ((mischia_M->Timing.clockTick1) *
100.0));
mischia_DW.systemEnable = 0L;
}

/* DataTypeConversion: '<Root>/Data Type Conversion' incorporates:

* Sin: '<Root>/Sine Wave1'
*/
HoldSine = floor(((mischia_DW.lastSin * -0.97620794950622491 +
mischia_DW.lastCos * -0.2168364344865775) *
-0.97620794950622491 + (mischia_DW.lastCos *
-0.97620794950622491 - mischia_DW.lastSin * -0.2168364344865775) *
0.2168364344865775) * 500.0 + 500.0);
if (rtIsNaN(HoldSine) || rtIsInf(HoldSine)) {
HoldSine = 0.0;
} else {
HoldSine = fmod(HoldSine, 65536.0);
}

mischia_DW.DataTypeConversion = HoldSine < 0.0 ? (uint16_T)-

(int16_T)(uint16_T)
-HoldSine : (uint16_T)HoldSine;

/* End of DataTypeConversion: '<Root>/Data Type Conversion' */

/* Sin: '<Root>/Sine Wave2' */

if (mischia_DW.systemEnable_i != 0L) {
 mischia_DW.lastSin_o = sin(314.0 * ((mischia_M->Timing.clockTick1) *
100.0));
mischia_DW.lastCos_d = cos(314.0 * ((mischia_M->Timing.clockTick1) *
100.0));
mischia_DW.systemEnable_i = 0L;
}

/* DataTypeConversion: '<Root>/Data Type Conversion1' incorporates:

* Sin: '<Root>/Sine Wave2'
*/
HoldSine = floor(((mischia_DW.lastSin_o * 0.67588983548558468 +
mischia_DW.lastCos_d * -0.73700266640445011) *
-0.97620794950622491 + (mischia_DW.lastCos_d *
0.67588983548558468 - mischia_DW.lastSin_o * -0.73700266640445011) *
0.2168364344865775) * 500.0 + 500.0);
if (rtIsNaN(HoldSine) || rtIsInf(HoldSine)) {
HoldSine = 0.0;
} else {
HoldSine = fmod(HoldSine, 65536.0);
}

mischia_DW.DataTypeConversion1 = HoldSine < 0.0 ? (uint16_T)-(int16_T)

(uint16_T)-HoldSine : (uint16_T)HoldSine;

/* End of DataTypeConversion: '<Root>/Data Type Conversion1' */

/* Sin: '<Root>/Sine Wave3' */

if (mischia_DW.systemEnable_im != 0L) {
mischia_DW.lastSin_i = sin(314.0 * ((mischia_M->Timing.clockTick1) *
100.0));
mischia_DW.lastCos_i = cos(314.0 * ((mischia_M->Timing.clockTick1) *
100.0));
mischia_DW.systemEnable_im = 0L;
}

/* DataTypeConversion: '<Root>/Data Type Conversion2' incorporates:

* Sin: '<Root>/Sine Wave3'
*/
HoldSine = floor(((mischia_DW.lastSin_i * 0.30031811402306291 +
mischia_DW.lastCos_i * 0.95383910089156576) *
-0.97620794950622491 + (mischia_DW.lastCos_i *
0.30031811402306291 - mischia_DW.lastSin_i * 0.95383910089156576) *
0.2168364344865775) * 500.0 + 500.0);
if (rtIsNaN(HoldSine) || rtIsInf(HoldSine)) {
HoldSine = 0.0;
} else {
HoldSine = fmod(HoldSine, 65536.0);
}

mischia_DW.DataTypeConversion2 = HoldSine < 0.0 ? (uint16_T)-(int16_T)

(uint16_T)-HoldSine : (uint16_T)HoldSine;

/* End of DataTypeConversion: '<Root>/Data Type Conversion2' */

/* S-Function (MCHP_PWM): '<Root>/PWM' */

/* PWM Output Function !! */
 /* S-Function (MCHP_Digital_Output_Read): '<S1>/Digital Output Read' */

/* MCHP_Digital_Output_Read Block: <S1>/Digital Output Read/Output */

/* Logic: '<Root>/Logical Operator' incorporates:

* S-Function (MCHP_Digital_Output_Read): '<S1>/Digital Output Read'
*/
rtb_LogicalOperator = !LATBbits.LATB5;

/* S-Function (MCHP_Digital_Output_Write): '<S1>/Digital Output Write' */

LATBbits.LATB5 = rtb_LogicalOperator;

/* Update for Sin: '<Root>/Sine Wave1' */

HoldSine = mischia_DW.lastSin;
mischia_DW.lastSin = mischia_DW.lastSin * -0.97620794950622491 +
mischia_DW.lastCos * 0.2168364344865775;
mischia_DW.lastCos = mischia_DW.lastCos * -0.97620794950622491 - HoldSine *
0.2168364344865775;

/* Update for Sin: '<Root>/Sine Wave2' */

HoldSine = mischia_DW.lastSin_o;
mischia_DW.lastSin_o = mischia_DW.lastSin_o * -0.97620794950622491 +
mischia_DW.lastCos_d * 0.2168364344865775;
mischia_DW.lastCos_d = mischia_DW.lastCos_d * -0.97620794950622491 -
HoldSine *
0.2168364344865775;

/* Update for Sin: '<Root>/Sine Wave3' */

HoldSine = mischia_DW.lastSin_i;
mischia_DW.lastSin_i = mischia_DW.lastSin_i * -0.97620794950622491 +
mischia_DW.lastCos_i * 0.2168364344865775;
mischia_DW.lastCos_i = mischia_DW.lastCos_i * -0.97620794950622491 -
HoldSine *
0.2168364344865775;

/* Update for S-Function (MCHP_PWM): '<Root>/PWM' */

P1DC1 = mischia_DW.DataTypeConversion;/* Period for Channel 1 */
P1DC2 = mischia_DW.DataTypeConversion1;/* Period for Channel 2 */
P1DC3 = mischia_DW.DataTypeConversion2;/* Period for Channel 3 */

/* Update absolute time */

/* The "clockTick1" counts the number of times the code of this task has
* been executed. The resolution of this integer timer is 100.0, which is
the step size
* of the task. Size of "clockTick1" ensures timer will not overflow during
the
* application lifespan selected.
*/
mischia_M->Timing.clockTick1++;
}

/* Model initialize function */

void mischia_initialize(void)
{
/* Registration code */

/* initialize non-finites */
 rt_InitInfAndNaN(sizeof(real_T));

/* initialize real-time model */

(void) memset((void *)mischia_M, 0,
sizeof(RT_MODEL_mischia_T));
(mischia_M)->Timing.TaskCounters.cLimit[0] = 1;
(mischia_M)->Timing.TaskCounters.cLimit[1] = 100000;

/* states (dwork) */
(void) memset((void *)&mischia_DW, 0,
sizeof(DW_mischia_T));

/* S-Function "Microchip MASTER" initialization Block: <Root>/Microchip

Master */

/* Start for S-Function (MCHP_PWM): '<Root>/PWM' */

PWM1CON1 = 0x77;
PWM1CON2 = 0x00;
P1DTCON1 = 0xB272;
P1DTCON2 = 0x01;
P1FLTACON = 0x87;
P1TPER = 0x01F4;
P1SECMP = 0x01F4;
P1TCON = 0x8003; /* Enable PWM */

/* Enable for Sin: '<Root>/Sine Wave1' */

mischia_DW.systemEnable = 1L;

/* Enable for Sin: '<Root>/Sine Wave2' */

mischia_DW.systemEnable_i = 1L;

/* Enable for Sin: '<Root>/Sine Wave3' */

mischia_DW.systemEnable_im = 1L;
}

/*
* File trailer for generated code.
*
* [EOF]
*/

EXPLICAREA PROGRAMULUI:

Dupa generarea schemei in Matlab Simulink am generat codul cu ajutorul functiei build
model, si codul este prezentat mai sus.
Motor.c si motor_main.c sunt fisierele sursa in care este generat codul pentru
microcontroler.
Functia void motor_step0(void) este functia main care este urmata switch si 5 case, in
care switch e o instrucțiune de comutare permite ca o variabilă să fie testată pentru
egalitate cu o listă de valori. Fiecare valoare se numește caz(case), iar variabila care este
activată este verificată pentru fiecare caz de comutare. Se verifica egalitatea .
motor_DW.ADC =ADCBuffChannelA[0]; este functia care ajuta ADC pentru a fi
initializat in codul sursa.
P1DC1 = motor_DW.DataTypeConversion este initializat dutycycle pentru a genera in
codul sursa semnalul PWM.
In finalul programului se gasesti registri pentru PWM si ADC.

EXPLICAREA REGISTRILOR:

PWM1CON2 = 0x00;,valoarea 0x00, (0000 0000 0000 0000 în binar) atribuita pentru PWM1CON2 arată
că doar pinii UDIS, IUE și OSYNC ceilalți sunt dezactivați.

IUE=0 activeaza PxDCy ssunt sincronizate cu baza temporală PWM

UDIS= 0 actualizările din registrele de dutycycle și registru buffer sunt activate

OSYNC= 0 activeaza registru PxOVDCON (1)

PWM1CON1 = 0x11, valoarea 0x11 (0000 0000 0001 0001 în binar) atribuita pentru PWM1CON1 arată
că doar pinii PWM1H1 și PWM1L1 sunt activi ca pini de PWM și ceilalți sunt dezactivați. Acești pini activi
funcționează în mod complementar (PMOD1=0)

AD1CHS0 = 0x01, valoarea 0x01(0000 0000 0000 0001 în binar) avem canalului 0 si intrare pozitiva pe
AN1
P1TCON = 0x8000; (in binar 1000000000000000),activeaza PWM, PTEN activ restul pinilor dezactivati,iar
cand PTEN=1 va rezulta ca timer este activ.

AD1CON2 = 0x00; valoarea 0x00(0000 0000 0000 0000 în binar) , intreruperea ADC este generată la
finalizarea fiecărei operațiuni de eșantionare .ALTS=0,intotdeauna se selecteaza intrarea pentru Sample
A.
EXPLICAREA UNOR INSTRUCȚIUNI DIN ASAMBLARE:
SIMULAREA PROIECTULUI GENERAT: