O código fonte do programa SRCC foi automaticamente gerado em linguagem C++ pelo programa Simulink, com base em um diagrama contendo um modulador PWM e o microcontrolador 28335 da Texas Instruments. As instruções adicionais foram inseridas diretamente nos arquivos relacionados.
A3.1 Arquivo: PWM_v19_main.c
/*
* File: PWM_v19_main.c *
* Real-Time Workshop code generated for Simulink model PWM_v19. *
* Model version : 1.182
* Real-Time Workshop file version : 7.4 (R2009b) 29-Jun-2009 * Real-Time Workshop file generated on : Tue Mar 22 20:18:42 2011 * TLC version : 7.4 (Jul 14 2009) * C/C++ source code generated on : Tue Mar 22 20:18:43 2011 *
* Target selection: ccslink_ert.tlc
* Embedded hardware selection: Texas Instruments->C2000 * Code generation objectives: Unspecified
* Validation result: Not run */ #include "PWM_v19.h" #include "rtwtypes.h" #include "PWM_v19_private.h" #include "c2000_main.h" #include "DSP2833x_Device.h" #include "DSP2833x_Examples.h" #include <stdlib.h> #include <stdio.h> void init_board(void); void enable_interrupts(void); void config_schedulerTimer(void); void disable_interrupts(void); volatile int IsrOverrun = 0; static boolean_T OverrunFlag = 0; void rt_OneStep(void)
{
// Check for overrun. Protect OverrunFlag against // pre-emption
if (OverrunFlag++) { IsrOverrun = 1; OverrunFlag--;
return; // finaliza o loop se OverrunFlag >=1. }
// Faz OverrunFlag = 1 e segue a execução asm(" SETC INTM");
PieCtrlRegs.PIEIER1.all |= (1 << 6); // Habilita INTx7 asm(" CLRC INTM");
// PWM_v19_step();
/* Get model outputs here */ asm(" SETC INTM");
PieCtrlRegs.PIEIER1.all &= ~(1 << 6); asm(" RPT #5 || NOP");
IFR &= 0xFFFE;
PieCtrlRegs.PIEACK.all = 0x1; asm(" CLRC INTM");
OverrunFlag--; // Decrementa OverrunFlag }
//
// Entry point into the code //
void main(void) {
volatile boolean_T noErr; init_board(); rtmSetErrorStatus(PWM_v19_M, 0); PWM_v19_initialize(1); config_schedulerTimer(); noErr = rtmGetErrorStatus(PWM_v19_M) == (NULL); enable_interrupts(); while (noErr ) { noErr = rtmGetErrorStatus(PWM_v19_M) == (NULL); }
/* Disable rt_OneStep() here */ /* Terminate model */
PWM_v19_terminate(); disable_interrupts(); }
/*
* File trailer for Real-Time Workshop generated code. *
* [EOF] */
Código fonte do programa SRCC
A3.3 Arquivo: PWM_v19.c
/*
* File: PWM_v19.c *
* Real-Time Workshop code generated for Simulink model PWM_v19. *
* Model version : 1.182
* Real-Time Workshop file version : 7.4 (R2009b) 29-Jun-2009 * Real-Time Workshop file generated on : Tue Mar 22 20:18:42 2011 * TLC version : 7.4 (Jul 14 2009) * C/C++ source code generated on : Tue Mar 22 20:18:43 2011 *
* Target selection: ccslink_ert.tlc
* Embedded hardware selection: Texas Instruments->C2000 * Code generation objectives: Unspecified
* Validation result: Not run */
#include "PWM_v19.h" #include "PWM_v19_private.h" #include "PWM_v19_byMBA.h" #include <stdio.h>
/* Block signals (auto storage) */ //BlockIO_PWM_v19 PWM_v19_B; /* Real-time model */ RT_MODEL_PWM_v19 PWM_v19_M_; RT_MODEL_PWM_v19 *PWM_v19_M = &PWM_v19_M_; // Variáveis globais // Caminhos: // 01: Redundante; // 02: Trans. suprimida; // 04: Ciclo neutro; // 08: Trans. Postergada; // 16: Com. executada. int16_T
ADC_buf[2][1667], // Buffer para o registrador ADC_b0 RegFPB_a0[200], RegADC_a0[200]; uint8_T RegCaminho[200], RegPwm[200], RegContAmo = 0; int8_T
SFm = 2U, // Salto de fila máximo RCm = 3U, // Retardo da comutação máximo DNtemp,
RegDNmax = 0, RegDN[10];
uint16_T RegVfap[200]; uint32_T RegDt[10], RegMomAmo[200], RegTG[10]; cmn RegCMN[10]; boolean_T Para1 = false, Para2 = true, RegBloco = false, RegLivre = false;
//int16_T Reg_buf1[1667]; // Buffer para o registrador ADC_b0 real32_T
Reg_buf[1667],
Kffw = -0.114115, // Constante da rede Feedforward. (Ganho ADC_a0 = 10,68. Valor medido)
// Constantes aplicadas para amostragem em 100 kHz:
Kp_VC = -1.25e-4, // Kp_VC = -7.8e-6 ( *16 = 1,248e-4). LJ_FPB_a0 = 16 Ki_VC = -2.4e-9, // Ki_VC = -1.5e-10 ( *16 = 2,4e-9). LJ_FPB_a0 = 16
Kp_CF = 12.0, // 4.882; Ganho Proporcional do controlador da corrente do filtro
Ki_CF = 0.05; // = 0.01808; Ganho Integral do controlador da corrente do filtro = Ki * Ts
void Amostra(void) { // Interrupção principal
static boolean_T
Falha_a = true, // Atendimento à falha FimRampa = true; // Fim da rampa de partida static long int
Cnt = 0U; // Contador de uso geral static int16_T
FPB_v0[16] = { // Vetor das leituras da tensão em ADC_a0. Comprimento LJ_FPB_a0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
FPB_a0 = 0; static int8_T
MDv[128] = { // Vetor de médias discretas de comprimento LJmd: MDV[LJ_MD]
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, MDi = 0, // Índice do contador do filtro de média móvel da MD
Vi = 0, // Índice do contador do FPB de ADC_a0 Cnt_aux = 0U; // Contador auxiliar de uso geral static real32_T
Integrador_VC = 0.0, // Integrador do controlador da tensão do capacitor Integrador_CF = 0.0, // Integrador do controlador da corrente do filtro iERROa = 0.0; // Erro de corrente ciclo anterior
Código fonte do programa SRCC
int16_T
ADC_a0, // Valor CA da tensão da rede ADC_b0; // Valor CA da corrente da rede real32_T
iERRO, // Erro de corrente
Up_CF, // Parcela proporcional do controlador da corrente do filtro Ld_CF, // Limite dinâmico da saturação do controlador CF
Up_VC, Ld_VC,
Soma_VC, // Soma dos valores do controlador PI_VC Soma_CF; // Soma dos valores do controlador PI_CF FProt &= GpioDataRegs.GPBDAT.bit.GPIO48;
// GpioDataRegs.GPBTOGGLE.bit.GPIO33 = 1U; // Chaveamento da saída de teste. Início da rotina = 50kHz // GpioDataRegs.GPASET.bit.GPIO17 = 1U;
if (FProt) { // Proteção desativa
// Calcula a Média Discreta
MD = GpioDataRegs.GPADAT.bit.GPIO24 + GpioDataRegs.GPADAT.bit.GPIO25 + GpioDataRegs.GPADAT.bit.GPIO26 + GpioDataRegs.GPADAT.bit.GPIO27 - 2;
// Aplica o filtro de média móvel na Média Discreta MDf += MD - MDv[MDi];
MDv[MDi] = MD; MDi++;
if (MDi == 128) MDi = 0;
// Calcula o valor ac do ADC
// ADC_a0 = (AdcRegs.ADCRESULT0>>4) - 2047; // Transdutor de tensão da rede
ADC_a0 = 2047 - (AdcRegs.ADCRESULT0>>4); // Transdutor de tensão da rede (-Out_ADC_a0) ADC_b0 = (AdcRegs.ADCRESULT1>>4) - 2047; // Transdutor de corrente do filtro (Out_ADC_b0) AdcRegs.ADCTRL2.bit.RST_SEQ1 = 0x1; // Sequencer reset
// Aplica o filtro passa-baixa (média móvel) na tensão da rede FPB_a0 += ADC_a0 - FPB_v0[Vi];
FPB_v0[Vi] = ADC_a0; Vi++;
if (Vi == 16) Vi = 0;
RegFPB_a0[RegContAmo] = FPB_a0; // Registra o valor de FPB_a0 ++++++ Temporário! RegADC_a0[RegContAmo] = ADC_a0; // Registra o valor de ADC_a0 ++++++ Temporário!
// Atualiza controlador VC
Up_VC = Kp_VC * MDf; // Parcela proporcional do controlador de tensão Ld_VC = 2.5 * Rampa; // Aplica a rampa no limite dinâmico (Valor experimental) Integrador_VC += (Ki_VC * MDf);
Integrador_VC = satura(Integrador_VC, Ld_VC); Soma_VC = Up_VC + Integrador_VC;
// Atualiza a rampa de partida if (FimRampa) {
Rampa = Rampa + 1.0e-6; iERRO *= 0.3 + 0.7*Rampa; if (Rampa >= 0.999998) { Rampa = 1.0; FimRampa = false; } }
Up_CF = Kp_CF * iERRO; // Calcula a parcela proporcional satura(Up_CF, 4095); // Aplica limites de saturação
Ld_CF = abs(4096 - abs(Up_CF)); // Calcula limite dinâmico da saturação Integrador_CF += (Ki_CF * (iERRO + iERROa) * 0.5); // Atualiza o integrador de corrente Integrador_CF = satura(Integrador_CF, Ld_CF); // Aplica limites de saturação
iERROa = iERRO;
Soma_CF = Up_CF + Integrador_CF; // Atualiza o controlador CF Soma_CF = satura(Soma_CF, 4095);
// Atualiza a tesão de referência do filtro ativo Vfap Vfap = (uint16_T)(Soma_CF + Kffw * FPB_a0 + 4095);
if (Vfap>8190) Vfap = 8189; // Aplica limite de saturação do PWM
RegVfap[RegContAmo] = Vfap; // Registra o valor de Vfap ++++++ Temporário!
// Atualiza vetor do buffer ADC_buf if (Conta < 1667) {
ADC_buf[0][Conta] = FPB_a0; ADC_buf[1][Conta] = ADC_b0;
Reg_buf[Conta] = Soma_VC * FPB_a0; // i_ref }
// Incrementa contador de amostragem Conta++;
// ========== Início da Rotina de rotação e comutação Rotacional(); // Rotina de rotação e comutação
// ========== Fim da Rotina de rotação e comutação
}
else { // Proteção ativa
if (GpioDataRegs.GPBDAT.bit.GPIO48) { // Verifica "Falha" // Falha removida
if (GpioDataRegs.GPBDAT.bit.GPIO62 == 0) { // Verifica "Rele1" (Alimentação) GpioDataRegs.GPBSET.bit.GPIO62 = 1U; // Ativa "Rele1"
Falha_a = true; // Ativa necessidade de atender à falha
Cnt = 0U; Cnt_aux = 0U;
GpioDataRegs.GPACLEAR.bit.GPIO31 = 1U; GpioDataRegs.GPBSET.bit.GPIO34 = 1U;
Código fonte do programa SRCC
if (GpioDataRegs.GPBDAT.bit.GPIO49==0U){ // Verifica "Parte": 0=R em série, 1=Direto. // Pré-carga dos capacitores. R em série
// Rotina de temporização para pré-carga Cnt++; if (Cnt == 50000U) { Cnt = 0U; GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1U; GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1U; Cnt_aux++;
// if (Cnt_aux == 1U) printf("Pré-carga\n"); if (Cnt_aux == 31U) { // Encerra a temporização
Cnt_aux = 0;
// printf("Fim pré-carga.\n");
GpioDataRegs.GPBSET.bit.GPIO49 = 1U; } // Fim do encerramento da temporização } // Fim pisca-led em temporização para pré-carga } // Fim da rotina de temporização
else { // Fim da proteção
// Última execução antes da partida
GpioDataRegs.GPBSET.bit.GPIO32 = 1U; // Ativa "Habilita" FProt = true; // Desativa proteção de falha // RegBufMax[0]=0;
// RegBufMin[0]=0; } // Fim do Fim da proteção }
else { // Falha no hardware
if (Falha_a) { // Verifica atendimento à falha
FProt = false; // Ativa proteção de falha
GpioDataRegs.GPBCLEAR.bit.GPIO62 = 1U; // Desliga "Rele1" (Alimentação) GpioDataRegs.GPBCLEAR.bit.GPIO49 = 1U; // Desliga rele "Parte"
GpioDataRegs.GPBCLEAR.bit.GPIO32 = 1U; // Desativa "Habilita"
Falha_a = false; // Apaga pedido de atendimento à falha GpioDataRegs.GPACLEAR.bit.GPIO31 = 1U; // Apaga LED_2
GpioDataRegs.GPBCLEAR.bit.GPIO34 = 1U; // Apaga LED_3 }
// Pisca LED Cnt++;
if (Cnt == 50000U) { // Pisca LED Cnt = 0U;
GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1U; GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1U; } // Fim do pisca led em falha
} // Fim da Falha no hardware } // Fim da proteção ativa
// GpioDataRegs.GPACLEAR.bit.GPIO17 = 1U; // Apaga GPIO17 } // Fim da interrupção principal "Amostra"
void Rotacional(void) { // Rotina de rotação e comutação // Variáveis locais
static uint32_T
R_s = 0U, // Registrador de amostragem
R_tr = 0, // Registrador de transições redundantes R_ts = 0, // Registrador de transições suprimidas R_cn = 0, // Registrador de ciclos neutros R_ce = 0, // Registrador das comutações executadas R_tp = 0; // Regitrador das transições postergadas static cmn phA = { // Conversor multinível da fase A {{ 0U, 2U, 4U, 6U }, // { 1A, 2A, 3A, 4A}
{ 1U, 3U, 5U, 7U }}, // { 1B, 2B, 3B, 4B} { 4U, 4U }}; // Final da fila static int8_T
DN = 0U; // Variação do nível static uint8_T
Dt = 0U, // Dados da saída PWM do conversor de entrada Dta = 0U, // Dados da saída PWM no ciclo anterior
RC = 0U, // Retardo da comutação
BP = 0U; // Bloqueio de Postergação após transições // SFm = 2U, // Salto de fila máximo
// RCm = 3U; // Retardo da comutação máximo uint32_T
TG = 0U; // Registrador de comutação. Mapa para GPATOGGLE. uint16_T
rtb_Sum; // Comparador da tensão do ePWM int8_T
DNm, // Módulo da variação do nível
DNA; // Variação do nível na transição anterior uint8_T
SG, // Sinal da transição: 0=Positiva, 1=Negativa SF, // Tamanho do salto da fila.
i; // Índice de contador para uso geral boolean_T
SI, // Sentido da Corrente (GPIO30) +I=1, -I=0
Q; // Nível de carga do capacitor (In_VCnom). 0:VC<VCn, 1:VC>VCn // Faz a leitura dos PWMs
Dt = GpioDataRegs.GPADAT.all &63U;
RegPwm[RegContAmo] = Dt; // Registra a leitura do PWM ++++++ Temporário ++++++ // Incrementa o registrador de amostragem
R_s++;
RegCaminho[RegContAmo] = 0;
Código fonte do programa SRCC
{ // Inicia a operação rotacional // === Bloco 1 ===
BP=(BP>0)? BP-1: 0; // Decrementa o Bloqueio de Postergação // === Bloco 2 ===
if (Dt!=Dta) { // Transição identificada DNA = DN;
// Cálculo da variação do nível
DN = (Dt&1) -(Dta&1) -((Dt&2)>>1) +((Dta&2)>>1) // PWM 1 + ((Dt&4)>>2) -((Dta&4)>>2) -((Dt&8)>>3) +((Dta&8)>>3) // PWM 2 + ((Dt&16)>>4) -((Dta&16)>>4) -((Dt&32)>>5) +((Dta&32)>>5); // PWM 3
if (DN==0U) { // Transição redundante // Registra transição redundante R_tr++;
RegCaminho[RegContAmo] += 1; } // Fim do registro da transição redundante
DN += DNA; // Adiciona nível anterior } // Fim da transição identificada
// === Bloco 3 ===
if (DN==0U) { // Amostra neutra
if (Dt!=Dta) { // Transição suprimida // Registra transição suprimida
R_ts++;
RegCaminho[RegContAmo] += 2; // Atualiza Dta
Dta = Dt;
} // Fim da transição suprimida else { // Ciclo neutro
// Registra ciclo neutro
R_cn++; RegCaminho[RegContAmo] += 4; // Atualiza LEDs switch (MD) { case 0: GpioDataRegs.GPBSET.bit.GPIO34 = 1; GpioDataRegs.GPASET.bit.GPIO31 = 1; break; case -1: GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1; GpioDataRegs.GPASET.bit.GPIO31 = 1; break; case 1: GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1; GpioDataRegs.GPBSET.bit.GPIO34 = 1; break; case -2: GpioDataRegs.GPBCLEAR.bit.GPIO34 = 1; GpioDataRegs.GPASET.bit.GPIO31 = 1; break;
case 2:
GpioDataRegs.GPACLEAR.bit.GPIO31 = 1; GpioDataRegs.GPBSET.bit.GPIO34 = 1;
break; }
// Verifica ciclo de medição dos registradores if (R_s >= 1000000){
N_s = R_s; R_s = 0U; N_t = Conta; Conta = 0U; N_tr = R_tr; R_tr = 0U; N_ts = R_ts; R_ts = 0U; N_cn = R_cn; R_cn = 0U; N_ce = R_ce; R_ce = 0U; N_tp = R_tp; R_tp = 0U;
// RegBloco = true; // Habilita registro de bloco }
} // Fim do ciclo neutro } // Fim da amostra neutra else { // Tratamento da transição
DNtemp = DN; // Registra o valor de DN
DNm = abs(DN); // Calcula o valor absoluto de DN if (DNm > RegDNmax) RegDNmax = DNm; // Registra o DN máximo if ((BP>0U)||(RC==0U)||(DNm>=2U)){ // Comuta as chaves
BP=(DNm>=2)? 1U: 2U; // Ajusta o Bloqueio de Postergação (BPe=1, BPn=2) // ***** Início de Comuta *****
SG = ((DN&32768)==32768)? 1: 0; // SG=0, DN positivo. SG=1, DN negativo. SI = GpioDataRegs.GPADAT.bit.GPIO30; // Calcula o sentido da corrente: +I=1, - I=0
do { // loop de comutação if (DNm>1) { //
SF = 0;
}
else { // Última volta no loop
// Ajusta o valor máximo do salto de fila
SF = (SFm > phA.F_Fila[SG]-1)? phA.F_Fila[SG]-1: SFm; // min(F_Fila; SFM)
i = 0;
do { // Loop de procura por célula hábil a comutar // phA.Fila[SG][i] = Chave na posição i da fila Q = ((GpioDataRegs.GPADAT.all & Ch[1][(phA.Fila[SG][i])]) && 1); i++; } while (!((SG^SI^Q)||(i==SF+1))); i--;
if ((SG^SI^Q)==1) { // Comutação natural
SF = i;
RC = RCm;
Código fonte do programa SRCC
else { // Comutação forçada
SF = 0;
RC = 0;
}
} // Fim da última volta
// Comuta os registradores da saída TG |= Ch[0][(phA.Fila[SG][SF])];
// Troca a chave e ajusta o fim da fila if (SG==0) { // Transição positiva
phA.Fila[1][(phA.F_Fila[1])] = phA.Fila[0][SF];
phA.F_Fila[0]--;
phA.F_Fila[1]++;
}
else { // Transição negativa
phA.Fila[0][(phA.F_Fila[0])] = phA.Fila[1][SF];
phA.F_Fila[0]++;
phA.F_Fila[1]--;
}
// Ajusta a fila ativa (corre a fila) for (i=SF; i<=phA.F_Fila[SG]-1; i++) { phA.Fila[SG][i] = phA.Fila[SG][i+1];
}
DNm--;
} // Fim do loop de comutação while (DNm!=0);
// Comuta as saídas
GpioDataRegs.GPATOGGLE.all = TG; // Registra as comutações executadas
R_ce++;
RegCaminho[RegContAmo] += 16;
DN = 0; //
// ***** Fim de Comuta ***** } // Fim comuta chaves
else { // Transição postergada
// Registro da transição postergada
R_tp++;
RegCaminho[RegContAmo] += 8;
RC--;
} // Fim da transição postergada
// Atualiza Dat Dta = Dt;
// DN *= (SG==0U)? 1:-1; // Recupera o sinal de DN
} // Fim do tratamento da transição
// Atualização dos comparadores do ePWM:
// Inverter CMPA e CMPB devido à inverão de fase no circuito // analógico de condicionamento do sinal de referência. // Configuração original: CMPA = Vfap e CMPB = rtb_Sum. rtb_Sum = 8190U - Vfap;
EPwm1Regs.CMPA.half.CMPA = rtb_Sum; EPwm1Regs.CMPB = Vfap; EPwm2Regs.CMPA.half.CMPA = rtb_Sum; EPwm2Regs.CMPB = Vfap; EPwm3Regs.CMPA.half.CMPA = rtb_Sum; EPwm3Regs.CMPB = Vfap;
// Registra as comutações da função Rotacional if (RegBloco || RegLivre) { RegMomAmo[RegContAmo] = Conta; // RegCaminho[RegContAmo] = // RegCMN[RegContCMN] = phA; // RegDN[RegContCMN] = DNtemp; // RegTG[RegContCMN] = TG; // RegDt[RegContCMN] = Dt; RegContAmo++; if (RegContAmo == 200) { RegBloco = false; RegContAmo = 0; } }
// Fim do bloco de registro }
/* Função do corte de saturação */
real32_T satura(real32_T obj, real32_T limite) {
if (obj > limite) obj = limite; if (obj < -limite) obj = -limite; return obj;
}
/* Model initialize function */
void PWM_v19_initialize(boolean_T firstTime) {
(void)firstTime; /* Registration code */ /* initialize error status */ rtmSetErrorStatus(PWM_v19_M, (NULL)); // /* block I/O */
// (void) memset(((void *) &PWM_v19_B),0, // sizeof(BlockIO_PWM_v19));
Código fonte do programa SRCC
/* Start for S-Function (c280xadc): '<Root>/ADC' */ InitAdc();
config_ADC_A (0U, 0U, 0U, 0U, 0U);
/* Start for S-Function (c280xpwm): '<Root>/ePWM1' */ /*** Initialize ePWM1 modules ***/
{
EPWMPARAMS EPwm1Params;
/*-- Setup Time-Base (TB) Submodule --*/ EPwm1Params.TBPRD = 8190; EPwm1Params.TBCTL_CTRMODE = 2; EPwm1Params.TBCTL_SYNCOSEL = 1; EPwm1Params.TBCTL_PHSEN = 0; EPwm1Params.TBCTL_PHSDIR = 0; EPwm1Params.TBPHS = 0; EPwm1Params.TBCTL_HSPCLKDIV = 0; EPwm1Params.TBCTL_CLKDIV = 0;
/*-- Setup Counter_Compare (CC) Submodule --*/ EPwm1Params.CMPCTL_LOADAMODE = 0;
EPwm1Params.CMPCTL_LOADBMODE = 0; EPwm1Params.CMPA = 0;
EPwm1Params.CMPB = 0;
/*-- Setup Action-Qualifier (AQ) Submodule --*/ EPwm1Params.AQCTLA = 144;
EPwm1Params.AQCTLB = 2304; EPwm1Params.AQCSFRC_CSFA = 0; EPwm1Params.AQCSFRC_CSFB = 0; EPwm1Params.AQCSFRC_RLDCSF = 0;
/*-- Setup Dead-Band Generator (DB) Submodule --*/ EPwm1Params.DBCTL_OUT_MODE = 0;
EPwm1Params.DBCTL_IN_MODE = 0; EPwm1Params.DBCTL_POLSEL = 0; EPwm1Params.DBRED = 0.0; EPwm1Params.DBFED = 0.0;
/*-- Setup Event-Trigger (ET) Submodule --*/ EPwm1Params.ETSEL_SOCAEN = 0; EPwm1Params.ETSEL_SOCASEL = 1; EPwm1Params.ETPS_SOCAPRD = 1; EPwm1Params.ETSEL_SOCBEN = 0; EPwm1Params.ETSEL_SOCBSEL = 1; EPwm1Params.ETPS_SOCBPRD = 1; EPwm1Params.ETSEL_INTEN = 0; EPwm1Params.ETSEL_INTSEL = 1; EPwm1Params.ETPS_INTPRD = 1;
/*-- Setup PWM-Chopper (PC) Submodule --*/ EPwm1Params.PCCTL_CHPEN = 0;
EPwm1Params.PCCTL_CHPFREQ = 0; EPwm1Params.PCCTL_OSHTWTH = 0; EPwm1Params.PCCTL_CHPDUTY = 0;
/*-- Setup Trip-Zone (TZ) Submodule --*/ EPwm1Params.TZSEL = 0; EPwm1Params.TZCTL_TZA = 3; EPwm1Params.TZCTL_TZB = 3; EPwm1Params.TZEINT_OST = 0; EPwm1Params.TZEINT_CBC = 0; /*-- Initial ePWM1 --*/ config_ePWMRegs(&EPwm1Regs, &EPwm1Params); /*-- Initial HRPWM for ePWM1 --*/
{ uint16_T HRLOAD = 0; uint16_T CTLMODE = 1; uint16_T EDGMODE = 3; uint16_T CMPAHR = 0; uint16_T TBPHSHR = 0;
extern int MEP_ScaleFactor[7];
init_HRPWM( &EPwm1Regs, HRLOAD, CTLMODE, EDGMODE, CMPAHR, TBPHSHR); }
}
/* Start for S-Function (c280xpwm): '<Root>/ePWM2' */ /*** Initialize ePWM2 modules ***/
{
EPWMPARAMS EPwm2Params;
/*-- Setup Time-Base (TB) Submodule --*/ EPwm2Params.TBPRD = 8190; EPwm2Params.TBCTL_CTRMODE = 2; EPwm2Params.TBCTL_SYNCOSEL = 1; EPwm2Params.TBCTL_PHSEN = 1; EPwm2Params.TBCTL_PHSDIR = 0; EPwm2Params.TBPHS = 2730; EPwm2Params.TBCTL_HSPCLKDIV = 0; EPwm2Params.TBCTL_CLKDIV = 0;
/*-- Setup Counter_Compare (CC) Submodule --*/ EPwm2Params.CMPCTL_LOADAMODE = 0;
EPwm2Params.CMPCTL_LOADBMODE = 0; EPwm2Params.CMPA = 0;
EPwm2Params.CMPB = 0;
/*-- Setup Action-Qualifier (AQ) Submodule --*/ EPwm2Params.AQCTLA = 144;
Código fonte do programa SRCC
EPwm2Params.AQCSFRC_CSFB = 0; EPwm2Params.AQCSFRC_RLDCSF = 0;
/*-- Setup Dead-Band Generator (DB) Submodule --*/ EPwm2Params.DBCTL_OUT_MODE = 0;
EPwm2Params.DBCTL_IN_MODE = 0; EPwm2Params.DBCTL_POLSEL = 0; EPwm2Params.DBRED = 0.0; EPwm2Params.DBFED = 0.0;
/*-- Setup Event-Trigger (ET) Submodule --*/ EPwm2Params.ETSEL_SOCAEN = 0; EPwm2Params.ETSEL_SOCASEL = 1; EPwm2Params.ETPS_SOCAPRD = 1; EPwm2Params.ETSEL_SOCBEN = 0; EPwm2Params.ETSEL_SOCBSEL = 1; EPwm2Params.ETPS_SOCBPRD = 1; EPwm2Params.ETSEL_INTEN = 0; EPwm2Params.ETSEL_INTSEL = 1; EPwm2Params.ETPS_INTPRD = 1;
/*-- Setup PWM-Chopper (PC) Submodule --*/ EPwm2Params.PCCTL_CHPEN = 0;
EPwm2Params.PCCTL_CHPFREQ = 0; EPwm2Params.PCCTL_OSHTWTH = 0; EPwm2Params.PCCTL_CHPDUTY = 0;
/*-- Setup Trip-Zone (TZ) Submodule --*/ EPwm2Params.TZSEL = 0; EPwm2Params.TZCTL_TZA = 3; EPwm2Params.TZCTL_TZB = 3; EPwm2Params.TZEINT_OST = 0; EPwm2Params.TZEINT_CBC = 0; /*-- Initial ePWM2 --*/ config_ePWMRegs(&EPwm2Regs, &EPwm2Params); /*-- Initial HRPWM for ePWM2 --*/
{ uint16_T HRLOAD = 0; uint16_T CTLMODE = 1; uint16_T EDGMODE = 3; uint16_T CMPAHR = 0; uint16_T TBPHSHR = 0;
extern int MEP_ScaleFactor[7]; {
real_T TBPHSf = 21845.0; TBPHSf -= EPwm2Params.TBPHS;
TBPHSHR = ((uint16_T)(TBPHSf * MEP_ScaleFactor[2]) << 8)+0x180; }
init_HRPWM( &EPwm2Regs, HRLOAD, CTLMODE, EDGMODE, CMPAHR, TBPHSHR); }
/* Start for S-Function (c280xpwm): '<Root>/ePWM3' */ /*** Initialize ePWM3 modules ***/
{
EPWMPARAMS EPwm3Params;
/*-- Setup Time-Base (TB) Submodule --*/ EPwm3Params.TBPRD = 8190; EPwm3Params.TBCTL_CTRMODE = 2; EPwm3Params.TBCTL_SYNCOSEL = 3; EPwm3Params.TBCTL_PHSEN = 1; EPwm3Params.TBCTL_PHSDIR = 0; EPwm3Params.TBPHS = 2730; EPwm3Params.TBCTL_HSPCLKDIV = 0; EPwm3Params.TBCTL_CLKDIV = 0;
/*-- Setup Counter_Compare (CC) Submodule --*/ EPwm3Params.CMPCTL_LOADAMODE = 0;
EPwm3Params.CMPCTL_LOADBMODE = 0; EPwm3Params.CMPA = 0;
EPwm3Params.CMPB = 0;
/*-- Setup Action-Qualifier (AQ) Submodule --*/ EPwm3Params.AQCTLA = 144;
EPwm3Params.AQCTLB = 2304; EPwm3Params.AQCSFRC_CSFA = 0; EPwm3Params.AQCSFRC_CSFB = 0; EPwm3Params.AQCSFRC_RLDCSF = 0;
/*-- Setup Dead-Band Generator (DB) Submodule --*/ EPwm3Params.DBCTL_OUT_MODE = 0;
EPwm3Params.DBCTL_IN_MODE = 0; EPwm3Params.DBCTL_POLSEL = 0; EPwm3Params.DBRED = 0.0; EPwm3Params.DBFED = 0.0;
/*-- Setup Event-Trigger (ET) Submodule --*/ EPwm3Params.ETSEL_SOCAEN = 0; EPwm3Params.ETSEL_SOCASEL = 1; EPwm3Params.ETPS_SOCAPRD = 1; EPwm3Params.ETSEL_SOCBEN = 0; EPwm3Params.ETSEL_SOCBSEL = 1; EPwm3Params.ETPS_SOCBPRD = 1; EPwm3Params.ETSEL_INTEN = 0; EPwm3Params.ETSEL_INTSEL = 1; EPwm3Params.ETPS_INTPRD = 1;
/*-- Setup PWM-Chopper (PC) Submodule --*/ EPwm3Params.PCCTL_CHPEN = 0;
EPwm3Params.PCCTL_CHPFREQ = 0; EPwm3Params.PCCTL_OSHTWTH = 0; EPwm3Params.PCCTL_CHPDUTY = 0;
Código fonte do programa SRCC
/*-- Setup Trip-Zone (TZ) Submodule --*/ EPwm3Params.TZSEL = 0; EPwm3Params.TZCTL_TZA = 3; EPwm3Params.TZCTL_TZB = 3; EPwm3Params.TZEINT_OST = 0; EPwm3Params.TZEINT_CBC = 0; /*-- Initial ePWM3 --*/ config_ePWMRegs(&EPwm3Regs, &EPwm3Params); /*-- Initial HRPWM for ePWM3 --*/
{ uint16_T HRLOAD = 0; uint16_T CTLMODE = 1; uint16_T EDGMODE = 3; uint16_T CMPAHR = 0; uint16_T TBPHSHR = 0;
extern int MEP_ScaleFactor[7]; {
real_T TBPHSf = 21845.0; TBPHSf -= EPwm3Params.TBPHS;
TBPHSHR = ((uint16_T)(TBPHSf * MEP_ScaleFactor[3]) << 8)+0x180; }
init_HRPWM( &EPwm3Regs, HRLOAD, CTLMODE, EDGMODE, CMPAHR, TBPHSHR); }
}
/* Start for function-call system: '<Root>/Function-Call Subsystem' */ /* Start for S-Function (c280xgpio_di): '<S2>/Digital Input 58, 59' */ /* Configuração das entradas (GPA, MUX2): 24, 25, 26, 27, 30. */ EALLOW;
GpioCtrlRegs.GPAPUD.all |= 1325400064U; // 1 = Disable pullup. GpioCtrlRegs.GPAMUX2.all &= 3472949247U; // 00 = GPIO.
GpioCtrlRegs.GPADIR.all &= 2969567231U; // Direction = 0 (input). EDIS;
/* Configuração das entradas (GPB, MUX2): 48, 58, 59, 60, 61. */ EALLOW;
GpioCtrlRegs.GPBPUD.all |= 1006698496U; // 1 = Disable pullup. GpioCtrlRegs.GPBMUX2.all &= 4027580415U; // 00 = GPIO.
GpioCtrlRegs.GPBDIR.all &= 3288268799U; // Direction = 0 (input). EDIS;
/* Start for S-Function (c280xgpio_do): '<S2>/Digital Output 13, 14' */ /* Configuração das saídas (GPA, MUX1): 12, 13, 14, 15. */
/* Configuração das saídas (GPA, MUX2): 20, 21, 22, 23, 31. */ EALLOW;
GpioCtrlRegs.GPAPUD.bit.GPIO6 = 0U; // Enable pullup (remover futuramente) GpioCtrlRegs.GPAPUD.bit.GPIO7 = 0U; // Enable pullup (remover futuramente) GpioCtrlRegs.GPAPUD.all &= 2131693567U; // 0 = Enable pullup.
GpioCtrlRegs.GPAMUX1.all &= 16777215U; // 00 = GPIO. GpioCtrlRegs.GPAMUX2.all &= 1073676543U; // 00 = GPIO.
GpioCtrlRegs.GPADIR.all |= 2163273728U; // Direction = 1 (output). /* Configuração das saídas (GPB, MUX1): 32, 34. */
/* Configuração das saídas (GPB, MUX2): 49, 62. */
GpioCtrlRegs.GPBPUD.all &= 3221094394U; // 0 = Enable pullup. GpioCtrlRegs.GPBMUX1.all &= 4294967244U; // 00 = GPIO. GpioCtrlRegs.GPBMUX2.all &= 3489660915U; // 00 = GPIO.
GpioCtrlRegs.GPBDIR.all |= 1073872901U; // Direction = 1 (output). EDIS;
/* Configuração das saídas (GPA, MUX2): 16, 17, 18, 19. GPIO Uso geral */ EALLOW;
GpioCtrlRegs.GPAPUD.all &= 4293984255U; GpioCtrlRegs.GPAMUX2.all &= 4294967040U; GpioCtrlRegs.GPADIR.all |= 983040U; EDIS;
/* Configuração da saída (GPB, MUX1): 33. GPIO33 Uso geral */ EALLOW;
GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0U; // enable pullup GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 0U; // 00 = GPIO
GpioCtrlRegs.GPBDIR.bit.GPIO33 = 1; // Direction = 1 (output). EDIS;
/* Start for S-Function (c280xpwm): '<Root>/ePWM5 ADC' */ /*** Initialize ePWM5 modules ***/
{
EPWMPARAMS EPwm5Params;
/*-- Setup Time-Base (TB) Submodule --*/
EPwm5Params.TBPRD = 1499; // 1999 = Amostragem a 75 kHz. (1499=100kHz) EPwm5Params.TBCTL_CTRMODE = 0; EPwm5Params.TBCTL_SYNCOSEL = 3; EPwm5Params.TBCTL_PHSEN = 0; EPwm5Params.TBCTL_PHSDIR = 0; EPwm5Params.TBPHS = 0; EPwm5Params.TBCTL_HSPCLKDIV = 0; EPwm5Params.TBCTL_CLKDIV = 0;
/*-- Setup Counter_Compare (CC) Submodule --*/ EPwm5Params.CMPCTL_LOADAMODE = 0;
EPwm5Params.CMPCTL_LOADBMODE = 0; EPwm5Params.CMPA = 500;
EPwm5Params.CMPB = 32000;
/*-- Setup Action-Qualifier (AQ) Submodule --*/ EPwm5Params.AQCTLA = 36;
EPwm5Params.AQCTLB = 264; EPwm5Params.AQCSFRC_CSFA = 0; EPwm5Params.AQCSFRC_CSFB = 0; EPwm5Params.AQCSFRC_RLDCSF = 0;
Código fonte do programa SRCC
EPwm5Params.DBCTL_IN_MODE = 0; EPwm5Params.DBCTL_POLSEL = 0; EPwm5Params.DBRED = 0.0; EPwm5Params.DBFED = 0.0;
/*-- Setup Event-Trigger (ET) Submodule --*/ EPwm5Params.ETSEL_SOCAEN = 1; EPwm5Params.ETSEL_SOCASEL = 2; EPwm5Params.ETPS_SOCAPRD = 1; EPwm5Params.ETSEL_SOCBEN = 0; EPwm5Params.ETSEL_SOCBSEL = 1; EPwm5Params.ETPS_SOCBPRD = 1; EPwm5Params.ETSEL_INTEN = 0; EPwm5Params.ETSEL_INTSEL = 1; EPwm5Params.ETPS_INTPRD = 1;
/*-- Setup PWM-Chopper (PC) Submodule --*/ EPwm5Params.PCCTL_CHPEN = 0;
EPwm5Params.PCCTL_CHPFREQ = 0; EPwm5Params.PCCTL_OSHTWTH = 0; EPwm5Params.PCCTL_CHPDUTY = 0;
/*-- Setup Trip-Zone (TZ) Submodule --*/ EPwm5Params.TZSEL = 0; EPwm5Params.TZCTL_TZA = 3; EPwm5Params.TZCTL_TZB = 3; EPwm5Params.TZEINT_OST = 0; EPwm5Params.TZEINT_CBC = 0; /*-- Initial ePWM5 --*/ config_ePWMRegs(&EPwm5Regs, &EPwm5Params); }
/* user code (Initialize function Body) */ // RTW Custom code
// Initialize function }
/* Model terminate function */ void PWM_v19_terminate(void) {
/* (no terminate code required) */ }
/*
* File trailer for Real-Time Workshop generated code. *
* [EOF] */
A3.4 Arquivo: PWM_v19.h
/*
* File: PWM_v19.h *
* Real-Time Workshop code generated for Simulink model PWM_v19. *
* Model version : 1.182
* Real-Time Workshop file version : 7.4 (R2009b) 29-Jun-2009 * Real-Time Workshop file generated on : Tue Mar 22 20:18:42 2011 * TLC version : 7.4 (Jul 14 2009) * C/C++ source code generated on : Tue Mar 22 20:18:43 2011 *
* Target selection: ccslink_ert.tlc
* Embedded hardware selection: Texas Instruments->C2000 * Code generation objectives: Unspecified
* Validation result: Not run */ #ifndef RTW_HEADER_PWM_v19_h_ #define RTW_HEADER_PWM_v19_h_ #ifndef PWM_v19_COMMON_INCLUDES_ # define PWM_v19_COMMON_INCLUDES_ #include <stddef.h> #include <string.h> #include "rtwtypes.h" #include "DSP2833x_Device.h" #include "DSP2833x_Gpio.h" #include "DSP2833x_Examples.h" #include "IQmathLib.h" #endif /* PWM_v19_COMMON_INCLUDES_ */ #include "PWM_v19_types.h" // #include "PWM_v19_byMBA.h"
/* Macros for accessing real-time model data structure */ #ifndef rtmGetErrorStatus
# define rtmGetErrorStatus(rtm) ((rtm)->errorStatus)