LABORATORIO 1 LABORATORIO 2

#include "DSP2833x_Device.h" #include "DSP2833x_Device.h"

#include "DSP2833x_Examples.h" #include "DSP2833x_Examples.h"

#include "math.h" #include "lab2.h"

#include "lab1.h" longinti,k,l;

float salida[1000]; //variable de salida longintretardo=5000000;

longint k=0; //muestra k longint test=0; // Variable parabuscarerrores

float T=0; //periodo de muestreo voidmain(void) {

constfloat pi=3.1415926535897932384; DINT; //deshabilita interrupciones

float w=0; //velocidad angular en rad/seg DRTM; //deshabilita interrupciones real time mode

float t=0; //variable de entrada o tiempo InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog

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

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

DINT; //deshabilita interrupciones IFR = 0x0000; //limpia bandera de interrupciones

DRTM; //deshabilita interrupciones real time mode InitPieVectTable(); //inicializa tabla de interrupciones por defecto

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

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

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

IFR = 0x0000; //limpia bandera de interrupciones //Pull up y Multiplexor de los pines

InitPieVectTable(); //inicializa tabla de interrupciones por defecto GpioCtrlRegs.GPAPUD.bit.GPIO0 = 0; // Habilitar pullup en GPIO0

EINT; //habilita interrupciones GpioCtrlRegs.GPAPUD.bit.GPIO1 = 0; // Habilitar pullup en GPIO1

ERTM; GpioCtrlRegs.GPAPUD.bit.GPIO2 = 0; // Habilitar pullup en GPIO2

T=0.001; //carga el periodo de muestreo =1KHz GpioCtrlRegs.GPAPUD.bit.GPIO3 = 0; // Habilitar pullup en GPIO3

w=2*pi*10; //carga la velocidad angular GpioCtrlRegs.GPAPUD.bit.GPIO4 = 0; // Habilitar pullup en GPIO4

for (k=0;k<1000;k++) GpioCtrlRegs.GPAPUD.bit.GPIO5 = 0; // Habilitar pullup en GPIO5

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

t=k*T; GpioCtrlRegs.GPAMUX1.bit.GPIO1 = 0; // GPIO1 = GPIO1

salida[k]=func_coseno(w*t); GpioCtrlRegs.GPAMUX1.bit.GPIO2 = 1; // GPIO2 = PWM2A

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

} GpioCtrlRegs.GPAMUX1.bit.GPIO4 = 0; // GPIO4 = GPIO4

floatfunc_coseno(float angulo) GpioCtrlRegs.GPAMUX1.bit.GPIO5 = 3; // GPIO5 = ECAP1

{ GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 0;

return 100*cos(angulo); // Habilitar un GPIO como salida en el GPIO6, usar el "set" para puesta a uno

} GpioCtrlRegs.GPAPUD.bit.GPIO6 = 0; // Habilitar pullup en GPIO6

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

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

 GpioCtrlRegs.GPADIR.bit.GPIO6 = 1; // GPIO6 = es salida #include "DSP2833x_Examples.h"

#include "DSP2833x_Device.h" #include "lab2.h"

#include "DSP2833x_Examples.h" longinti,k,l;

#include "lab2.h" longintretardo=5000000;

longinti,k,l; longint test=0; // Variable parabuscarerrores

longintretardo=5000000; voidmain(void) {

longint test=0; // Variable parabuscarerrores DINT; //deshabilita interrupciones

voidmain(void) { DRTM; //deshabilita interrupciones real time mode

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

DRTM; //deshabilita interrupciones real time mode InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos

InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog IER = 0x0000; //limpia máscara de interrupciones

InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos IFR = 0x0000; //limpia bandera de interrupciones

IER = 0x0000; //limpia máscara de interrupciones InitPieVectTable(); //inicializa tabla de interrupciones por defecto

IFR = 0x0000; //limpia bandera de interrupciones EINT; //habilita interrupciones

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

EINT; //habilita interrupciones EALLOW;

ERTM; //Pull up y Multiplexor de los pines

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

//Pull up y Multiplexor de los pines GpioCtrlRegs.GPAPUD.bit.GPIO1 = 0; // Habilitar pullup en GPIO1

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

GpioCtrlRegs.GPAPUD.bit.GPIO1 = 0; // Habilitar pullup en GPIO1 GpioCtrlRegs.GPAPUD.bit.GPIO3 = 0; // Habilitar pullup en GPIO3

GpioCtrlRegs.GPAPUD.bit.GPIO2 = 0; // Habilitar pullup en GPIO2 GpioCtrlRegs.GPAPUD.bit.GPIO4 = 0; // Habilitar pullup en GPIO4

GpioCtrlRegs.GPAPUD.bit.GPIO3 = 0; // Habilitar pullup en GPIO3 GpioCtrlRegs.GPAPUD.bit.GPIO5 = 0; // Habilitar pullup en GPIO5

GpioCtrlRegs.GPAPUD.bit.GPIO4 = 0; // Habilitar pullup en GPIO4 GpioCtrlRegs.GPAPUD.bit.GPIO6 = 0; // Habilitar pullup en GPIO6

GpioCtrlRegs.GPAPUD.bit.GPIO5 = 0; // Habilitar pullup en GPIO5 GpioCtrlRegs.GPAPUD.bit.GPIO7 = 0; // Habilitar pullup en GPIO7

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

GpioCtrlRegs.GPAPUD.bit.GPIO7 = 0; // Habilitar pullup en GPIO7 GpioCtrlRegs.GPAMUX1.bit.GPIO1 = 0; // GPIO1 = GPIO1

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

GpioCtrlRegs.GPAMUX1.bit.GPIO1 = 0; // GPIO1 = GPIO1 GpioCtrlRegs.GPAMUX1.bit.GPIO3 = 0; // GPIO3 = GPIO3

GpioCtrlRegs.GPAMUX1.bit.GPIO2 = 0; // GPIO2 = GPIO2 GpioCtrlRegs.GPAMUX1.bit.GPIO4 = 0; // GPIO4 = GPIO4

GpioCtrlRegs.GPAMUX1.bit.GPIO3 = 0; // GPIO3 = GPIO3 GpioCtrlRegs.GPAMUX1.bit.GPIO5 = 0; // GPIO5 = GPIO5

GpioCtrlRegs.GPAMUX1.bit.GPIO4 = 0; // GPIO4 = GPIO4 GpioCtrlRegs.GPAMUX1.bit.GPIO6 = 0; // GPIO6 = GPIO6

GpioCtrlRegs.GPAMUX1.bit.GPIO5 = 0; // GPIO5 = GPIO5 GpioCtrlRegs.GPAMUX1.bit.GPIO7 = 0; // GPIO7 = GPIO7

GpioCtrlRegs.GPAMUX1.bit.GPIO6 = 0; // GPIO6 = GPIO6 while(1){

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

#include "DSP2833x_Device.h" GpioDataRegs.GPBTOGGLE.bit.GPIO0 = 1; // Modificar alternando

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

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

estado de GPIO0 estado de GPIO5

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

estado de GPIO1 estado de GPIO4

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

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

estado de GPIO1 estado de GPIO4

GpioDataRegs.GPBTOGGLE.bit.GPIO2 = 1; // Modificar alternando GpioDataRegs.GPBTOGGLE.bit.GPIO3 = 1; // Modificar alternando

estado de GPIO2 estado de GPIO3

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

GpioDataRegs.GPBTOGGLE.bit.GPIO2 = 1; // Modificar alternando GpioDataRegs.GPBTOGGLE.bit.GPIO3 = 1; // Modificar alternando

estado de GPIO2 estado de GPIO3

GpioDataRegs.GPBTOGGLE.bit.GPIO3 = 1; // Modificar alternando GpioDataRegs.GPBTOGGLE.bit.GPIO2 = 1; // Modificar alternando

estado de GPIO3 estado de GPIO2

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

GpioDataRegs.GPBTOGGLE.bit.GPIO3 = 1; // Modificar alternando GpioDataRegs.GPBTOGGLE.bit.GPIO2 = 1; // Modificar alternando

estado de GPIO3 estado de GPIO2

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

estado de GPIO4 estado de GPIO1

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

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

estado de GPIO4 estado de GPIO0

GpioDataRegs.GPCTOGGLE.bit.GPIO5 = 1; // Modificar alternando }

estado de GPIO5
}
for (k=0;k<retardo;k++); // bloque de retardo
}
GpioDataRegs.GPCTOGGLE.bit.GPIO5 = 1; // Modificar alternando
estado de GPIO5 LABORATORIO 3

GpioDataRegs.GPCTOGGLE.bit.GPIO6 = 1; // Modificar alternando #include "DSP2833x_Device.h"

estado de GPIO6
#include "DSP2833x_Examples.h"
for (k=0;k<retardo;k++); // bloque de retardo
#include "lab3.h"
GpioDataRegs.GPCTOGGLE.bit.GPIO6 = 1; // Modificar alternando
estado de GPIO6 #include "monitorF28335.h"

GpioDataRegs.GPCTOGGLE.bit.GPIO7 = 1; // Modificar alternando voidmain(void)

estado de GPIO7
{
for (k=0;k<retardo;k++); // bloque de retardo
DINT; //deshabilita interrupciones
GpioDataRegs.GPCTOGGLE.bit.GPIO7 = 1; // Modificar alternando
estado de GPIO7 DRTM; //deshabilita interrupciones real time mode

GpioDataRegs.GPCTOGGLE.bit.GPIO6 = 1; // Modificar alternando InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog

estado de GPIO6
InitSciaGpio(); // inicializa los pines scia para ser usados con su función sci
for (k=0;k<retardo;k++); // bloque de retardo
InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos
GpioDataRegs.GPCTOGGLE.bit.GPIO6 = 1; // Modificar alternando
estado de GPIO6 IER = 0x0000; //limpia máscara de interrupciones

GpioDataRegs.GPCTOGGLE.bit.GPIO5 = 1; // Modificar alternando IFR = 0x0000; //limpia bandera de interrupciones

estado de GPIO5
InitPieVectTable(); //inicializa tabla de interrupciones por defecto caso=ReceivedChar; // se decodifica

EINT; //habilita interrupciones switch (caso) { // con el CASE

ERTM; case 0:

IniciarSerial(); //Inicialización de los parámetros del puerto serial A LeerDSP(); // Si el comando es un CERO Leer DSP

do{ //hacer loop por lo menos una vez break;

IteraSerial(); //Rutina de espera del puerto serial case 1:

}while(1); //Itera infinitamente LeerDSP();

} break;

MONITOR case 2:

#include "stdlib.h" LeerDSP();

#include "DSP2833x_Device.h" break;

#include "monitorF28335.h" case 3:

const float mipi=3.1415926535897932384626433832795; EscribirDSP(); // Si el comando es un TRES Escribir DSP

Uint16 LoopCount; break;

Uint16 SendChar; case 4:

Uint16 ReceivedChar; EscribirDSP();

voidAddrCant(void); break;

Uint32 Direccion=0; case 5:

int16 *memoria=0; EscribirDSP();

Uint32 Cantidad=0; break;

int caso=0; };

Uint32 j=0; }

voidIniciarSerial(void) voidLeerDSP(void)

{ {

scia_fifo_init(); // Inicializa el FIFO del SCI AddrCant(); //Averiguar la Dirección de memoria y cuantos datos

scia_init(); // Inicializa el lazo de iteración for (j=0;j<Cantidad+1;j++)

SendChar = 0; {

} memoria=0;

voidIteraSerial(void) SendChar=memoria[Direccion]; // Buscar el dato en memoria

{ Direccion++;

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

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

listo
}; // espera por XRDY =1
ReceivedChar = SciaRegs.SCIRXBUF.all; //Leer byte del buffer
ReceivedChar = SciaRegs.SCIRXBUF.all; //se lee el byte
} while (ReceivedChar!=0x40); // Esperar a que sea el byte 64
SendChar=ReceivedChar; //se guarda en una variable
scia_xmit(SendChar>>8); //Enviar parte alta del dato
scia_xmit(SendChar); //se retransmite como ECO para que la PC sepa
do{
while(SciaRegs.SCIFFRX.bit.RXFFST ==0) { } // esperar a XRDY =1 estado SciaRegs.SCILBAUD =0x0028; //a 150mhz
listo
SciaRegs.SCICCR.bit.LOOPBKENA =0; // No habilitar loop back
ReceivedChar = SciaRegs.SCIRXBUF.all;
SciaRegs.SCICTL1.all =0x0023; // SCI fuera de Reset
} while (ReceivedChar!=0x40); // Esperar a que sea el byte 64
}
scia_xmit(SendChar); //Enviar parte baja del dato
voidscia_xmit(int a)
};
{
}
SciaRegs.SCITXBUF=a; // Cargar buffer para transmitir
voidEscribirDSP(void)
}
{

AddrCant();
voidscia_fifo_init()
for (j=0;j<Cantidad+1;j++) // Preparar la cantidad de veces
{
{
SciaRegs.SCIFFTX.all=0xE040;
while(SciaRegs.SCIFFRX.bit.RXFFST ==0) { } // esperar a XRDY =1 estado
listo SciaRegs.SCIFFRX.all=0x204f;

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

scia_xmit(ReceivedChar); // Enviar ECO }

SendChar = ReceivedChar<<8; // Sube el valor recibido a la parte alta voidAddrCant(void)

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

listo
inti=0;
ReceivedChar = SciaRegs.SCIRXBUF.all; //Leer byte del buffer
Direccion=0;
scia_xmit(ReceivedChar); // Enviar ECO
ReceivedChar=0;
SendChar = SendChar+ ReceivedChar; // Agrega parte baja del dato
for (i=0;i<4;i++)
memoria[Direccion]=SendChar; // Graba el valor del dato en memoria
{
Direccion++; // Incrementa para la próxima dirección
while(SciaRegs.SCIFFRX.bit.RXFFST ==0) { } // esperar a XRDY =1 estado
}; listo

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

voidscia_init() scia_xmit(ReceivedChar);// Enviar ECO

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

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

// No parity,8char bits, for (i=0;i<4;i++)

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

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

listo
SciaRegs.SCICTL1.all =0x0003; // Habilitar TX, RX, SCICLK interno,
ReceivedChar = SciaRegs.SCIRXBUF.all; //Leer byte del buffer
// Deshabilitar RX ERR, SLEEP, TXWAKE
scia_xmit(ReceivedChar);// Enviar ECO
SciaRegs.SCICTL2.all =0x0003;
Cantidad=(Cantidad<<8)+ReceivedChar; // Ir agregando Cantidad
SciaRegs.SCICTL2.bit.TXINTENA = 0;
};
SciaRegs.SCICTL2.bit.RXBKINTENA =1;
}
SciaRegs.SCIHBAUD =0x0000;
LABORATORIO 4 AdcRegs.ADCCHSELSEQ1.all = 0x3210; // Selecionarcanales 0-1-2-3

#include "DSP2833x_Device.h" AdcRegs.ADCCHSELSEQ2.all = 0x7654;

#include "DSP2833x_Examples.h" AdcRegs.ADCCHSELSEQ3.all = 0xBA98;

#include "lab4.h" AdcRegs.ADCCHSELSEQ4.all = 0xFEDC;

#include "monitorF28335.h" AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0xF; // Convertir y guardar 16

canales
#define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =
150/(2*3) = 25.0 MHz AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; // Arranque inicial del ADC

#define ADC_CKPS 0x0 // ADC module clock = HSPCLK/1 = 25.5MHz/(1) EINT; //habilita interrupciones
= 25.0 MHz
ERTM;
#define ADC_MODO 0x0 // 1 es simultáneo 0 es secuencial
IniciarSerial(); //Inicialización de los parámetros del puerto serial A
#define ADC_SHCLK 0x1 // S/H ancho en periodos ADC = 2 ciclos ADC
do{ //hacer loop por lo menos una vez
longinti,k;
IteraSerial();
unsignedintResultadoADC[16];
AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; //Arranque de conversión SOC por
voidmain(void) SW

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

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

DRTM; //deshabilita interrupciones real time mode ResultadoADC[1]= AdcRegs.ADCRESULT2>>4;

InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog }while(1); //Itera infinitamente

EALLOW; }

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

SYSCLKOUT/ADC_MODCLK = 25MHz
#include "DSP2833x_Device.h"
EDIS;
#include "DSP2833x_Examples.h"

#include "lab5.h"
InitSciaGpio(); // inicializa los pines scia para ser usados con su función sci
#include "monitorF28335.h"
InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos
#define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =
IER = 0x0000; //limpia máscara de interrupciones 150/(2*3) = 25.0 MHz

IFR = 0x0000; //limpia bandera de interrupciones #define ADC_CKPS 0x0 // ADC module clock = HSPCLK/1 = 25.5MHz/(1)
= 25.0 MHz
InitPieVectTable(); //inicializa tabla de interrupciones por defecto
#define ADC_MODO 0x0 // 1 es simultáneo 0 es secuencial
InitAdc(); // inicializa ADC
#define ADC_SHCLK 0x1 // S/H ancho en periodos ADC = 2 ciclos ADC
AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS; // ADC module clock =
25MHz longinti,k;

AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK; // Modo Secuencial: // int max1; max2; max3;

Ancho del S/H = (2+ACQ_PS)*ADC clock en ns
unsignedintResultadoADC[4];
// En modo simultáneo sería: = (3+ACQ_PS)*ADC clock en ns
void main(void)
AdcRegs.ADCTRL3.bit.SMODE_SEL = ADC_MODO; // Secuencial
{
AdcRegs.ADCTRL1.bit.SEQ_CASC = 1; // 1 Cascaded mode
DINT; //deshabilita interrupciones
AdcRegs.ADCTRL1.bit.CONT_RUN = 0; // Modocontínuo
DRTM; //deshabilita interrupciones real time mode
AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin
wrap around ADCRESULT InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog
 EALLOW; AdcRegs.ADCCHSELSEQ1.bit.CONV02=1111;

SysCtrlRegs.HISPCP.all = ADC_MODCLK; // HSPCLK = AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0x2; // Convertir y guardar 3

SYSCLKOUT/ADC_MODCLK = 25MHz canales

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

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

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

IER = 0x0000; //limpia máscara de interrupciones IniciarSerial(); //Inicialización de los parámetros del puerto serial A

IFR = 0x0000; //limpia bandera de interrupciones do{ //hacer loop por lo menos una vez

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

// ISR functions found within this file. AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;

EALLOW; // This is needed to write to EALLOW protected register ResultadoADC[0]=AdcRegs.ADCRESULT14>>4;//A

GpioCtrlRegs.GPAPUD.bit.GPIO15 = 0; ResultadoADC[1]=AdcRegs.ADCRESULT3>>4;//B

GpioCtrlRegs.GPAPUD.bit.GPIO16 = 0; ResultadoADC[2]=AdcRegs.ADCRESULT15>>4;//C

GpioCtrlRegs.GPAPUD.bit.GPIO17 = 0; if(ResultadoADC[0]>ResultadoADC[1]&&ResultadoADC[0]>ResultadoADC[2])

GpioCtrlRegs.GPAMUX1.bit.GPIO15 = 0; {

GpioCtrlRegs.GPAMUX2.bit.GPIO16 = 0; GpioDataRegs.GPADAT.bit.GPIO15=1;

GpioCtrlRegs.GPAMUX2.bit.GPIO17 = 0; }else{

GpioCtrlRegs.GPADIR.bit.GPIO15 = 1; if(ResultadoADC[1]>ResultadoADC[0]&&ResultadoADC[1]>ResultadoADC[2]){

GpioCtrlRegs.GPADIR.bit.GPIO16 = 1; GpioDataRegs.GPADAT.bit.GPIO16=1;

GpioCtrlRegs.GPADIR.bit.GPIO17 = 1; }else{

PieVectTable.ADCINT = &adc_isr; GpioDataRegs.GPADAT.bit.GPIO17=1;

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

InitAdc(); // inicializa ADC }

// Enable ADCINT in PIE }while(1); //Itera infinitamente

PieCtrlRegs.PIEIER1.bit.INTx6 = 1; }

IER |= M_INT1; // Enable CPU Interrupt 1 LABORATORIO 6

AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS; // ADC module clock = #include "DSP2833x_Device.h"

25MHz
#include "DSP2833x_Examples.h"
AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK; // ModoSecuencial: Ancho
del S/H = (2+ACQ_PS)*ADC clock en ns #include "lab6.h"

// En modo simultáneo sería: = (3+ACQ_PS)*ADC clock en ns #include "monitorF28335.h"

AdcRegs.ADCTRL3.bit.SMODE_SEL = ADC_MODO; // Secuencial #define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =

150/(2*3) = 25.0 MHz
AdcRegs.ADCTRL1.bit.SEQ_CASC = 1; // 1 Cascaded mode
#define ADC_CKPS 0x0 // ADC module clock = HSPCLK/1 = 25.5MHz/(1)
AdcRegs.ADCTRL1.bit.CONT_RUN = 1; // Modocontínuo = 25.0 MHz

AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin #define ADC_MODO 0x0 // 1 es simultáneo 0 es secuencial

wrap around ADCRESULT
#define ADC_SHCLK 0x1 // S/H ancho en periodos ADC = 2 ciclos ADC
AdcRegs.ADCCHSELSEQ1.bit.CONV00=1110; //0x3210; // Selecionar
canales 0-1-2-3 longinti,k;

AdcRegs.ADCCHSELSEQ1.bit.CONV01=0011; unsignedint t1,t2,t0;

unsignedintResultadoADC[16]; IER |= M_INT14; // Aumentar interrupción 14

void main(void) 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
DINT; //deshabilita interrupciones
EINT; //habilita interrupciones
DRTM; //deshabilita interrupciones real time mode
ERTM;
InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog
IniciarSerial(); //Inicialización de los parámetros del puerto serial A
EALLOW;
do{ //hacer loop por lo menos una vez
SysCtrlRegs.HISPCP.all = ADC_MODCLK; // HSPCLK =
SYSCLKOUT/ADC_MODCLK = 25MHz IteraSerial();

EDIS; }while(1); //Itera infinitamente

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

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

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

IFR = 0x0000; //limpia bandera de interrupciones t0++;

InitPieVectTable(); //inicializa tabla de interrupciones por defecto CpuTimer0.InterruptCount++;

// ISR para los timers de CPU GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1; //alterna estado del led

EALLOW; // Habilita cambio de registros PieCtrlRegs.PIEACK.all = PIEACK_GROUP1; //Reconocer interrupt grupo1

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

timer0
interrupt void cpu_timer1_isr(void)
PieVectTable.XINT13 = &cpu_timer1_isr;//apuntar a subrutina interrupt de
timer1 {

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

timer2
CpuTimer1.InterruptCount++;
EDIS; // Deshabilita cambio de registros
GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1; //alterna estado del led
InitAdc(); // inicializa ADC
// El Cpu reconoce solo la interrupción
iniciarRegADC(); // iniciar parámetros propios para el ADC
EDIS;
preparaLuces(); // prepara GPIO para luces alternas
}
InitCpuTimers(); // inicializa los CpuTimers
interrupt void cpu_timer2_isr(void)
ConfigCpuTimer(&CpuTimer0, 150, 1000000); // a 150MHz 1000000uSeg =
1segundo { t2++;

ConfigCpuTimer(&CpuTimer1, 150, 4500000); // a 150MHz 4500000uSeg = EALLOW;

4.5segundos
CpuTimer2.InterruptCount++;
ConfigCpuTimer(&CpuTimer2, 150, 100000); // a 150MHz 100000uSeg =
0.1segundos ResultadoADC[0]= AdcRegs.ADCRESULT0 >>4;

CpuTimer0Regs.TCR.all = 0x4001; // Arrancar timer T0 TSS bit = 0 ResultadoADC[1]= AdcRegs.ADCRESULT1 >>4;

CpuTimer1Regs.TCR.all = 0x4001; // Arrancar timer T0 TSS bit = 0 AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; // Arranque de conversión del ADC

CpuTimer2Regs.TCR.all = 0x4001; // Arrancar timer T0 TSS bit = 0 // El Cpu reconoce solo la interrupción

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

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

IER = M_INT1| M_INT13; // Interrupciones 1 y 13 voidiniciarRegADC(void)

{ #include "monitorF28335.h"

AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS; // ADC module clock = #define EPWM1_TIMER_TBPRD 2000 // Period register
25MHz
#define EPWM1_MAX_CMPA 1950
AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK; // Modo Secuencial:
Ancho del S/H = (2+ACQ_PS)*ADC clock en ns #define EPWM1_MIN_CMPA 50

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

AdcRegs.ADCTRL3.bit.SMODE_SEL = ADC_MODO; // Secuencial #define EPWM1_MIN_CMPB 50

AdcRegs.ADCTRL1.bit.SEQ_CASC = 1; // 1 Cascaded mode #define EPWM_CMP_UP 1

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

AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin wrap void main(void)

around ADCRESULT
{
AdcRegs.ADCCHSELSEQ1.all = 0x3210; // Selecionarcanales 0-1-2-3
DINT; //deshabilita interrupciones
AdcRegs.ADCCHSELSEQ2.all = 0x7654;
DRTM; //deshabilita interrupciones real time mode
AdcRegs.ADCCHSELSEQ3.all = 0xBA98;
InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog
AdcRegs.ADCCHSELSEQ4.all = 0xFEDC;
InitEPwm1Gpio();
AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0xF; // Convertir y guardar 16
canales InitSciaGpio(); // inicializa los pines scia para ser usados con su función sci

AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 0; // No habilitar interrupción InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos

SEQ1
IER = 0x0000; //limpia máscara de interrupciones
AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; // Arranque inicial del ADC
IFR = 0x0000; //limpia bandera de interrupciones
}
InitPieVectTable(); //inicializa tabla de interrupciones por defecto
voidpreparaLuces(void)
// ISR para los timers de CPU
{
EALLOW; // Habilita cambio de registros
// Luces en el control Card
PieVectTable.EPWM1_INT = &epwm1_isr;
EALLOW;
SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 0;
GpioCtrlRegs.GPAPUD.bit.GPIO31 = 0; // Habilitar pullup en GPIO31
EDIS;// Deshabilita cambio de registros
GpioDataRegs.GPADAT.bit.GPIO31 = 1; // Latch a 1
IniciaEPwm1();
GpioCtrlRegs.GPAMUX2.bit.GPIO31 = 0; // GPIO31 = GPIO31
EALLOW;
GpioCtrlRegs.GPADIR.bit.GPIO31 = 1; // GPIO31 = es salida
SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 1;
GpioCtrlRegs.GPBPUD.bit.GPIO34 = 0; // Habilitar pullup en GPIO34
EDIS;
GpioDataRegs.GPBDAT.bit.GPIO34 = 0; // Latch a 0
IER |= M_INT3; // Interrupción 3
GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0; // GPIO34 = GPIO34
PieCtrlRegs.PIEIER3.bit.INTx1 = 1;
GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1; // GPIO34 = es salida
EINT; //habilita interrupciones
EDIS;
ERTM;
}
IniciarSerial(); //Inicialización de los parámetros del puerto serial A
LABORATORIO 7
do{ //hacer loop por lo menos una vez
#include "DSP2833x_Device.h"
IteraSerial();
#include "DSP2833x_Examples.h"
}while(1); //Itera infinitamente
#include "lab7.h"
} EPwm1Regs.AQCTLB.bit.CBD = AQ_CLEAR; // Clear PWM1B en
evento B, contar abajo
interruptvoid epwm1_isr(void)
// Interrupción cuando se cambiaran los valores de comparación
{
EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO; // Seleccionar INT en
// Limpiar bandera de interrupción del Timer evento Zero

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

// Reconocer la interrupción del grupo 3 para que pueda haber más EPwm1Regs.ETPS.bit.INTPRD = ET_3RD; // Generar INT en el 3er
evento
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
}
}
LABORATORIO 8
void IniciaEPwm1()
#include "DSP2833x_Device.h"
{
#include "DSP2833x_Examples.h"
// Configurar TBCLK
#include "lab8.h"
EPwm1Regs.TBPRD = EPWM1_TIMER_TBPRD; // Determina el
periodo 801 TBCLKs #include "monitorF28335.h"

EPwm1Regs.TBPHS.half.TBPHS = 0x0000; // La fase es 0 #define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =

150/(2*3) = 25.0 MHz
EPwm1Regs.TBCTR = 0x0000; // Contador a cero
#define ADC_CKPS 0x0 // ADC module clock = HSPCLK/1 = 25.5MHz/(1)
// Configurar valores de los Comparadores = 25.0 MHz

EPwm1Regs.CMPA.half.CMPA = EPWM1_MIN_CMPA; // Dar valor al #define ADC_MODO 0x0 // 1 es simultáneo 0 es secuencial

comparador A
#define ADC_SHCLK 0x1 // S/H ancho en periodos ADC = 2 ciclos ADC
EPwm1Regs.CMPB = EPWM1_MAX_CMPB; // Dar valor al
comparador B longinti,k;

// Configurar modo de conteo unsignedintResultadoADC[16];

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

arriba y al llegar al periodo igual a cero
EPWM_INFO epwm2_info;
EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Deshabilitar carga de
fase EPWM_INFO epwm3_info;

EPwm1Regs.TBCTL.bit.HSPCLKDIV = TB_DIV1; // Tasa del prescalador #define EPWM1_TIMER_TBPRD 2000 // Period register
del SYSCLKOUT
#define EPWM1_MAX_CMPA 1950
EPwm1Regs.TBCTL.bit.CLKDIV = TB_DIV1;
#define EPWM1_MIN_CMPA 50
// Configurar shadowing modo de sombra
#define EPWM1_MAX_CMPB 1950
EPwm1Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW;
#define EPWM1_MIN_CMPB 50
EPwm1Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW;
#define EPWM2_TIMER_TBPRD 2000 // Period register
EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; // cargar en
cero #define EPWM2_MAX_CMPA 1950

EPwm1Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO; #define EPWM2_MIN_CMPA 50

// Configurar acciones #define EPWM2_MAX_CMPB 1950

EPwm1Regs.AQCTLA.bit.CAU = AQ_SET; // Set PWM1A en evento #define EPWM2_MIN_CMPB 50

A, contar arriba
#define EPWM3_TIMER_TBPRD 2000 // Period register
EPwm1Regs.AQCTLA.bit.CAD = AQ_CLEAR; // Clear PWM1A en
evento A, contar abajo #define EPWM3_MAX_CMPA 950

EPwm1Regs.AQCTLB.bit.CBU = AQ_SET; // Set PWM1B en evento #define EPWM3_MIN_CMPA 50

B, contar arriba
#define EPWM3_MAX_CMPB 1950
#define EPWM3_MIN_CMPB 1050 preparaLuces(); // prepara GPIO para luces alternas

#define EPWM_CMP_UP 1 IER |= M_INT3; // Interrupción 3

#define EPWM_CMP_DOWN 0 PieCtrlRegs.PIEIER3.bit.INTx1 = 1;

void main(void) PieCtrlRegs.PIEIER3.bit.INTx2 = 1;

{ PieCtrlRegs.PIEIER3.bit.INTx3 = 1;

DINT; //deshabilita interrupciones EINT; //habilita interrupciones

DRTM; //deshabilita interrupciones real time mode ERTM;

InitSysCtrl(); //inicializa el sistema como PLL,clocks,watcgdog IniciarSerial(); //Inicialización de los parámetros del puerto serial A

InitEPwm1Gpio(); do{ //hacer loop por lo menos una vez

InitEPwm2Gpio(); IteraSerial();

InitEPwm3Gpio(); }while(1); //Itera infinitamente

EALLOW; }

SysCtrlRegs.HISPCP.all = ADC_MODCLK; // HSPCLK = voidiniciarRegADC(void)

SYSCLKOUT/ADC_MODCLK = 25MHz
{
EDIS;
AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS; // ADC module clock =
InitSciaGpio(); // inicializa los pines scia para ser usados con su función sci 25MHz

InitPieCtrl(); //inicializa el apoyo de interrupción de periféricos AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK; // Modo Secuencial:

Ancho del S/H = (2+ACQ_PS)*ADC clock en ns
IER = 0x0000; //limpia máscara de interrupciones
// En modo simultáneo sería: = (3+ACQ_PS)*ADC clock en ns
IFR = 0x0000; //limpia bandera de interrupciones
AdcRegs.ADCTRL3.bit.SMODE_SEL = ADC_MODO; // Secuencial
InitPieVectTable(); //inicializa tabla de interrupciones por defecto
AdcRegs.ADCTRL1.bit.SEQ_CASC = 1; // 1 Cascaded mode
// ISR para los timers de CPU
AdcRegs.ADCTRL1.bit.CONT_RUN = 0; // No al modo contínuo
EALLOW; // Habilita cambio de registros
AdcRegs.ADCTRL1.bit.SEQ_OVRD = 0; // Deshabilitar Override, sin wrap
PieVectTable.EPWM1_INT = &epwm1_isr; around ADCRESULT

PieVectTable.EPWM2_INT = &epwm2_isr; AdcRegs.ADCCHSELSEQ1.all = 0x3210; // Selecionarcanales 0-1-2-3

PieVectTable.EPWM3_INT = &epwm3_isr; AdcRegs.ADCCHSELSEQ2.all = 0x7654;

EDIS; // Deshabilita cambio de registros AdcRegs.ADCCHSELSEQ3.all = 0xBA98;

EALLOW; AdcRegs.ADCCHSELSEQ4.all = 0xFEDC;

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

canales
EDIS;
AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 0; // No habilitar interrupción
InitEPwm1Example(); SEQ1

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

InitEPwm3Example(); }

EALLOW; voidpreparaLuces(void)

SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 1; {

EDIS; // Luces en el control Card

InitAdc(); // inicializa ADC EALLOW;

iniciarRegADC(); // iniciar parámetros propios para el ADC GpioCtrlRegs.GPAPUD.bit.GPIO31 = 0; // Habilitar pullup en GPIO31
 GpioDataRegs.GPADAT.bit.GPIO31 = 1; // Latch a 1 void InitEPwm1Example()

GpioCtrlRegs.GPAMUX2.bit.GPIO31 = 0; // GPIO31 = GPIO31 {

GpioCtrlRegs.GPADIR.bit.GPIO31 = 1; // GPIO31 = es salida // Setup TBCLK

GpioCtrlRegs.GPBPUD.bit.GPIO34 = 0; // Habilitar pullup en GPIO34 EPwm1Regs.TBPRD = EPWM1_TIMER_TBPRD; // Set timer period

801 TBCLKs
GpioDataRegs.GPBDAT.bit.GPIO34 = 0; // Latch a 0
EPwm1Regs.TBPHS.half.TBPHS = 0x0000; // Phase is 0
GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0; // GPIO34 = GPIO34
EPwm1Regs.TBCTR = 0x0000; // Clear counter
GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1; // GPIO34 = es salida
// Set Compare values
EDIS;
EPwm1Regs.CMPA.half.CMPA = EPWM1_MIN_CMPA; // Set compare A
} value

interrupt void epwm1_isr(void) EPwm1Regs.CMPB = EPWM1_MAX_CMPB; // Set Compare B

value
{
// Setup counter mode
// Update the CMPA and CMPB values
EPwm1Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Count up
update_compare(&epwm1_info);
EPwm1Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Disable phase
// Clear INT flag for this timer loading

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

SYSCLKOUT
// Acknowledge this interrupt to receive more interrupts from group 3
EPwm1Regs.TBCTL.bit.CLKDIV = TB_DIV1;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
// Setup shadowing
}
EPwm1Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW;
interrupt void epwm2_isr(void)
EPwm1Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW;
{
EPwm1Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; // Load on Zero
// Update the CMPA and CMPB values
EPwm1Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO;
update_compare(&epwm2_info);
// Set actions
// Clear INT flag for this timer
EPwm1Regs.AQCTLA.bit.CAU = AQ_SET; // Set PWM1A on event A,
EPwm2Regs.ETCLR.bit.INT = 1; up count

// Acknowledge this interrupt to receive more interrupts from group 3 EPwm1Regs.AQCTLA.bit.CAD = AQ_CLEAR; // Clear PWM1A on
event A, down count
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
EPwm1Regs.AQCTLB.bit.CBU = AQ_SET; // Set PWM1B on event B,
} up count

interrupt void epwm3_isr(void) EPwm1Regs.AQCTLB.bit.CBD = AQ_CLEAR; // Clear PWM1B on

event B, down count
{
// Interrupt where we will change the Compare Values
// Update the CMPA and CMPB values
EPwm1Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO; // Select INT on Zero
update_compare(&epwm3_info); event

// Clear INT flag for this timer EPwm1Regs.ETSEL.bit.INTEN = 1; // Enable INT

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

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

PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
// Information this example uses to keep track
}
 // of the direction the CMPA/CMPB values are EPwm2Regs.AQCTLA.bit.CAU = AQ_SET; // Set PWM2A on event A,
up count
// moving, the min and max allowed values and
EPwm2Regs.AQCTLA.bit.CBD = AQ_CLEAR; // Clear PWM2A on event
// a pointer to the correct ePWM registers B, down count

epwm1_info.EPwm_CMPA_Direction = EPWM_CMP_UP; // Start by EPwm2Regs.AQCTLB.bit.ZRO = AQ_CLEAR; // Clear PWM2B on zero

increasing CMPA &
EPwm2Regs.AQCTLB.bit.PRD = AQ_SET ; // Set PWM2B on period
epwm1_info.EPwm_CMPB_Direction = EPWM_CMP_DOWN; // decreasing
CMPB // Interrupt where we will change the Compare Values

epwm1_info.EPwmTimerIntCount = 0; // Zero the interrupt counter EPwm2Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO; // Select INT on Zero
event
epwm1_info.EPwmRegHandle = &EPwm1Regs; // Set the pointer to the
ePWM module EPwm2Regs.ETSEL.bit.INTEN = 1; // Enable INT

epwm1_info.EPwmMaxCMPA = EPWM1_MAX_CMPA; // Setup min/max EPwm2Regs.ETPS.bit.INTPRD = ET_3RD; // Generate INT on 3rd

CMPA/CMPB values event

epwm1_info.EPwmMinCMPA = EPWM1_MIN_CMPA; // Information this example uses to keep track

epwm1_info.EPwmMaxCMPB = EPWM1_MAX_CMPB; // of the direction the CMPA/CMPB values are

epwm1_info.EPwmMinCMPB = EPWM1_MIN_CMPB; // moving, the min and max allowed values and

} // a pointer to the correct ePWM registers

void InitEPwm2Example() epwm2_info.EPwm_CMPA_Direction = EPWM_CMP_UP; // Start by

increasing CMPA &
{
epwm2_info.EPwm_CMPB_Direction = EPWM_CMP_UP; // increasing
// Setup TBCLK CMPB

EPwm2Regs.TBPRD = EPWM2_TIMER_TBPRD; // Set timer period epwm2_info.EPwmTimerIntCount = 0; // Zero the interrupt counter
801 TBCLKs
epwm2_info.EPwmRegHandle = &EPwm2Regs; // Set the pointer to the
EPwm2Regs.TBPHS.half.TBPHS = 0x0000; // Phase is 0 ePWM module

EPwm2Regs.TBCTR = 0x0000; // Clear counter epwm2_info.EPwmMaxCMPA = EPWM2_MAX_CMPA; // Setup min/max

CMPA/CMPB values
// Set Compare values
epwm2_info.EPwmMinCMPA = EPWM2_MIN_CMPA;
EPwm2Regs.CMPA.half.CMPA = EPWM2_MIN_CMPA; // Set compare A
value epwm2_info.EPwmMaxCMPB = EPWM2_MAX_CMPB;

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

// Setup counter mode }

EPwm2Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN; // Count up void InitEPwm3Example(void)

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

loading
// Setup TBCLK
EPwm2Regs.TBCTL.bit.HSPCLKDIV = TB_DIV1; // Clock ratio to
SYSCLKOUT EPwm3Regs.TBCTL.bit.CTRMODE = TB_COUNT_UPDOWN;// Count
up/down
EPwm2Regs.TBCTL.bit.CLKDIV = TB_DIV1;
EPwm3Regs.TBPRD = EPWM3_TIMER_TBPRD; // Set timer period
// Setup shadowing
EPwm3Regs.TBCTL.bit.PHSEN = TB_DISABLE; // Disable phase loading
EPwm2Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW;
EPwm3Regs.TBPHS.half.TBPHS = 0x0000; // Phase is 0
EPwm2Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW;
EPwm3Regs.TBCTR = 0x0000; // Clear counter
EPwm2Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; // Load on Zero
EPwm3Regs.TBCTL.bit.HSPCLKDIV = TB_DIV1; // Clock ratio to
EPwm2Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO; SYSCLKOUT

// Set actions EPwm3Regs.TBCTL.bit.CLKDIV = TB_DIV1;

 // Setup shadow register load on ZERO {

EPwm3Regs.CMPCTL.bit.SHDWAMODE = CC_SHADOW; // Every 10'th interrupt, change the CMPA/CMPB values

EPwm3Regs.CMPCTL.bit.SHDWBMODE = CC_SHADOW; if(epwm_info->EPwmTimerIntCount == 10)

EPwm3Regs.CMPCTL.bit.LOADAMODE = CC_CTR_ZERO; {

EPwm3Regs.CMPCTL.bit.LOADBMODE = CC_CTR_ZERO; epwm_info->EPwmTimerIntCount = 0;

// Set Compare values // If we were increasing CMPA, check to see if

EPwm3Regs.CMPA.half.CMPA = EPWM3_MIN_CMPA; // Set compare A // we reached the max value. If not, increase CMPA
value
// else, change directions and decrease CMPA
EPwm3Regs.CMPB = EPWM3_MAX_CMPB; // Set Compare B value
if(epwm_info->EPwm_CMPA_Direction == EPWM_CMP_UP)
// Set Actions
{
EPwm3Regs.AQCTLA.bit.PRD = AQ_SET; // Set PWM3A on period
if(epwm_info->EPwmRegHandle->CMPA.half.CMPA<epwm_info-
EPwm3Regs.AQCTLA.bit.CBD = AQ_CLEAR; // Clear PWM3A on event >EPwmMaxCMPA)
B, down count
{
EPwm3Regs.AQCTLB.bit.PRD = AQ_CLEAR; // Clear PWM3A on
period epwm_info->EPwmRegHandle->CMPA.half.CMPA++;

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

up count
else
// Interrupt where we will change the Compare Values
{
EPwm3Regs.ETSEL.bit.INTSEL = ET_CTR_ZERO; // Select INT on Zero
event epwm_info->EPwm_CMPA_Direction = EPWM_CMP_DOWN;

EPwm3Regs.ETSEL.bit.INTEN = 1; // Enable INT epwm_info->EPwmRegHandle->CMPA.half.CMPA--;

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

event
}
// Information this example uses to keep track
// If we were decreasing CMPA, check to see if
// of the direction the CMPA/CMPB values are
// we reached the min value. If not, decrease CMPA
// moving, the min and max allowed values and
// else, change directions and increase CMPA
// a pointer to the correct ePWM registers
else
epwm3_info.EPwm_CMPA_Direction = EPWM_CMP_UP; // Start by
increasing CMPA & {

epwm3_info.EPwm_CMPB_Direction = EPWM_CMP_DOWN; // decreasing if(epwm_info->EPwmRegHandle->CMPA.half.CMPA == epwm_info-

CMPB >EPwmMinCMPA)

epwm3_info.EPwmTimerIntCount = 0; // Zero the interrupt counter {

epwm3_info.EPwmRegHandle = &EPwm3Regs; // Set the pointer to the epwm_info->EPwm_CMPA_Direction = EPWM_CMP_UP;

ePWM module
epwm_info->EPwmRegHandle->CMPA.half.CMPA++;
epwm3_info.EPwmMaxCMPA = EPWM3_MAX_CMPA; // Setup min/max
CMPA/CMPB values }

epwm3_info.EPwmMinCMPA = EPWM3_MIN_CMPA; else

epwm3_info.EPwmMaxCMPB = EPWM3_MAX_CMPB; {

epwm3_info.EPwmMinCMPB = EPWM3_MIN_CMPB; epwm_info->EPwmRegHandle->CMPA.half.CMPA--;

} }

voidupdate_compare(EPWM_INFO *epwm_info) }
 // If we were increasing CMPB, check to see if return;

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

// else, change directions and decrease CMPB UNO DE LOS PRIMEROS LABOS

if(epwm_info->EPwm_CMPB_Direction == EPWM_CMP_UP) while(1){

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

la memoria
if(epwm_info->EPwmRegHandle->CMPB <epwm_info->EPwmMaxCMPB)
GpioDataRegs.GPBTOGGLE.bit.GPIO60 = 1; // Modificar
{ alternando estado de GPIO60

epwm_info->EPwmRegHandle->CMPB++; for (k=0;k<retardo;k++); // bloque de retardo

} GpioDataRegs.GPBTOGGLE.bit.GPIO60 = 1; // Modificar
alternando estado de GPIO60
else
GpioDataRegs.GPBTOGGLE.bit.GPIO61 = 1; // Modificar
{ alternando estado de GPIO61

epwm_info->EPwm_CMPB_Direction = EPWM_CMP_DOWN; for (k=0;k<retardo;k++); // bloque de retardo

epwm_info->EPwmRegHandle->CMPB--; GpioDataRegs.GPBTOGGLE.bit.GPIO61 = 1; // Modificar

alternando estado de GPIO61
}
GpioDataRegs.GPBTOGGLE.bit.GPIO62 = 1; // Modificar
} alternando estado de GPIO62

// If we were decreasing CMPB, check to see if for (k=0;k<retardo;k++); // bloque de retardo

// we reached the min value. If not, decrease CMPB GpioDataRegs.GPBTOGGLE.bit.GPIO62 = 1; // Modificar

alternando estado de GPIO62
// else, change directions and increase CMPB
GpioDataRegs.GPBTOGGLE.bit.GPIO63 = 1; // Modificar
else alternando estado de GPIO63

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

if(epwm_info->EPwmRegHandle->CMPB == epwm_info->EPwmMinCMPB) GpioDataRegs.GPBTOGGLE.bit.GPIO63 = 1; // Modificar

alternando estado de GPIO63
{
GpioDataRegs.GPCTOGGLE.bit.GPIO64 = 1; // Modificar
epwm_info->EPwm_CMPB_Direction = EPWM_CMP_UP; alternando estado de GPIO64

epwm_info->EPwmRegHandle->CMPB++; for (k=0;k<retardo;k++); // bloque de retardo

} GpioDataRegs.GPCTOGGLE.bit.GPIO64 = 1; // Modificar
alternando estado de GPIO64
else
GpioDataRegs.GPCTOGGLE.bit.GPIO65 = 1; // Modificar
{ alternando estado de GPIO65

epwm_info->EPwmRegHandle->CMPB--; for (k=0;k<retardo;k++); // bloque de retardo

} GpioDataRegs.GPCTOGGLE.bit.GPIO65 = 1; // Modificar
alternando estado de GPIO65
}
GpioDataRegs.GPCTOGGLE.bit.GPIO66 = 1; // Modificar
}
alternando estado de GPIO66

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

{
GpioDataRegs.GPCTOGGLE.bit.GPIO66 = 1; // Modificar
alternando estado de GPIO66
epwm_info->EPwmTimerIntCount++;
GpioDataRegs.GPCTOGGLE.bit.GPIO67 = 1; // Modificar
}
alternando estado de GPIO67

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

 GpioDataRegs.GPCTOGGLE.bit.GPIO67 = 1; // Modificar 7) Aparece la ventana de configuración
alternando estado de GPIO60
8) Abrimos Projects->Lab1->XDS100
GpioDataRegs.GPCTOGGLE.bit.GPIO66 = 1; // Modificar
alternando estado de GPIO61 9) Click derecho en XDS100 y luego en LaunchSelectedConfiguration

for (k=0;k<retardo;k++); // bloque de retardo 10) Tenemos el entorno de prueba

GpioDataRegs.GPCTOGGLE.bit.GPIO66 = 1; // Modificar 11) Para conectar con la tarjeta Run->Connect Target

alternando estado de GPIO61
12) Para cargar el programa Run->Load->Load Program
GpioDataRegs.GPCTOGGLE.bit.GPIO65 = 1; // Modificar
alternando estado de GPIO62 13) Seleccionamos el programa que deseamos cargar

for (k=0;k<retardo;k++); // bloque de retardo 14) En nuestro caso C->DSP28335_2013>Lab1->Debug->lab01.out

GpioDataRegs.GPCTOGGLE.bit.GPIO65 = 1; // Modificar 15) Para correr el programa hacer click en la flecha verde (F8)
alternando estado de GPIO62
PRIMEROS LABOS
GpioDataRegs.GPCTOGGLE.bit.GPIO64 = 1; // Modificar
alternando estado de GPIO63 //Pull up y Multiplexor de los pines

for (k=0;k<retardo;k++); // bloque de retardo GpioCtrlRegs.GPBPUD.bit.GPIO60 = 0; // Habilitar pullup en GPIO60

GpioDataRegs.GPCTOGGLE.bit.GPIO64 = 1; // Modificar GpioCtrlRegs.GPBPUD.bit.GPIO61 = 0; // Habilitar pullup en GPIO61

alternando estado de GPIO63
GpioCtrlRegs.GPBPUD.bit.GPIO62 = 0; // Habilitar pullup en GPIO62
GpioDataRegs.GPBTOGGLE.bit.GPIO63 = 1; // Modificar
alternando estado de GPIO64 GpioCtrlRegs.GPBPUD.bit.GPIO63 = 0; // Habilitar pullup en GPIO63

for (k=0;k<retardo;k++); // bloque de retardo GpioCtrlRegs.GPCPUD.bit.GPIO64 = 0; // Habilitar pullup en GPIO64

GpioDataRegs.GPBTOGGLE.bit.GPIO63 = 1; // Modificar GpioCtrlRegs.GPCPUD.bit.GPIO65 = 0; // Habilitar pullup en GPIO65

alternando estado de GPIO64
GpioCtrlRegs.GPCPUD.bit.GPIO66 = 0; // Habilitar pullup en GPIO66
GpioDataRegs.GPBTOGGLE.bit.GPIO62 = 1; // Modificar
alternando estado de GPIO65 GpioCtrlRegs.GPCPUD.bit.GPIO67 = 0; // Habilitar pullup en GPIO67

for (k=0;k<retardo;k++); // bloque de retardo //Es señal digital

GpioDataRegs.GPBTOGGLE.bit.GPIO62 = 1; // Modificar GpioCtrlRegs.GPBMUX2.bit.GPIO60 = 0; // GPIO60 = GPIO60

alternando estado de GPIO65
GpioCtrlRegs.GPBMUX2.bit.GPIO61 = 0; // GPIO61 = GPIO61
GpioDataRegs.GPBTOGGLE.bit.GPIO61 = 1; // Modificar
alternando estado de GPIO66 GpioCtrlRegs.GPBMUX2.bit.GPIO62 = 0; // GPIO62 = GPIO62

for (k=0;k<retardo;k++); // bloque de retardo GpioCtrlRegs.GPBMUX2.bit.GPIO63 = 0; // GPIO63 = GPIO63

GpioDataRegs.GPBTOGGLE.bit.GPIO60 = 1; // Modificar GpioCtrlRegs.GPCMUX1.bit.GPIO64 = 0; // GPIO64 = GPIO64

alternando estado de GPIO66
GpioCtrlRegs.GPCMUX1.bit.GPIO65 = 0; // GPIO65 = GPIO65
}
GpioCtrlRegs.GPCMUX1.bit.GPIO66 = 0; // GPIO66 = GPIO66
}
GpioCtrlRegs.GPCMUX1.bit.GPIO67 = 0; // GPIO67 = GPIO67
}
//Es salida
CONFIGURAR
GpioCtrlRegs.GPBDIR.bit.GPIO60 = 1; // GPIO60 = es salida
1) Abrir el codecomposer
GpioCtrlRegs.GPBDIR.bit.GPIO61 = 1; // GPIO61 = es salida
2) Seleccionar el espacio de trabajo
GpioCtrlRegs.GPBDIR.bit.GPIO62 = 1; // GPIO62 = es salida
3) Verificar que este abierto el programa (LAB1)
GpioCtrlRegs.GPBDIR.bit.GPIO63 = 1; // GPIO63 = es salida
4) Compilar en Project->BuildAll
GpioCtrlRegs.GPCDIR.bit.GPIO64 = 1; // GPIO64 = es salida
5) Verificar que no haya errores
GpioCtrlRegs.GPCDIR.bit.GPIO65 = 1; // GPIO64 = es salida
6) Ir a View->Target Configurations
GpioCtrlRegs.GPCDIR.bit.GPIO66 = 1; // GPIO64 = es salida
 GpioCtrlRegs.GPCDIR.bit.GPIO67 = 1; // GPIO64 = es salida

EDIS;

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

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

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

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

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

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

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

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

EINT;

ERTM;

while(1){

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