EJEMPLO INICIALIZAR PROGRAMA

#include "DSP2833x_Device.h"

#include "DSP2833x_Examples.h"

#include "math.h"

#include "lab1.h"

float salida[1000]; //variable de salida

long int k=0; //muestra k

float T=0; //periodo de muestreo

const float 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 interrupcin de perifricos

IER = 0x0000; //limpia mscara 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

do{

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

t=k*T;

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

}while(1);

float func_coseno(float angulo)

return 100*cos(angulo);

EJEMPLO GPIO

#include "DSP2833x_Device.h"

#include "DSP2833x_Examples.h"

#include "lab2.h"

long int i,k,l;

long int retardo=5000000;

long int test=0; // Variable para buscar errores

void main(void) {

DINT; //deshabilita interrupciones

DRTM; //deshabilita interrupciones real time mode

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

InitPieCtrl(); //inicializa el apoyo de interrupcin de perifricos

IER = 0x0000; //limpia mscara de interrupciones

IFR = 0x0000; //limpia bandera de interrupciones

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

EINT; //habilita interrupciones

ERTM;

EALLOW;

//Pull up y Multiplexor de los pines

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

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

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

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

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

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

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

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

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

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

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

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

// 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

// Habilitar eCAP2 en GPIO7 con calificador sincronizado con el Sysclout

(defecto)

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

GpioCtrlRegs.GPAQSEL1.bit.GPIO7 = 0; // Sincronizar con reloj principal

SYSCLOUT

GpioCtrlRegs.GPAMUX1.bit.GPIO7 = 3; // GPIO7 = ECAP2

// Habilitar GPIO como entrada en GPIO8 con pull up

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

GpioCtrlRegs.GPAQSEL1.bit.GPIO8 = 2; // Selector de calificador a 6 muestras

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

GpioCtrlRegs.GPADIR.bit.GPIO8 = 0; // GPIO8 = es entrada

// Habilitar GPIO como entrada en GPIO9 sin pull up

GpioCtrlRegs.GPAPUD.bit.GPIO9 = 1; // Deshabilitar el pullup en GPIO9

 GpioCtrlRegs.GPAQSEL1.bit.GPIO9 = 3; // Selector de calificador a modo
asncrono

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

GpioCtrlRegs.GPADIR.bit.GPIO9 = 0; // GPIO9 = es entrada

// Habilitar un GPIO como salida en el GPIO10, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO10 = 1; // cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO11, luego se har un TOGGLE

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

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

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

// Otros GPIO12 - GPIO15

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

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

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

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

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

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

GpioCtrlRegs.GPAQSEL1.bit.GPIO14 = 3; // Selector de calificador a modo

asncrono

GpioCtrlRegs.GPAQSEL1.bit.GPIO15 = 3; // Selector de calificador a modo

asncrono

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

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

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

 GpioCtrlRegs.GPADIR.bit.GPIO13 = 1; // GPIO12 = es salida

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

GpioCtrlRegs.GPAMUX1.bit.GPIO14 = 1; // GPIO14 = TZ3

GpioCtrlRegs.GPAMUX1.bit.GPIO15 = 1; // GPIO15 = TZ4

// Luces en el control Card

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

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

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

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

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;

//Datos a poner en los pines

GpioDataRegs.GPATOGGLE.bit.GPIO11 = 1; // Modificar alternando estado de

GPIO11

GpioDataRegs.GPADAT.bit.GPIO12 = 0; // GPIO12 es salida a 0

GpioDataRegs.GPADAT.bit.GPIO13 = 1; // GPIO13 es salida a 1

EINT;

ERTM;

//XF bandera externa

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

GpioDataRegs.GPATOGGLE.bit.GPIO11 =1; //Alternar estado del pin

GPIO11

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

GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1;

GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1;

};
 GpioDataRegs.GPADAT.bit.GPIO31 =0; //Al terminar dejar pin OFF

GpioDataRegs.GPBDAT.bit.GPIO34 = 1; //Al terminar dejar pin ON

botones.all=0;

while(1){ //hacer loop por lo menos una vez

test++; // test debera cambiar en cada pasada

*(long int *)0x8000=test; // La memoria =0x8000 debe cambiar cada vez

botones.bit.boton0=GpioDataRegs.GPADAT.bit.GPIO0; //Leer pin con

boton[0]

botones.bit.boton1=GpioDataRegs.GPADAT.bit.GPIO1; //Leer pin con

boton[1]

botones.bit.boton2=GpioDataRegs.GPADAT.bit.GPIO8; //Leer pin con

boton[2]

botones.bit.boton3=GpioDataRegs.GPADAT.bit.GPIO9; //Leer pin con

boton[3]

GpioDataRegs.GPADAT.bit.GPIO10= botones.bit.boton0 &&

botones.bit.boton1; //Copiar boton1&&boton0 en salida GPIO10

}; //Itera infinitamente

EJEMPLO ADC

#include "DSP2833x_Device.h"

#include "DSP2833x_Examples.h"

#include "lab4.h"

#include "monitorF28335.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 simultneo 0 es secuencial

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

long int i,k;

int Promedio;
unsigned int ResultadoADC[16];

void main(void)

DINT; //deshabilita interrupciones

DRTM; //deshabilita interrupciones real time mode

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

EALLOW;

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

SYSCLKOUT/ADC_MODCLK = 25MHz

EDIS;

InitSciaGpio(); // inicializa los pines scia para ser usados con su funcin sci

InitPieCtrl(); //inicializa el apoyo de interrupcin de perifricos

IER = 0x0000; //limpia mscara de interrupciones

IFR = 0x0000; //limpia bandera de interrupciones

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

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 simultneo sera: =

(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 = 1; // Modo contnuo

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

around ADCRESULT

/*AdcRegs.ADCCHSELSEQ1.all = 0x3210; // Selecionar canales 0-1-2-3

 AdcRegs.ADCCHSELSEQ2.all = 0x7654;

AdcRegs.ADCCHSELSEQ3.all = 0xBA98;

AdcRegs.ADCCHSELSEQ4.all = 0xFEDC;*/

AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x7;

AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x2;

AdcRegs.ADCCHSELSEQ1.bit.CONV02 = 0x0;

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

canales

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

EINT; //habilita interrupciones

ERTM;

IniciarSerial(); //Inicializacin de los parmetros del puerto serial A

do{ //hacer loop por lo menos una vez

IteraSerial();

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1; //Arranque de conversin

SOC por SW

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

termine

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

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

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

ResultadoADC[3]=(ResultadoADC[0]+ResultadoADC[1]+ResultadoADC[2])/3;

Promedio=5.46*ResultadoADC[3]+573.8;

}while(1); //Itera infinitamente

EJEMPLO ePWM

#include "DSP2833x_Device.h"

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

#include "monitorF28335.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)

DINT; //deshabilita interrupciones

DRTM; //deshabilita interrupciones real time mode

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

InitEPwm1Gpio();

InitSciaGpio(); // inicializa los pines scia para ser usados con su funcin sci

InitPieCtrl(); //inicializa el apoyo de interrupcin de perifricos

IER = 0x0000; //limpia mscara de interrupciones

IFR = 0x0000; //limpia bandera de interrupciones

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

// ISR para los timers de CPU

EALLOW; // Habilita cambio de registros

PieVectTable.EPWM1_INT = &epwm1_isr;

SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 0;

EDIS;// Deshabilita cambio de registros

IniciaEPwm1();

EALLOW;

SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 1;
 EDIS;

IER |= M_INT3; // Interrupcin 3

PieCtrlRegs.PIEIER3.bit.INTx1 = 1;

EINT; //habilita interrupciones

ERTM;

IniciarSerial(); //Inicializacin de los parmetros del puerto serial A

do{ //hacer loop por lo menos una vez

IteraSerial();

}while(1); //Itera infinitamente

interrupt void epwm1_isr(void)

// Limpiar bandera de interrupcin del Timer

EPwm1Regs.ETCLR.bit.INT = 1;

// Reconocer la interrupcin del grupo 3 para que pueda haber ms

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

// Interrupcin cuando se cambiaran los valores de comparacin

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 PID

#include "DSP2833x_Device.h"

#include "DSP2833x_Examples.h"

#include "math.h"

#include "lab1.h"

//float salida[1000]; //variable de salida

//long int k=0; //muestra k

//float T=0; //periodo de muestreo

//const float pi=3.1415926535897932384;

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

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

float Q[2];

float w[2];

float i[2];

int vref;

const double k = 1;

const double Tc =1 ;

const double J = 0.01;

const double R = 1;

const double L = 0.004;

const double dt =0.001 ;

const double qref= 0.5;

const double wref = 0.5;

const double iref = 0.5;

const double Ki = {1.4, 1.5, 1.6};

const double Kq = {1.5, 1.2, 1.1};

const double Kw = {1.0, 1.5, 1.4};

double q = 0.2;

double w = 0.5;

double i = 0.5;

double errq = {0,0};

double erri = { 0,0 };

double errw = { 0,0 };

double cont=0;

main(void)

DINT; //deshabilita interrupciones

DRTM; //deshabilita interrupciones real time mode

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

InitPieCtrl(); //inicializa el apoyo de interrupcin de perifricos

IER = 0x0000; //limpia mscara de interrupciones

IFR = 0x0000; //limpia bandera de interrupciones

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

EINT; //habilita interrupciones

ERTM;

while (1) {

u = PID(qref, q, kq, errq, mtgq, dt);

wref = u;

u = PID(wref, w, kw, errw, mtgw, dt);

 iref = u;

u = PID(iref, i, ki, erri, mtgi, dt);

M(V, k, L, Tc, J, R, q, w, i, dt);

void M(double V,double k,double L,double Tc,double J,double R,double q,double

w,double i,double dt) {

float dq = w*dt;

float dw = (k*i - Tc)*dt / J;

float di = (u - i*R - k*w)*dt / L;

q += dq;

w += dw;

i += di;

float PID(double vref, double V,double K[3],double err[2],double mtg, double dt

){

err[1] = vref - v;

P = K[1] * err[1];

mtg += err[1] * dt;

I = K[2] * mtg;

d = (err[1] - err[0]) / dt;

D = kd*d;

err[0] = err[1];

u = P + I + D;

return u; }

LABORATORIO PLANTA QUMICA

//----------------------------------SALIDAS----------------------------------
// Habilitar un GPIO como salida en el GPIO1, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO1 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO2, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO2 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO3, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO3 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO4, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO4 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO5, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO5 = 1;// Cargar latch de salida = 1

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

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

 // Habilitar un GPIO como salida en el GPIO6, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO6 = 1;// Cargar latch de salida = 1

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

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

//----------------------------------ENTRADAS---------------------------------

// Habilitar GPIO como entrada en GPIO7 con pull up

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

GpioCtrlRegs.GPAQSEL1.bit.GPIO7 = 0; // Selector de calificador sincronizando

con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO7 = 1; // GPIO7 = es entrada

// Habilitar GPIO como entrada en GPIO8 con pull up

GpioCtrlRegs.GPAPUD.bit.GPIO8 = 0; // Habilitar el pullup en GPIO8

GpioCtrlRegs.GPAQSEL1.bit.GPIO8 = 0; // Selector de calificador sincronizando

con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO8 = 1; // GPIO8 = es entrada

// Habilitar GPIO como entrada en GPIO9 con pull up

GpioCtrlRegs.GPAPUD.bit.GPIO9 = 0; // Habilitar el pullup en GPIO9

GpioCtrlRegs.GPAQSEL1.bit.GPIO9 = 0; // Selector de calificador sincronizando

con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO9 = 1; // GPIO9 = es entrada

// Habilitar GPIO como entrada en GPIO10 con pull up

GpioCtrlRegs.GPAPUD.bit.GPIO10 = 0; // Habilitar el pullup en GPIO10

 GpioCtrlRegs.GPAQSEL1.bit.GPIO10 = 0; // Selector de calificador sincronizando
con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO10 = 1; // GPIO10 = es entrada

// Habilitar GPIO como entrada en GPIO11 con pull up

GpioCtrlRegs.GPAPUD.bit.GPIO11 = 0; // Habilitar el pullup en GPIO11

GpioCtrlRegs.GPAQSEL1.bit.GPIO11 = 0; // Selector de calificador sincronizando

con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO11 = 1; // GPIO11 = es entrada

//--------------ASIGNACIN DE VARIABLES A LAS ENTRADAS-------------------

----

//GpioDataRegs.GPADAT.bit.GPIO1=VA -> Vlvula para la entrada de la sustancia

A

//GpioDataRegs.GPADAT.bit.GPIO2=VB -> Vlvula para la entrada de la sustancia

B

//GpioDataRegs.GPADAT.bit.GPIO3=VC -> Vlvula para la entrada de la sustancia

C

//GpioDataRegs.GPADAT.bit.GPIO4=VE -> Vlvula de vaciado de mezcla

//GpioDataRegs.GPADAT.bit.GPIO5=VD -> Vlvula de calentamiento por vapor

//GpioDataRegs.GPADAT.bit.GPIO6=S1 -> Interruptor para el motor

//----------------------FUNCIONAMIENTO DE LA PLANTA--------------------------

//VERIFICO SI EL TANQUE EST VACO

//Si no lo est activo la vlvula de vaciado

if (GpioDataRegs.GPADAT.bit.GPIO7==1)

{GpioDataRegs.GPASET.bit.GPIO4 = 1;}//VE=1

//Si lo est llevo la planta a condiciones iniciales

else

{
 GpioDataRegs.GPACLEAR.bit.GPIO4 = 1; //VE=0

GpioDataRegs.GPACLEAR.bit.GPIO6 = 1; //S1=0

GpioDataRegs.GPACLEAR.bit.GPIO5 = 1; //VD=0

GpioDataRegs.GPACLEAR.bit.GPIO1 = 1; //VA=0

GpioDataRegs.GPACLEAR.bit.GPIO2 = 1; //VB=0

GpioDataRegs.GPACLEAR.bit.GPIO3 = 1; //VC=0

//Espero 3 segundos

delay_ms(3000);

//Enciendo la vlvula de vaciado de la sustancia A

GpioDataRegs.GPASET.bit.GPIO1 = 1; //VA=1

//VERIFICO SI EL SENSOR DE NIVEL 1 SE HA ACTIVADO

//Si no se ha activado, dejo la vlvula de vaciado de sustancia A activa

if (GpioDataRegs.GPADAT.bit.GPIO8==0)

{GpioDataRegs.GPASET.bit.GPIO4 = 1;} //VA=1

//Si se ha activado, apago la vlvula y enciendo la vlvula de la sustancia B

else

GpioDataRegs.GPACLEAR.bit.GPIO1 = 1; //VA=0

GpioDataRegs.GPASET.bit.GPIO2 = 1; //VB=1

//VERIFICO SI EL SENSOR DE NIVEL 2 SE HA ACTIVADO

//Si no se ha activado, dejo la vlvula de vaciado de sustancia B activa

if (GpioDataRegs.GPADAT.bit.GPIO9==0)

{GpioDataRegs.GPASET.bit.GPIO2 = 1;} //VB=1

//Si se ha activado, apago la vlvula y enciendo la vlvula de la sustancia C

else

GpioDataRegs.GPACLEAR.bit.GPIO2 = 1; //VB=0

GpioDataRegs.GPASET.bit.GPIO3 = 1; //VC=1

//VERIFICO SI EL SENSOR DE NIVEL 3 SE HA ACTIVADO

//Si no se ha activado, dejo la vlvula de vaciado de sustancia C activa

if (GpioDataRegs.GPADAT.bit.GPIO10==0)

{GpioDataRegs.GPASET.bit.GPIO3 = 1;} //VC=1

//Si se ha activado, apago la vlvula, enciendo el motor y caliento

else

GpioDataRegs.GPACLEAR.bit.GPIO3 = 1; //VC=0

GpioDataRegs.GPASET.bit.GPIO6 = 1; //S1=1

delay_ms(20000); //Dejo que la mezcla se homogenice

GpioDataRegs.GPASET.bit.GPIO5 = 1; //VD=1

//VERIFICO SI LA MEZCLA LLEG A LA TEMPERATURA ADECUADA

//Si no est a la temperatura adecuada, sigo calentando

if (GpioDataRegs.GPADAT.bit.GPIO11==0)

{GpioDataRegs.GPASET.bit.GPIO5 = 1;} //VD=1

//Si lleg a la temperatura adecuada, dejo de calentar, apago el motor

//y activo la vlvula de vaciado

else

GpioDataRegs.GPACLEAR.bit.GPIO5 = 1; //VD=0
 GpioDataRegs.GPACLEAR.bit.GPIO6 = 1; //S1=0

delay_ms(5000);

GpioDataRegs.GPASET.bit.GPIO4 = 1; //VE=1;

//VERIFICO SI LA MEZCLA TERMIN DE VACIARSE

if (GpioDataRegs.GPADAT.bit.GPIO7==0)

{GpioDataRegs.GPASET.bit.GPIO4 = 1;} //VE=1

else

{GpioDataRegs.GPACLEAR.bit.GPIO4 = 1;} //VE=0

LABORATORIO ASCENSOR

//SALIDAS

// Habilitar un GPIO como salida en el GPIO4, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO4 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO5, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO5 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO6, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO6 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO7, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO7 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO8, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO8 = 1;// Cargar latch de salida = 1

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

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

// Habilitar un GPIO como salida en el GPIO9, usar el "clear" para puesta a cero

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

GpioDataRegs.GPACLEAR.bit.GPIO9 = 1;// Cargar latch de salida = 1

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

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

//ENTRADAS

// Habilitar GPIO como entrada en GPIO1 con pull up

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

GpioCtrlRegs.GPAQSEL1.bit.GPIO1 = 0; // Selector de calificador sincronizando

con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO1 = 1; // GPIO1 = es entrada

// Habilitar GPIO como entrada en GPIO2 con pull up

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

GpioCtrlRegs.GPAQSEL1.bit.GPIO2 = 0; // Selector de calificador sincronizando

con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO2 = 1; // GPIO2 = es entrada

// Habilitar GPIO como entrada en GPIO3 con pull up

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

 GpioCtrlRegs.GPAQSEL1.bit.GPIO3 = 0; // Selector de calificador sincronizando
con SYSCLKOUT

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

GpioCtrlRegs.GPADIR.bit.GPIO3 = 1; // GPIO3 = es entrada

//VARIABLES

//int bot_subir,bot_bajar,bot_abrir;

//int lvl_1,lvl2;

//int s_1,s_2;

//int door_1,door_2;

//GpioDataRegs.GPADAT.bit.GPIO1=bot_subir -> Boton para subir al piso 2

//GpioDataRegs.GPADAT.bit.GPIO2=bot_bajar -> Boton para bajar al piso 1

//GpioDataRegs.GPADAT.bit.GPIO3=bot_abrir -> Boton para abrir las puertas

//GpioDataRegs.GPADAT.bit.GPIO4=lvl_1 -> Sensor de llegada al piso 1

//GpioDataRegs.GPADAT.bit.GPIO5=lvl_2 -> Sensor de llegada al piso 2

//GpioDataRegs.GPADAT.bit.GPIO6=s_1 -> Encender el motor para subir

//GpioDataRegs.GPADAT.bit.GPIO7=s_2 -> Encender el motor para bajar

//GpioDataRegs.GPADAT.bit.GPIO8=door_1 -> Abrir las puertas del piso 1

//GpioDataRegs.GPADAT.bit.GPIO9=door_2 -> Abrir las puertas del piso 2

//CODIGO

void main(){

while(1) //WHILE

while(GpioDataRegs.GPADAT.bit.GPIO4==0)

{GpioDataRegs.GPADAT.bit.GPIO6=0;

GpioDataRegs.GPADAT.bit.GPIO7=1;

GpioDataRegs.GPADAT.bit.GPIO6=0;

GpioDataRegs.GPADAT.bit.GPIO7=0;
delay_ms(1000);

do {if (GpioDataRegs.GPADAT.bit.GPIO3==1)

{GpioDataRegs.GPADAT.bit.GPIO8=1;

delay_ms(3000);

GpioDataRegs.GPADAT.bit.GPIO8=0;

delay_ms(1500);

} while(GpioDataRegs.GPADAT.bit.GPIO1==0);

GpioDataRegs.GPADAT.bit.GPIO6=1;

while(GpioDataRegs.GPADAT.bit.GPIO5==0)

GpioDataRegs.GPADAT.bit.GPIO6=0;

do {if (GpioDataRegs.GPADAT.bit.GPIO3==1)

{GpioDataRegs.GPADAT.bit.GPIO9=1;

delay_ms(3000);

GpioDataRegs.GPADAT.bit.GPIO9=0;

delay_ms(1500);

} while(GpioDataRegs.GPADAT.bit.GPIO2==0);

GpioDataRegs.GPADAT.bit.GPIO7=1;