dsp

LABORATORIO 1

#include "DSP2833x_Device.h"

#include "DSP2833x_Examples.h"

#include "math.h"

#include "lab1.h"

float salida[1000]; //variable de salida

longint k=0; //muestra k

float T=0; //periodo de muestreo

constfloat pi=3.1415926535897932384;

float w=0; //velocidad angular en rad/seg

float t=0; //variable de entrada o tiempo

main(void)

{

DINT; //deshabilita interrupciones

DRTM; //deshabilita interrupciones real time mode

InitSysCtrl(); //inicializa el sistema como PLL,clocks,watchdog

InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos

IER = 0x0000; //limpia máscara de interrupciones

IFR = 0x0000; //limpia bandera de interrupciones

InitPieVectTable(); //inicializa tabla de interrupciones por defecto

EINT; //habilita interrupciones

ERTM;

T=0.001; //carga el periodo de muestreo =1KHz

w=2*pi*10; //carga la velocidad angular

for (k=0;k<1000;k++)

{

t=k*T;

salida[k]=func_coseno(w*t);

};

}

floatfunc_coseno(float angulo)

{

return 100*cos(angulo);

}

LABORATORIO 2



#include "lab2.h"

longinti,k,l;

longintretardo=5000000;

longint test=0; // Variable parabuscarerrores

voidmain(void) {



InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog






ERTM;

EALLOW;

//Pull up y Multiplexor de los pines

GpioCtrlRegs.GPAPUD.bit.GPIO0 = 0; // Habilitar pullup en GPIO0






GpioCtrlRegs.GPAMUX1.bit.GPIO0 = 0; // GPIO0 = GPIO0


GpioCtrlRegs.GPAMUX1.bit.GPIO2 = 1; // GPIO2 = PWM2A

GpioCtrlRegs.GPAMUX1.bit.GPIO3 = 2; // GPIO3 = ECAP5


GpioCtrlRegs.GPAMUX1.bit.GPIO5 = 3; // GPIO5 = ECAP1

GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 0;

// Habilitar un GPIO como salida en el GPIO6, usar el "set" para puesta a uno


GpioDataRegs.GPASET.bit.GPIO6 = 1; // cargar latch de salida = 1


GpioCtrlRegs.GPADIR.bit.GPIO6 = 1; // GPIO6 = es salida



#include "lab2.h"

longinti,k,l;



voidmain(void) {









ERTM;

EALLOW;




















#include "lab2.h"

longinti,k,l;



voidmain(void) {









ERTM;

EALLOW;


















while(1){

for (i=0;i<60;i++){ //Los retardo son proporcionales a la velocidad de la memoria

GpioDataRegs.GPBTOGGLE.bit.GPIO0 = 1; // Modificar alternando

estado de GPIO0

for (k=0;k<retardo;k++); // bloque de retardo


estado de GPIO0


estado de GPIO1



estado de GPIO1


estado de GPIO2



estado de GPIO2


estado de GPIO3



estado de GPIO3

GpioDataRegs.GPCTOGGLE.bit.GPIO4 = 1; // Modificar alternando

estado de GPIO4



estado de GPIO4


estado de GPIO5



estado de GPIO5


estado de GPIO6



estado de GPIO6


estado de GPIO7



estado de GPIO7


estado de GPIO6



estado de GPIO6


estado de GPIO5



estado de GPIO5


estado de GPIO4



estado de GPIO4


estado de GPIO3



estado de GPIO3


estado de GPIO2



estado de GPIO2


estado de GPIO1



estado de GPIO0

}

}

}

LABORATORIO 3



#include "lab3.h"

#include "monitorF28335.h"

voidmain(void)

{




InitSciaGpio(); // inicializa los pines scia para ser usados con su función sci






ERTM;

IniciarSerial(); //Inicialización de los parámetros del puerto serial A

do{ //hacer loop por lo menos una vez

IteraSerial(); //Rutina de espera del puerto serial

}while(1); //Itera infinitamente

}

MONITOR

#include "stdlib.h"



const float mipi=3.1415926535897932384626433832795;

Uint16 LoopCount;

Uint16 SendChar;

Uint16 ReceivedChar;

voidAddrCant(void);

Uint32 Direccion=0;

int16 *memoria=0;

Uint32 Cantidad=0;

int caso=0;

Uint32 j=0;

voidIniciarSerial(void)

{

scia_fifo_init(); // Inicializa el FIFO del SCI

scia_init(); // Inicializa el lazo de iteración

SendChar = 0;

}

voidIteraSerial(void)

{

while(SciaRegs.SCIFFRX.bit.RXFFST ==0) {

return;

}; // espera por XRDY =1

ReceivedChar = SciaRegs.SCIRXBUF.all; //se lee el byte

SendChar=ReceivedChar; //se guarda en una variable

scia_xmit(SendChar); //se retransmite como ECO para que la PC sepa

caso=ReceivedChar; // se decodifica

switch (caso) { // con el CASE

case 0:

LeerDSP(); // Si el comando es un CERO Leer DSP

break;

case 1:

LeerDSP();

break;

case 2:

LeerDSP();

break;

case 3:

EscribirDSP(); // Si el comando es un TRES Escribir DSP

break;

case 4:

EscribirDSP();

break;

case 5:

EscribirDSP();

break;

};

}

voidLeerDSP(void)

{

AddrCant(); //Averiguar la Dirección de memoria y cuantos datos

for (j=0;j<Cantidad+1;j++)

{

memoria=0;

SendChar=memoria[Direccion]; // Buscar el dato en memoria

Direccion++;

do{

while(SciaRegs.SCIFFRX.bit.RXFFST ==0) { } // esperar a XRDY =1 estado

listo

ReceivedChar = SciaRegs.SCIRXBUF.all; //Leer byte del buffer

} while (ReceivedChar!=0x40); // Esperar a que sea el byte 64

scia_xmit(SendChar>>8); //Enviar parte alta del dato

do{


listo

ReceivedChar = SciaRegs.SCIRXBUF.all;

} while (ReceivedChar!=0x40); // Esperar a que sea el byte 64

scia_xmit(SendChar); //Enviar parte baja del dato

};

}

voidEscribirDSP(void)

{

AddrCant();

for (j=0;j<Cantidad+1;j++) // Preparar la cantidad de veces

{


listo


scia_xmit(ReceivedChar); // Enviar ECO

SendChar = ReceivedChar<<8; // Sube el valor recibido a la parte alta


listo


scia_xmit(ReceivedChar); // Enviar ECO

SendChar = SendChar+ ReceivedChar; // Agrega parte baja del dato

memoria[Direccion]=SendChar; // Graba el valor del dato en memoria

Direccion++; // Incrementa para la próxima dirección

};

}

voidscia_init()

{

SciaRegs.SCICCR.all =0x0007; // 1 stop bit, No loopback

// No parity,8char bits,

// modo asíncrono, protocolo idle-line línea en espera

SciaRegs.SCICCR.bit.SCICHAR = 7;

SciaRegs.SCICTL1.all =0x0003; // Habilitar TX, RX, SCICLK interno,

// Deshabilitar RX ERR, SLEEP, TXWAKE

SciaRegs.SCICTL2.all =0x0003;

SciaRegs.SCICTL2.bit.TXINTENA = 0;

SciaRegs.SCICTL2.bit.RXBKINTENA =1;

SciaRegs.SCIHBAUD =0x0000;

SciaRegs.SCILBAUD =0x0028; //a 150mhz

SciaRegs.SCICCR.bit.LOOPBKENA =0; // No habilitar loop back

SciaRegs.SCICTL1.all =0x0023; // SCI fuera de Reset

}

voidscia_xmit(int a)

{

SciaRegs.SCITXBUF=a; // Cargar buffer para transmitir

}

voidscia_fifo_init()

{

SciaRegs.SCIFFTX.all=0xE040;

SciaRegs.SCIFFRX.all=0x204f;

SciaRegs.SCIFFCT.all=0x0;

}

voidAddrCant(void)

{

inti=0;

Direccion=0;

ReceivedChar=0;

for (i=0;i<4;i++)

{


listo


scia_xmit(ReceivedChar);// Enviar ECO

Direccion=(Direccion<<8)+ReceivedChar; // Ir agregando Dirección

};

for (i=0;i<4;i++)

{


listo


scia_xmit(ReceivedChar);// Enviar ECO

Cantidad=(Cantidad<<8)+ReceivedChar; // Ir agregando Cantidad

};

}

LABORATORIO 4



#include "lab4.h"


#define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =

150/(2*3) = 25.0 MHz

#define ADC_CKPS 0x0 // ADC module clock = HSPCLK/1 = 25.5MHz/(1)

= 25.0 MHz

#define ADC_MODO 0x0 // 1 es simultáneo 0 es secuencial

#define ADC_SHCLK 0x1 // S/H ancho en periodos ADC = 2 ciclos ADC

longinti,k;

unsignedintResultadoADC[16];

voidmain(void)

{




EALLOW;

SysCtrlRegs.HISPCP.all = ADC_MODCLK; // HSPCLK =

SYSCLKOUT/ADC_MODCLK = 25MHz

EDIS;






InitAdc(); // inicializa ADC

AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS; // ADC module clock =

25MHz

AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK; // Modo Secuencial:

Ancho del S/H = (2+ACQ_PS)*ADC clock en ns

// En modo simultáneo sería: = (3+ACQ_PS)*ADC clock en ns

AdcRegs.ADCTRL3.bit.SMODE_SEL = ADC_MODO; // Secuencial

AdcRegs.ADCTRL1.bit.SEQ_CASC = 1; // 1 Cascaded mode

AdcRegs.ADCTRL1.bit.CONT_RUN = 0; // Modocontínuo

AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin

wrap around ADCRESULT

AdcRegs.ADCCHSELSEQ1.all = 0x3210; // Selecionarcanales 0-1-2-3

AdcRegs.ADCCHSELSEQ2.all = 0x7654;

AdcRegs.ADCCHSELSEQ3.all = 0xBA98;

AdcRegs.ADCCHSELSEQ4.all = 0xFEDC;

AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0xF; // Convertir y guardar 16

canales

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; // Arranque inicial del ADC


ERTM;



IteraSerial();

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; //Arranque de conversión SOC por

SW

while(AdcRegs.ADCST.bit.SEQ1_BSY ==1) {}; //Esperar a que termine

ResultadoADC[0]= AdcRegs.ADCRESULT0>>4; //Leer resultados

ResultadoADC[1]= AdcRegs.ADCRESULT2>>4;


}

LABORATORIO 5



#include "lab5.h"



150/(2*3) = 25.0 MHz


= 25.0 MHz



longinti,k;

// int max1; max2; max3;


void main(void)

{




EALLOW;



EDIS;






// ISR functions found within this file.

EALLOW; // This is needed to write to EALLOW protected register

GpioCtrlRegs.GPAPUD.bit.GPIO15 = 0;



GpioCtrlRegs.GPAMUX1.bit.GPIO15 = 0;



GpioCtrlRegs.GPADIR.bit.GPIO15 = 1;



PieVectTable.ADCINT = &adc_isr;

EDIS; // This is needed to disable write to EALLOW protected registers


// Enable ADCINT in PIE

PieCtrlRegs.PIEIER1.bit.INTx6 = 1;

IER |= M_INT1; // Enable CPU Interrupt 1


25MHz

AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK; // ModoSecuencial: Ancho

del S/H = (2+ACQ_PS)*ADC clock en ns




AdcRegs.ADCTRL1.bit.CONT_RUN = 1; // Modocontínuo

AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin

wrap around ADCRESULT

AdcRegs.ADCCHSELSEQ1.bit.CONV00=1110; //0x3210; // Selecionar

canales 0-1-2-3

AdcRegs.ADCCHSELSEQ1.bit.CONV01=0011;

AdcRegs.ADCCHSELSEQ1.bit.CONV02=1111;

AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0x2; // Convertir y guardar 3

canales



ERTM;



IteraSerial();

AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;

ResultadoADC[0]=AdcRegs.ADCRESULT14>>4;//A

ResultadoADC[1]=AdcRegs.ADCRESULT3>>4;//B

ResultadoADC[2]=AdcRegs.ADCRESULT15>>4;//C

if(ResultadoADC[0]>ResultadoADC[1]&&ResultadoADC[0]>ResultadoADC[2])

{

GpioDataRegs.GPADAT.bit.GPIO15=1;

}else{

if(ResultadoADC[1]>ResultadoADC[0]&&ResultadoADC[1]>ResultadoADC[2]){


}else{


}

}


}

LABORATORIO 6



#include "lab6.h"



150/(2*3) = 25.0 MHz


= 25.0 MHz



longinti,k;

unsignedint t1,t2,t0;


void main(void)

{




EALLOW;



EDIS;






// ISR para los timers de CPU

EALLOW; // Habilita cambio de registros

PieVectTable.TINT0 = &cpu_timer0_isr; //apuntar a subrutina interrupt de

timer0

PieVectTable.XINT13 = &cpu_timer1_isr;//apuntar a subrutina interrupt de

timer1

PieVectTable.TINT2 = &cpu_timer2_isr;//apuntar a subrutina interrupt de

timer2

EDIS; // Deshabilita cambio de registros


iniciarRegADC(); // iniciar parámetros propios para el ADC

preparaLuces(); // prepara GPIO para luces alternas

InitCpuTimers(); // inicializa los CpuTimers

ConfigCpuTimer(&CpuTimer0, 150, 1000000); // a 150MHz 1000000uSeg =

1segundo


4.5segundos


0.1segundos

CpuTimer0Regs.TCR.all = 0x4001; // Arrancar timer T0 TSS bit = 0



// Notar que cuando se usa .all es una instrucción directa de escritura

// con .bit para no modificar los otros bits se lee primero y luego se escribe

IER = M_INT1| M_INT13; // Interrupciones 1 y 13

IER |= M_INT14; // Aumentar interrupción 14

PieCtrlRegs.PIEIER1.bit.INTx7 = 1; // la interrupción TINT0 pasa por el PIE

XIntruptRegs.XNMICR.bit.SELECT= 0; // asegura que TINT1 está conectado a

INT13 y no XNMI


ERTM;



IteraSerial();


}

interruptvoid cpu_timer0_isr(void)

{

t0++;

CpuTimer0.InterruptCount++;

GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1; //alterna estado del led

PieCtrlRegs.PIEACK.all = PIEACK_GROUP1; //Reconocer interrupt grupo1

}

interrupt void cpu_timer1_isr(void)

{

t1++;


GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1; //alterna estado del led

// El Cpu reconoce solo la interrupción

EDIS;

}

interrupt void cpu_timer2_isr(void)

{ t2++;

EALLOW;


ResultadoADC[0]= AdcRegs.ADCRESULT0 >>4;

ResultadoADC[1]= AdcRegs.ADCRESULT1 >>4;

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; // Arranque de conversión del ADC

// El Cpu reconoce solo la interrupción

EDIS;

}

voidiniciarRegADC(void)

{


25MHz






AdcRegs.ADCTRL1.bit.CONT_RUN = 0; // No al modo contínuo

AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin wrap

around ADCRESULT






canales

AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 0; // No habilitar interrupción

SEQ1


}

voidpreparaLuces(void)

{

// Luces en el control Card

EALLOW;


GpioDataRegs.GPADAT.bit.GPIO31 = 1; // Latch a 1



GpioCtrlRegs.GPBPUD.bit.GPIO34 = 0; // Habilitar pullup en GPIO34

GpioDataRegs.GPBDAT.bit.GPIO34 = 0; // Latch a 0

GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0; // GPIO34 = GPIO34

GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1; // GPIO34 = es salida

EDIS;

}

LABORATORIO 7



#include "lab7.h"


#define EPWM1_TIMER_TBPRD 2000 // Period register

#define EPWM1_MAX_CMPA 1950

#define EPWM1_MIN_CMPA 50

#define EPWM1_MAX_CMPB 1950

#define EPWM1_MIN_CMPB 50

#define EPWM_CMP_UP 1

#define EPWM_CMP_DOWN 0

void main(void)

{




InitEPwm1Gpio();








PieVectTable.EPWM1_INT = &epwm1_isr;

SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 0;

EDIS;// Deshabilita cambio de registros

IniciaEPwm1();

EALLOW;


EDIS;

IER |= M_INT3; // Interrupción 3



ERTM;



IteraSerial();


}

interruptvoid epwm1_isr(void)

{

// Limpiar bandera de interrupción del Timer

EPwm1Regs.ETCLR.bit.INT = 1;

// Reconocer la interrupción del grupo 3 para que pueda haber más

PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;

}

void IniciaEPwm1()

{

// Configurar TBCLK

EPwm1Regs.TBPRD = EPWM1_TIMER_TBPRD; // Determina el

periodo 801 TBCLKs

EPwm1Regs.TBPHS.half.TBPHS = 0x0000; // La fase es 0

EPwm1Regs.TBCTR = 0x0000; // Contador a cero

// Configurar valores de los Comparadores

EPwm1Regs.CMPA.half.CMPA = EPWM1_MIN_CMPA; // Dar valor al

comparador A

EPwm1Regs.CMPB = EPWM1_MAX_CMPB; // Dar valor al

comparador B

// Configurar modo de conteo

EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Contar hacia

arriba y al llegar al periodo igual a cero

EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Deshabilitar carga de

fase

EPwm1Regs.TBCTL.bit.HSPCLKDIV = TB_DIV1; // Tasa del prescalador

del SYSCLKOUT

EPwm1Regs.TBCTL.bit.CLKDIV = TB_DIV1;

// Configurar shadowing modo de sombra

EPwm1Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW;

EPwm1Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW;

EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; // cargar en

cero

EPwm1Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;

// Configurar acciones

EPwm1Regs.AQCTLA.bit.CAU = AQ_SET; // Set PWM1A en evento

A, contar arriba

EPwm1Regs.AQCTLA.bit.CAD = AQ_CLEAR; // Clear PWM1A en

evento A, contar abajo

EPwm1Regs.AQCTLB.bit.CBU = AQ_SET; // Set PWM1B en evento

B, contar arriba

EPwm1Regs.AQCTLB.bit.CBD = AQ_CLEAR; // Clear PWM1B en

evento B, contar abajo

// Interrupción cuando se cambiaran los valores de comparación

EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO; // Seleccionar INT en

evento Zero

EPwm1Regs.ETSEL.bit.INTEN = 1; // Habilitar INT

EPwm1Regs.ETPS.bit.INTPRD = ET_3RD; // Generar INT en el 3er

evento

}

LABORATORIO 8



#include "lab8.h"



150/(2*3) = 25.0 MHz


= 25.0 MHz



longinti,k;


EPWM_INFO epwm1_info;


















#define EPWM_CMP_UP 1

#define EPWM_CMP_DOWN 0

void main(void)

{




InitEPwm1Gpio();

InitEPwm2Gpio();

InitEPwm3Gpio();

EALLOW;



EDIS;











EDIS; // Deshabilita cambio de registros

EALLOW;


EDIS;

InitEPwm1Example();

InitEPwm2Example();

InitEPwm3Example();

EALLOW;


EDIS;


iniciarRegADC(); // iniciar parámetros propios para el ADC

preparaLuces(); // prepara GPIO para luces alternas

IER |= M_INT3; // Interrupción 3





ERTM;



IteraSerial();


}

voidiniciarRegADC(void)

{


25MHz






AdcRegs.ADCTRL1.bit.CONT_RUN = 0; // No al modo contínuo

AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin wrap

around ADCRESULT






canales

AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 0; // No habilitar interrupción

SEQ1


}

voidpreparaLuces(void)

{

// Luces en el control Card

EALLOW;


GpioDataRegs.GPADAT.bit.GPIO31 = 1; // Latch a 1




GpioDataRegs.GPBDAT.bit.GPIO34 = 0; // Latch a 0



EDIS;

}

interrupt void epwm1_isr(void)

{

// Update the CMPA and CMPB values

update_compare(&epwm1_info);

// Clear INT flag for this timer


// Acknowledge this interrupt to receive more interrupts from group 3


}


{







}


{







}

void InitEPwm1Example()

{

// Setup TBCLK

EPwm1Regs.TBPRD = EPWM1_TIMER_TBPRD; // Set timer period

801 TBCLKs

EPwm1Regs.TBPHS.half.TBPHS = 0x0000; // Phase is 0

EPwm1Regs.TBCTR = 0x0000; // Clear counter

// Set Compare values

EPwm1Regs.CMPA.half.CMPA = EPWM1_MIN_CMPA; // Set compare A

value

EPwm1Regs.CMPB = EPWM1_MAX_CMPB; // Set Compare B

value

// Setup counter mode

EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Count up

EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Disable phase

loading

EPwm1Regs.TBCTL.bit.HSPCLKDIV = TB_DIV1; // Clock ratio to

SYSCLKOUT


// Setup shadowing



EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; // Load on Zero


// Set actions

EPwm1Regs.AQCTLA.bit.CAU = AQ_SET; // Set PWM1A on event A,

up count

EPwm1Regs.AQCTLA.bit.CAD = AQ_CLEAR; // Clear PWM1A on

event A, down count

EPwm1Regs.AQCTLB.bit.CBU = AQ_SET; // Set PWM1B on event B,

up count

EPwm1Regs.AQCTLB.bit.CBD = AQ_CLEAR; // Clear PWM1B on

event B, down count

// Interrupt where we will change the Compare Values

EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO; // Select INT on Zero

event

EPwm1Regs.ETSEL.bit.INTEN = 1; // Enable INT

EPwm1Regs.ETPS.bit.INTPRD = ET_3RD; // Generate INT on 3rd

event

// Information this example uses to keep track

// of the direction the CMPA/CMPB values are

// moving, the min and max allowed values and

// a pointer to the correct ePWM registers

epwm1_info.EPwm_CMPA_Direction = EPWM_CMP_UP; // Start by

increasing CMPA &

epwm1_info.EPwm_CMPB_Direction = EPWM_CMP_DOWN; // decreasing

CMPB

epwm1_info.EPwmTimerIntCount = 0; // Zero the interrupt counter

epwm1_info.EPwmRegHandle = &EPwm1Regs; // Set the pointer to the

ePWM module

epwm1_info.EPwmMaxCMPA = EPWM1_MAX_CMPA; // Setup min/max

CMPA/CMPB values

epwm1_info.EPwmMinCMPA = EPWM1_MIN_CMPA;

epwm1_info.EPwmMaxCMPB = EPWM1_MAX_CMPB;

epwm1_info.EPwmMinCMPB = EPWM1_MIN_CMPB;

}

void InitEPwm2Example()

{

// Setup TBCLK


801 TBCLKs





value

EPwm2Regs.CMPB = EPWM2_MIN_CMPB; // Set Compare B value

// Setup counter mode

EPwm2Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Count up

EPwm2Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Disable phase

loading


SYSCLKOUT


// Setup shadowing



EPwm2Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; // Load on Zero


// Set actions

EPwm2Regs.AQCTLA.bit.CAU = AQ_SET; // Set PWM2A on event A,

up count

EPwm2Regs.AQCTLA.bit.CBD = AQ_CLEAR; // Clear PWM2A on event

B, down count

EPwm2Regs.AQCTLB.bit.ZRO = AQ_CLEAR; // Clear PWM2B on zero

EPwm2Regs.AQCTLB.bit.PRD = AQ_SET ; // Set PWM2B on period



event



event






increasing CMPA &

epwm2_info.EPwm_CMPB_Direction = EPWM_CMP_UP; // increasing

CMPB



ePWM module


CMPA/CMPB values




}

void InitEPwm3Example(void)

{

// Setup TBCLK

EPwm3Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN;// Count

up/down


EPwm3Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Disable phase loading




SYSCLKOUT


// Setup shadow register load on ZERO



EPwm3Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO;




value

EPwm3Regs.CMPB = EPWM3_MAX_CMPB; // Set Compare B value

// Set Actions

EPwm3Regs.AQCTLA.bit.PRD = AQ_SET; // Set PWM3A on period

EPwm3Regs.AQCTLA.bit.CBD = AQ_CLEAR; // Clear PWM3A on event

B, down count

EPwm3Regs.AQCTLB.bit.PRD = AQ_CLEAR; // Clear PWM3A on

period

EPwm3Regs.AQCTLB.bit.CAU = AQ_SET; // Set PWM3A on event A,

up count



event



event






increasing CMPA &

epwm3_info.EPwm_CMPB_Direction = EPWM_CMP_DOWN; // decreasing

CMPB



ePWM module


CMPA/CMPB values




}

voidupdate_compare(EPWM_INFO *epwm_info)

{

// Every 10'th interrupt, change the CMPA/CMPB values

if(epwm_info->EPwmTimerIntCount == 10)

{

epwm_info->EPwmTimerIntCount = 0;

// If we were increasing CMPA, check to see if

// we reached the max value. If not, increase CMPA

// else, change directions and decrease CMPA

if(epwm_info->EPwm_CMPA_Direction == EPWM_CMP_UP)

{

if(epwm_info->EPwmRegHandle->CMPA.half.CMPA<epwm_info-

>EPwmMaxCMPA)

{

epwm_info->EPwmRegHandle->CMPA.half.CMPA++;

}

else

{

epwm_info->EPwm_CMPA_Direction = EPWM_CMP_DOWN;

epwm_info->EPwmRegHandle->CMPA.half.CMPA--;

}

}

// If we were decreasing CMPA, check to see if

// we reached the min value. If not, decrease CMPA

// else, change directions and increase CMPA

else

{

if(epwm_info->EPwmRegHandle->CMPA.half.CMPA == epwm_info-

>EPwmMinCMPA)

{

epwm_info->EPwm_CMPA_Direction = EPWM_CMP_UP;

epwm_info->EPwmRegHandle->CMPA.half.CMPA++;

}

else

{

epwm_info->EPwmRegHandle->CMPA.half.CMPA--;

}

}

// If we were increasing CMPB, check to see if

// we reached the max value. If not, increase CMPB

// else, change directions and decrease CMPB

if(epwm_info->EPwm_CMPB_Direction == EPWM_CMP_UP)

{

if(epwm_info->EPwmRegHandle->CMPB <epwm_info->EPwmMaxCMPB)

{

epwm_info->EPwmRegHandle->CMPB++;

}

else

{

epwm_info->EPwm_CMPB_Direction = EPWM_CMP_DOWN;

epwm_info->EPwmRegHandle->CMPB--;

}

}

// If we were decreasing CMPB, check to see if

// we reached the min value. If not, decrease CMPB

// else, change directions and increase CMPB

else

{

if(epwm_info->EPwmRegHandle->CMPB == epwm_info->EPwmMinCMPB)

{

epwm_info->EPwm_CMPB_Direction = EPWM_CMP_UP;

epwm_info->EPwmRegHandle->CMPB++;

}

else

{

epwm_info->EPwmRegHandle->CMPB--;

}

}

}

else

{

epwm_info->EPwmTimerIntCount++;

}

return;

}

UNO DE LOS PRIMEROS LABOS

while(1){

for (i=0;i<60;i++){ //Los retardo son proporcionales a la velocidad de

la memoria

GpioDataRegs.GPBTOGGLE.bit.GPIO60 = 1; // Modificar

alternando estado de GPIO60



















GpioDataRegs.GPCTOGGLE.bit.GPIO64 = 1; // Modificar


















































}

}

}

CONFIGURAR

1) Abrir el codecomposer

2) Seleccionar el espacio de trabajo

3) Verificar que este abierto el programa (LAB1)

4) Compilar en Project->BuildAll

5) Verificar que no haya errores

6) Ir a View->Target Configurations

7) Aparece la ventana de configuración

8) Abrimos Projects->Lab1->XDS100

9) Click derecho en XDS100 y luego en LaunchSelectedConfiguration

10) Tenemos el entorno de prueba

11) Para conectar con la tarjeta Run->Connect Target

12) Para cargar el programa Run->Load->Load Program

13) Seleccionamos el programa que deseamos cargar

14) En nuestro caso C->DSP28335_2013>Lab1->Debug->lab01.out

15) Para correr el programa hacer click en la flecha verde (F8)

PRIMEROS LABOS






GpioCtrlRegs.GPCPUD.bit.GPIO64 = 0; // Habilitar pullup en GPIO64




//Es señal digital





GpioCtrlRegs.GPCMUX1.bit.GPIO64 = 0; // GPIO64 = GPIO64




//Es salida





GpioCtrlRegs.GPCDIR.bit.GPIO64 = 1; // GPIO64 = es salida




EDIS;

GpioDataRegs.GPBDAT.bit.GPIO60 = 0; // GPIO60=0




GpioDataRegs.GPCDAT.bit.GPIO64 = 0; // GPIO64=0




EINT;

ERTM;

while(1){

for (i=0;i<60;i++){ //Los retardo son proporcionale

dsp

Documents