Trabajo Práctico 1 - UNR · Web viewDepartamento de Sistemas e Informática Electrónica Facultad de Cs. Exactas, Ingeniería y Agrimensura Trabajo de promoción Manejo de un motor

Informática Electrónica

Departamento de Sistemas e Informática Electrónica

Facultad de Cs. Exactas, Ingeniería y Agrimensura

Trabajo de promoción

Manejo de un motor paso a paso

Autores Nº Legajo Firma

Alfredo Luque L-1673/0

Mariano Olivera O-0584/3

Informática Electrónica – Trabajo Practico 1

Introducción

Teniendo la placa de desarrollo ACKIT, implementamos el mismo haciendo uso de los periféricos del mismo y la interfase serie /USB para interaccionar con la PC por medio del Terminal Windows de P&E micro.La consigna es realizar el control de velocidad y posición del motor paso a paso que recibirá las señales de pulsos del KIT a través de una interfase de transistores para comandar sus bobinas e indicara por medio de LEDs externos la secuencia de activación. Desarrollamos un modo ‘remoto’ que comanda las diferentes funciones del motor por puerto serie y un modo ‘local’ que permite comandarlo por medio de los switch y potenciómetro integrado indicando los estados a través de los LEDs integrados.Logramos duplicar sus pasos, Implementando ‘medio paso’ por medio de la superposición de la secuencia de activación de las bobinas.

Desarrollo

Existen 2 modos, local/remoto, seleccionables por el SW1 e indicado por el LED1. Dentro de los cuales hay diferentes estados que definen el funcionamiento del mismo.

1- Modo Local, el motor se controla por medio de los switchs integrados al KIT que definen su estado.

SW4, LED4: Arranque/Parada del motor. SW2, LED2: Giro directo/inverso. SW3, LED3: Velocidad/Posición,

Velocidad: Es el modo por defecto, comienza detenido al inicializar el sistema, presionando SW4 le doy arranque y gira a la velocidad dada por el potenciómetro y según el sentido de giro dado por SW2, presionando SW4 lo detengo.

Posición : Control relativa de la posición, inicialmente toma el cero donde quedo el motor y lo mueve por medio del potenciómetro que indica los pasos relativos en sentido directo o inverso según el sentido de giro del mismo, presionando SW2 invierto el sentido de giro dado por el potenciómetro.

2- Modo Remoto, el motor se controla por medio del Terminal Windows y los comandos definen su estado.

Los comandos validos son los siguientes:

V+xx: Define el giro en sentido directo a xx pasos por segundo. V-xx: Define el giro en sentido inverso a xx pasos por segundo. P+xx: El motor se posiciona a xx pasos hacia su sentido directo. P- xx: El motor se posiciona a xx pasos hacia su sentido inverso. S: Frenado de emergencia del motor.

Todos estos comandos empiezan a tener efecto en forma inmediata al presionar enter después del comando valido por más que este ejecutando otro.

Pag. 2 de 21


Los códigos de error y avisos:

OK: Comando valido a ejecutarse. START: Motor en marcha. STOP: Motor frenado. T: Error en el canal de datos SCI. I: Entrada de comandos incorrecta. B: Buffer overflow

El funcionamiento en general se basa en habilitar 4 salidas de pulsos de tensión, en una secuencia adecuada para el giro directo e inverso del motor, designada por programa, los intervalos de activación y desactivación de los pulsos darán mayor o menor frecuencia al giro. Estos pulsos de tensión entran al TTL compatible ‘ULN2003’, un array de transistores en configuración Darlington, excitando sus bases con pulso + logramos activar las bobinas del motor que este comanda, La secuencia de bobinas es A+, B+, A-, B- . Los ‘medio paso’ se dan al excitar 2 bobinas contiguas al mismo tiempo, por lo cual superpusimos las señales de activación obteniendo 8 pasos por secuencia, duplicando así la cantidad de pasos total. Dicho motor posee su propia alimentación en una protoboard que contiene además el ULN2003 y los 4 LEDs que muestran los estados de las bobinas y su secuencia.En el modo por defecto, al inicializar el sistema es modo ‘local’ y función velocidad detenida, al pulsar el SW4 el motor comienza a girar a una velocidad comandada por la señal analógica del potenciómetro que entra al ADC, el rango de velocidad es de frenado a 350 pasos por segundos definida al determinar experimentalmente una frecuencia máxima del motor de 380 pps luego de la cual comenzaba a perderse pasos y funcionar mas lentamente de lo previsto. Presionando SW3, el motor invertirá su giro manteniendo el mismo modulo de velocidad, Presionando SW2, podemos controlar la posición del mismo según una posición relativa dada por la posición inicial del motor a partir de la cual se determina el cambio en el valor de la señal analógica, para sacar la cantidad de pasos a efectuar. Si esta diferencia da positiva o negativa el motor girara esa cantidad de pasos en un sentido u otro, guardando una relación directa entre sentido de giro de la ‘ruedita’ y sentido de giro del motor, relación que se invierte al presionar SW3.El modo remoto se entra presionando SW1, el motor comienza su control por medio del Terminal con los comandos especificados, pudiendo girar a la velocidad seteada por ‘V; y en el sentido dado por su signo, también se puede comandar su posición en pasos según el valor de P y el sentido dado por su signo, luego con le comando ‘S’ se hace una parada del sistema, el mismo indica en el terminal ‘OK’ si comprueba un dato valido a ejecutar y ‘START’ cuando habilita el giro y ‘STOP’ cuando lo deshabilita.

ConclusionesLa realización del trabajo la encaramos con objetivos de realizar una tarea integral desarrollando un programa que saque provecho del funcionamiento del motor paso a paso por lo cual lo implementamos en forma real para lidiar con todos los detalles que esto significa en cuanto a hardware y software, nos ayudo mucho el usar el KIT porque ya trae integrada ciertas funcionalidades que dan comodidad y reducen los tiempos de desarrollo también del lenguaje C. Este desarrollo tiene infinidades de aplicaciones concretas ya muy conocida que con poca adaptación o mejoras se pueden implementar en distintas áreas.

Pag. 3 de 21


Circuito de aplicacion

Anexo 1 - Archivo main.h

// Modulo SCI: interfase con el P&E Micro UF32E// que necesita 115200 baud, 8bits, sin paridad//// SCI BaudRate = BusClock /(16 * SC1BD) = 115200// SC1BD = 16MHz / (16*115200) = 8.68 =~ 9

Pag. 4 de 21


// es un valor aproximado, pero funciona#define SCI_SC SCI1C2// SCI_SC: RE=1 | TE=1 | RIE=1 -> 0010 1100#define SCI_SET 0x2C

// Modulo ADC1// Entrada: 0 ~ 255 -> valorADC// Escala de salida: 0 a 100 % de velocidad maxima//// Se utilizan valores *100 para los calculos,// obteniendo "decimales virtuales" para mayor precision.// Para mostrar los valores afuera, se divide por 100.

#define ADC_SET 0x48#define ADC_SC ADC1SC1//

// Timer TPM3 ; FuxedSysClock = 2MHz ; PreScaler = 16// To = PreScaler / BusClock = 8us// TimerClock = 1/To = 125 KHz// La cuenta del timer tiene unidades de 16us// Tp = To * (tPeriodo +1)#define TIMERCLOCK 125000

#define tPeriodo TPM3MOD#define TIMER_MOD TPM3MOD// Configuracion del Timer3: TOIE=1 | CLKSB=1 | PS = 100#define TIMER_SET 0x54#define TIMER_SC TPM3SC// Maximo periodo : 0.5 seg // -> 1 paso por seg// TIMER_MODMax = 0.5s / 8us = 62500#define TOMAX 62500 //65535// Maxima frecuencia: 360 semi-pasos por seg = 180 PPS#define PPS_MAX 360// Minimo periodo: 5ms// -> tPeriodoMin= TimerClock / pasosPorSeg = 125 KHz / 200 p/s = 625#define TOMIN 625

#define MOT0 PTHD_PTHD0#define MOT1 PTHD_PTHD1#define MOT2 PTHD_PTHD2#define MOT3 PTHD_PTHD3#define MOT_PORT PTHD#define MOT_MASK 0x0F

#define LED1 PTFD_PTFD0#define LED2 PTFD_PTFD1#define LED3 PTFD_PTFD4#define LED4 PTFD_PTFD5

#define KBI_VAL (PTGD&0x0F) // PTGD: registro de lectura p/ entradas SW/* KBI_VAL: 0x0F : Ninguna tecla presionada (tienen pull-up) 0x0E : SW1 presionado 0x0D : SW2 presionado 0x0B : SW3 presionado 0x07 : SW4 presionado*/

struct { byte otros :2; byte tecla :1; // Tecla presionada byte modoPos :1; // Modo 0=Posición, 1=Velocidad byte modoRemoto :1; // Control local o remoto byte adcFlag :1; // Conversion del ADC completada byte stepActivo :1; // Controlador del motor activo

Pag. 5 de 21


byte stepReverso :1;}banderas;// Lectura de los pulsadoresbyte teclaValor;// lectura de la ruedita con el ADCint adcValor;// buffer para conversion de numeros a BCDbyte bcdValor [6];// buffer para transmision por el SCIchar msgTx [15];// Set-Point de posicion, unidades: medio pasoint pasosSP = 0;// Posición estimada del motor, acumulador [semi-pasos]int pasosPos = 0;// Set-point de velocidad, [semi-pasos por seg]int pasosVelSP = 0;// Tabla de datos para la secuencia de pasos// Ordenado: A+, B+, A-, B-// binario: 0001,0101,0100,0110,0010,1010,1000,1001byte pasosTab[8]={ 0x01,0x05,0x04,0x06,0x02,0x0A,0x08,0x09};

void stop();

void start();

void controlP();

void controlV();

void unPaso(signed char signo);

void asignaLed (byte iOut);

void hex2ascii(word hex, char *bcd);

char ascii2hex(char *sval, int *ival);

void msgSend(char *msg);

void msgVal(char c, byte iVal);

void msgErr(char e);

void msgProcesar( char *msg);

void setVelocidad(int pps);

__interrupt void isrVkeyboard1(void);

__interrupt void isrVtpm3ovf(void);

__interrupt void isrVrti(void);

__interrupt void isrVadc1(void);

__interrupt void isrVkeyboard1(void);

__interrupt void isrVsci1tx(void);

__interrupt void isrVsci1rx(void);

__interrupt void isrVsci1err(void);

__interrupt void isrVicg(void);

Pag. 6 de 21


Anexo 2 - Archivo main.c

#include <hidef.h> /* for EnableInterrupts macro */#include "derivative.h" /* include peripheral declarations */

#include "main.h"

#ifdef __cplusplus extern "C"#endifvoid MCU_init(void); /* Device initialization function declaration */

void main(void) {

banderas.tecla=0; banderas.adcFlag=0; banderas.modoPos=0; // Modo = Velocidad banderas.modoRemoto=0; // Control local banderas.stepActivo=0; // Motor parado banderas.stepReverso=0; // Control directo (sin invertir) asignaLed(0xFF); // apaga todos los LED MCU_init(); /* call Device Initialization */

for(;;) { __RESET_WATCHDOG(); } /* loop forever */ /* please make sure that you never leave main */}

// ----------------------------------------------------------------------------void stop(){ TIMER_SC = 0; banderas.stepActivo = 0; LED4= 1; msgTx[0]='S'; msgTx[1]='t'; msgTx[2]='o'; msgTx[3]='p'; msgTx[4]='\n'; msgTx[5]='\r'; msgTx[6]=0; msgSend(msgTx);}

// ----------------------------------------------------------------------------void start(){ msgTx[0]='S'; msgTx[1]='t'; msgTx[2]='a'; msgTx[3]='r'; msgTx[4]='t'; msgTx[5]='\n'; msgTx[6]='\r'; msgTx[7]=0; msgSend(msgTx); LED4 = 0;

Pag. 7 de 21


TIMER_SC = TIMER_SET; banderas.stepActivo = 1;}

// ----------------------------------------------------------------------------void setVelocidad(int pps){ if(pps==0){ //stop(); //No hacer nada; esta contemplado en controlV return; }else{ if(pps<0){ pps=-pps; } } tPeriodo = (word)TIMERCLOCK / pps ;}// ----------------------------------------------------------------------------void controlV(){ if(pasosVelSP>0){ unPaso(1); }else{ if(pasosVelSP<0){ unPaso(-1); }else{ // esperar que venga una consigna != 0 } }}

// ----------------------------------------------------------------------------void controlP(){ int errorP = pasosSP - pasosPos; if(errorP > 0){ unPaso(1); pasosPos ++; }else{ if(errorP < 0){ unPaso(-1); pasosPos --; }else{ //stop(); } }}

// ----------------------------------------------------------------------------void unPaso(signed char signo){ static signed char idx = 0; MOT_PORT = pasosTab[idx]; if(signo>0){ idx++; if(idx>7){ idx = 0; } }else{ idx--; if(idx<0){ idx=7; } }}

// ----------------------------------------------------------------------------// Salida en los LED// Logica Negativa

Pag. 8 de 21


void asignaLed (byte iOut){ LED1 = ~(iOut & 1); LED2 = ~(iOut & 2)>>1; LED3 = ~(iOut & 4)>>2; LED4 = ~(iOut & 8)>>3; }

// ----------------------------------------------------------------------------// hex2ASCII// convierte un numero hexa de 16 bits en 5 digitos BCD, // y los devuelve en un string de 5 caracteres ASCII#define ASCII_0 '0'void hex2ascii(word hex, char *bcd){ byte i; bcd+=5; *bcd='\0'; // caracter de fin de string for (i=0;i<5;i++){ bcd--; *bcd = (char)(hex%10) + ASCII_0; hex = (word)(hex/10); // asegurarse que no use punto flotante ! } }

// ----------------------------------------------------------------------------// ascii2hex(char *sval, int *ival)// convierte un numero de una string a una variable int,// en formato "+nnnn" o "-nnnn"// ordenada desde la cifra mas significativa hasta la menos significativa// max: +/- 9999.// devuelve la cantidad de cifras asignadas// en caso de error, devuelve 0

char ascii2hex(char *sval, int *ival){ int iacum=0; signed char signo=1; byte ncifras=0; if(*sval=='+'){ sval++; }else{ if(*sval=='-'){ sval++; signo= -1; }else{ signo=1; } } while((*sval >='0')&&(*sval <='9')&&(ncifras<=4)){ iacum = iacum * 10 + signo * (int)(*sval - '0'); ncifras++; sval++; } if(ncifras){ // si ncifras > 0 *ival=iacum; return ncifras; }else return 0;}

// ----------------------------------------------------------------------------// msgSend// Transmite un string por el puerto SCI1

Pag. 9 de 21


void msgSend(char *msg) { if(SCI1C2_TE){ while(*msg != 0x00) { while(!SCI1S1_TDRE){} //registro no vacio -> espera SCI1D = (byte) *msg; // send data byte msg++; } // end while }}

// ----------------------------------------------------------------------------// msgOK()// Se usa para indicar la ejecucion exitosa de un comandovoid msgOK(){ msgTx[0]= 'O'; msgTx[1]= 'K'; msgTx[2]='\n'; msgTx[3]='\r'; msgTx[4]= 0; msgSend(msgTx);}

// ----------------------------------------------------------------------------// msgVal(char c, byte iVal)// Manda un mensaje de reporte de un valor,// indicado por el caracter c y el valor iVal,// por el puerto serie SCI

void msgVal(char c, byte iVal){ char bcd[6]; hex2ascii(iVal, bcd); msgTx[0]= c; msgTx[1]='='; msgTx[2]=bcd[0]; msgTx[3]=bcd[1]; msgTx[4]=bcd[2]; msgTx[5]=bcd[3]; msgTx[6]=bcd[4]; msgTx[7]='\n'; msgTx[8]='\r'; msgTx[9]=0; msgSend(msgTx);}

// ----------------------------------------------------------------------------// msgErr(char e)// Manda un mensaje de error por el puerto serie,// a traves de la funcion msgSend// El argumento e es un caracter con el codigo del error// Codigos de Error:

// T: Error en el canal de datos SCI// I: Entrada de comandos incorrecta// B: Buffer overflow

void msgErr(char e){ msgTx[0]='E'; msgTx[1]='r'; msgTx[2]=':'; msgTx[3]= e; msgTx[4]='\n'; msgTx[5]='\r'; msgTx[6]=0; msgSend(msgTx);}

Pag. 10 de 21


// ----------------------------------------------------------------------------// msgProcesar( byte *msg)// Procesa la string de entrada hasta encontrar un caracter de control

void msgProcesar( char *msg){ int iValor =0; while(*msg >= ' ' && banderas.modoRemoto){ // 32=' ' y modo remoto activo. switch(*msg){ case 'p': case 'P':{ if(ascii2hex(++msg, &iValor) >0){ // Asignacion del Set-Point de posicion en semi-pasos // Pasa a modo de control de posicion pasosPos=0; pasosSP = 2 * iValor; msgOK(); banderas.modoPos = 1; if(!banderas.stepActivo ){ start(); } }else{ msgErr('I'); } msg--; return; } case 'v': case 'V':{ if(ascii2hex(++msg, &iValor) >0){ // Asignacion del Set-Point de velocidad en pasosPorSegundo // Pasa a modo de velocidad continua pasosVelSP = iValor; banderas.modoPos = 0; setVelocidad(pasosVelSP); msgOK(); if(!banderas.stepActivo ){ start(); } }else{ msgErr('I'); } msg--; return; } case 's': case 'S':{ if(banderas.stepActivo) stop(); return; } case ' ': { msg++; break; } default: { msgErr('I'); // nunca pasa mas de una vez return; } } }}

Pag. 11 de 21


/*** ===================================================================** Interrupt handler : isrVtpm3ovf*/__interrupt void isrVtpm3ovf(void){ if(TPM3SC_TOF){ TPM3SC_TOF = 0; if(banderas.stepActivo){ if(banderas.modoPos){ controlP(); }else{ controlV(); } }else{ stop(); } }}/* end of isrVtpm3ovf */

/*** ===================================================================** Interrupt handler : isrVrti*/__interrupt void isrVrti(void){ static int adcValor2 = 0; SRTISC_RTIACK = 1; // Teclado - Verificacion de rebotes if(banderas.tecla){ if (teclaValor==(byte)KBI_VAL){ banderas.tecla = 0; switch(teclaValor){ case 0x0E:{ // SW1 Modo Local o Remoto banderas.modoRemoto = ~banderas.modoRemoto; if(banderas.modoRemoto){ LED1 = 0; banderas.adcFlag=0; ADC_SC = 0; SCI_SC = SCI_SET; }else{ LED1 = 1; ADC_SC = ADC_SET; SCI_SC = 0; } break; } case 0x0D:{ // SW2 Modo Posición / Velocidad if(!banderas.modoRemoto){ banderas.modoPos = ~banderas.modoPos; if(banderas.modoPos){ LED2 = 0; TIMER_MOD = PPS_MAX; pasosSP=0; pasosPos=0; }else{ LED2 = 1; } } break; } case 0x0B:{ // SW3 cambia el sentido de giro if(!banderas.modoRemoto){ banderas.stepReverso = ~banderas.stepReverso;

Pag. 12 de 21


banderas.adcFlag = 1; LED3=~LED3; } break; } case 0x07:{ // SW4: Parada / Arranque if(!banderas.modoRemoto){ if(banderas.stepActivo){ stop(); LED4 = 1; }else{ start(); LED4 = 0; } break; } } } } else{ // si se detectan rebotes, leer nuevamente el teclado isrVkeyboard1(); } } // Procesamiento de la lectura del ADC // Verifica que hay un dato del ADC y lo procesa if(banderas.adcFlag ){ banderas.adcFlag = 0; ADC_SC = ADC_SET ; // Habilita la siguiente conversion if(banderas.modoPos){ if(banderas.stepReverso){ pasosSP -= (adcValor - adcValor2)<<1; // el codigo <<1 es: pasos -> semipasos }else{ pasosSP += (adcValor - adcValor2)<<1; } }else{ if(banderas.stepReverso){ pasosVelSP = - adcValor2 ; }else{ pasosVelSP = adcValor2 ; } setVelocidad(pasosVelSP); } adcValor2 = adcValor; // adcValor= 0 a 255 }}/* end of isrVrti */

/*** ===================================================================** Interrupt handler : isrVadc1*/__interrupt void isrVadc1(void){ adcValor = ADC1RL; banderas.adcFlag = 1;}/* end of isrVadc1 */

/*** ===================================================================** Interrupt handler : isrVkeyboard1*/__interrupt void isrVkeyboard1(void){ static byte d,b;

Pag. 13 de 21


teclaValor = KBI_VAL; //capture which pin was pushed banderas.tecla = 1;// asignaLed(teclaValor); // Enciende todos los LED for (d=0xff;d>0;d--){ //debounce button for (b=0x80;b>0;b--){} } KBISC_KBACK = 1; //clear KBI flag

}/* end of isrVkeyboard1 */

/*** ===================================================================** Interrupt handler : isrVsci1tx*/__interrupt void isrVsci1tx(void){ /* Write your interrupt code here ... */

}/* end of isrVsci1tx */

/*** ===================================================================** Interrupt handler : isrVsci1rx*/__interrupt void isrVsci1rx(void){

if(banderas.modoRemoto){ static char msgRx[10]; static byte iRx = 0; byte iRxVal; if(SCI1S1_PF||SCI1S1_FE||SCI1S1_NF){// msgTx = "Er:SCI Rx"; iRxVal = SCI1D; iRx=0; msgErr('T'); } else{ msgRx[iRx] = SCI1D; // caracter actual guardado en buffer if(iRx > 5){ msgRx[iRx]=0; iRx=0; msgErr('B'); }else{ if(msgRx[iRx]<32){ msgRx[iRx]=0; msgProcesar(msgRx); iRx=0; // si hay un buffer overflow, agregamos un fin de string } else { iRx++; // esperamos proximo caracter } } }}}/* end of isrVsci1rx */

/*

Pag. 14 de 21


** ===================================================================** Interrupt handler : isrVsci1err*/__interrupt void isrVsci1err(void){ /* Write your interrupt code here ... */

}/* end of isrVsci1err */

/*** ===================================================================** Interrupt handler : isrVicg*/__interrupt void isrVicg(void){ /* Write your interrupt code here ... */

}/* end of isrVicg */

Anexo 3 - Archivo MCUinit.c

#include <MC9S08AC128.h> /* I/O map for MC9S08AC128CLK */#include "MCUinit.h"

/* User declarations and definitions */

/* End of user declarations and definitions */

/*** ===================================================================** Method : MCU_init (bean MC9S08AC128_80)**** Description :** Device initialization code for selected peripherals.** ===================================================================*/void MCU_init(void){ /* ### MC9S08AC128_80 "Cpu" init code ... */ /* PE initialization code after reset */ /* Common initialization of the write once registers */ /* SOPT: COPE=0,COPT=1,STOPE=0 */ SOPT = 0x53; /* SPMSC1: LVDF=0,LVDACK=0,LVDIE=0,LVDRE=1,LVDSE=1,LVDE=1,BGBE=0 */ SPMSC1 = 0x1C;

Pag. 15 de 21


/* SPMSC2: LVWF=0,LVWACK=0,LVDV=0,LVWV=0,PPDF=0,PPDACK=0,PPDC=0 */ SPMSC2 = 0x00; /* System clock initialization */ /* ICGC1: HGO=0,RANGE=1,REFS=1,CLKS1=1,CLKS0=1,OSCSTEN=1,LOCD=0 */ ICGC1 = 0x7C; /* ICGC2: LOLRE=0,MFD2=0,MFD1=1,MFD0=0,LOCRE=0,RFD2=0,RFD1=0,RFD0=0 */ ICGC2 = 0x20; ICGTRM = *(unsigned char*far)0xFFBE; /* Initialize ICGTRM register from a non volatile memory */ while(!ICGS1_LOCK) { /* Wait */ {asm sta SRS;} /* Reset watchdog counter */ } /* SOPT2: COPCLKS=1,TPMCCFG=1 */ SOPT2 = 0x88; /* Common initialization of the CPU registers */ /* PTGPE: PTGPE3=1,PTGPE2=1,PTGPE1=1,PTGPE0=1 */ PTGPE |= (unsigned char)0x0F; /* ### Init_GPIO init code */ /* PTFDD: PTFDD7=1,PTFDD6=1,PTFDD5=1,PTFDD4=1,PTFDD3=1,PTFDD2=1,PTFDD1=1,PTFDD0=1 */ PTFDD = 0xFF; /* ### Init_SCI init code */ /* SCI1BDL: SBR7=0,SBR6=0,SBR5=0,SBR4=0,SBR3=1,SBR2=0,SBR1=0,SBR0=1 */ SCI1BDL = 0x09; /* SCI1C3: R8=0,T8=0,TXDIR=1,TXINV=0,ORIE=0,NEIE=0,FEIE=0,PEIE=0 */ SCI1C3 = 0x20; /* SCI1C2: TIE=0,TCIE=0,RIE=1,ILIE=0,TE=1,RE=1,RWU=0,SBK=0 */ SCI1C2 = 0x2C; /* ### Init_ADC init code */ /* ADC1CFG: ADLPC=0,ADIV1=0,ADIV0=0,ADLSMP=1,MODE1=0,MODE0=0,ADICLK1=1,ADICLK0=0 */ ADC1CFG = 0x12; /* ADC1SC1: COCO=0,AIEN=1,ADCO=0,ADCH4=0,ADCH3=1,ADCH2=0,ADCH1=0,ADCH0=0 */ ADC1SC1 = 0x48; /* ### Init_TPM init code */ TPM3MOD = 0xFDE8; /* Period value setting */ /* TPM3SC: TOF=0,TOIE=1,CPWMS=0,CLKSB=1,CLKSA=0,PS2=1,PS1=0,PS0=0 */ TPM3SC = 0x54; /* Timer control register setting */ /* ### Init_KBI init code */ /* KBIPE: KBIPE7=0,KBIPE6=0,KBIPE5=0,KBIPE4=0,KBIPE3=1,KBIPE2=1,KBIPE1=1,KBIPE0=1 */ KBIPE = 0x0F; /* KBISC: KBACK=1 */ KBISC |= (unsigned char)0x04; /* KBISC: KBIE=1 */

Pag. 16 de 21


KBISC |= (unsigned char)0x02; /* ### Init_GPIO init code */ /* PTHDD: PTHDD7=1,PTHDD6=1,PTHDD5=1,PTHDD4=1,PTHDD3=1,PTHDD2=1,PTHDD1=1,PTHDD0=1 */ PTHDD = 0xFF; /* ### Init_COP init code */ SRS = 0xFF; /* Clear WatchDog counter */ /* ### Init_RTI init code */ /* SRTISC: RTIF=0,RTIACK=0,RTICLKS=0,RTIE=1,RTIS2=0,RTIS1=0,RTIS0=1 */ SRTISC = 0x11; /* ### Init_GPIO init code */ /* PTAPE: PTAPE7=1,PTAPE6=1,PTAPE5=1,PTAPE4=1,PTAPE3=1,PTAPE2=1,PTAPE1=1,PTAPE0=1 */ PTAPE = 0xFF; /* ### Init_GPIO init code */ /* PTBPE: PTBPE7=1,PTBPE6=1,PTBPE5=1,PTBPE4=1,PTBPE3=1,PTBPE2=1,PTBPE1=1,PTBPE0=1 */ PTBPE = 0xFF; /* ### Init_GPIO init code */ /* PTCPE: PTCPE6=1,PTCPE5=1,PTCPE4=1,PTCPE3=1,PTCPE2=1,PTCPE1=1,PTCPE0=1 */ PTCPE |= (unsigned char)0x7F; /* ### Init_GPIO init code */ /* PTJPE: PTJPE7=1,PTJPE6=1,PTJPE5=1,PTJPE4=1,PTJPE3=1,PTJPE2=1,PTJPE1=1,PTJPE0=1 */ PTJPE = 0xFF; /* ### Init_GPIO init code */ /* PTGPE: PTGPE4=1 */ PTGPE |= (unsigned char)0x10; /* ### */ asm CLI; /* Enable interrupts */} /*MCU_init*/

#pragma CODE_SEG __NEAR_SEG NON_BANKED/*** ===================================================================** Interrupt handler : isrVtpm3ovf**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing

Pag. 17 de 21


** ===================================================================*/__interrupt void isrVtpm3ovf(void);

/*** ===================================================================** Interrupt handler : isrVrti**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVrti(void);

/*** ===================================================================** Interrupt handler : isrVadc1**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVadc1(void);

/*** ===================================================================** Interrupt handler : isrVkeyboard1**

Pag. 18 de 21


** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVkeyboard1(void);

/*** ===================================================================** Interrupt handler : isrVsci1tx**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVsci1tx(void);

/*** ===================================================================** Interrupt handler : isrVsci1rx**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVsci1rx(void);

/*

Pag. 19 de 21


** ===================================================================** Interrupt handler : isrVsci1err**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVsci1err(void);

/*** ===================================================================** Interrupt handler : isrVicg**** Description :** User interrupt service routine. ** Parameters : None** Returns : Nothing** ===================================================================*/__interrupt void isrVicg(void);

#pragma CODE_SEG DEFAULT/* Initialization of the CPU registers in FLASH */

/* NVPROT: FPS6=1,FPS5=1,FPS4=1,FPS3=1,FPS2=1,FPS1=1,FPS0=1,FPOPEN=1 */const unsigned char NVPROT_INIT @0x0000FFBD = 0xFF;

/* NVOPT: KEYEN1=0,KEYEN0=1,SEC1=1,SEC0=0 */const unsigned char NVOPT_INIT @0x0000FFBF = 0x7E;

extern near void _Startup(void);

/* Interrupt vector table */#ifndef UNASSIGNED_ISR #define UNASSIGNED_ISR 0xFFFF /* unassigned interrupt service routine */#endif

Pag. 20 de 21


void (* near const _vect[])() @0xFF9C = { /* Interrupt vector table */ UNASSIGNED_ISR, /* Int.no. 0 Vspi2 (at FF9C) Unassigned */ isrVtpm3ovf /* Int.no. 1 Vtpm3ovf (at FF9E) Used */};

void (* near const _vect2[])() @0xFFC0 = { /* Interrupt vector table */ UNASSIGNED_ISR, /* Int.no. 18 Vtpm3ch1 (at FFC0) Unassigned */ UNASSIGNED_ISR, /* Int.no. 19 Vtpm3ch0 (at FFC2) Unassigned */ isrVrti, /* Int.no. 20 Vrti (at FFC4) Used */ UNASSIGNED_ISR, /* Int.no. 21 Viic1 (at FFC6) Unassigned */ isrVadc1, /* Int.no. 22 Vadc1 (at FFC8) Used */ isrVkeyboard1, /* Int.no. 23 Vkeyboard1 (at FFCA) Used */ UNASSIGNED_ISR, /* Int.no. 24 Vsci2tx (at FFCC) Unassigned */ UNASSIGNED_ISR, /* Int.no. 25 Vsci2rx (at FFCE) Unassigned */ UNASSIGNED_ISR, /* Int.no. 26 Vsci2err (at FFD0) Unassigned */ isrVsci1tx, /* Int.no. 27 Vsci1tx (at FFD2) Used */ isrVsci1rx, /* Int.no. 28 Vsci1rx (at FFD4) Used */ isrVsci1err, /* Int.no. 29 Vsci1err (at FFD6) Used */ UNASSIGNED_ISR, /* Int.no. 30 Vspi1 (at FFD8) Unassigned */ UNASSIGNED_ISR, /* Int.no. 31 Vtpm2ovf (at FFDA) Unassigned */ UNASSIGNED_ISR, /* Int.no. 32 Vtpm2ch5 (at FFDC) Unassigned */ UNASSIGNED_ISR, /* Int.no. 33 Vtpm2ch4 (at FFDE) Unassigned */ UNASSIGNED_ISR, /* Int.no. 34 Vtpm2ch3 (at FFE0) Unassigned */ UNASSIGNED_ISR, /* Int.no. 35 Vtpm2ch2 (at FFE2) Unassigned */ UNASSIGNED_ISR, /* Int.no. 36 Vtpm2ch1 (at FFE4) Unassigned */ UNASSIGNED_ISR, /* Int.no. 37 Vtpm2ch0 (at FFE6) Unassigned */ UNASSIGNED_ISR, /* Int.no. 38 Vtpm1ovf (at FFE8) Unassigned */ UNASSIGNED_ISR, /* Int.no. 39 Vtpm1ch5 (at FFEA) Unassigned */ UNASSIGNED_ISR, /* Int.no. 40 Vtpm1ch4 (at FFEC) Unassigned */ UNASSIGNED_ISR, /* Int.no. 41 Vtpm1ch3 (at FFEE) Unassigned */ UNASSIGNED_ISR, /* Int.no. 42 Vtpm1ch2 (at FFF0) Unassigned */ UNASSIGNED_ISR, /* Int.no. 43 Vtpm1ch1 (at FFF2) Unassigned */ UNASSIGNED_ISR, /* Int.no. 44 Vtpm1ch0 (at FFF4) Unassigned */ isrVicg, /* Int.no. 45 Vicg (at FFF6) Used */ UNASSIGNED_ISR, /* Int.no. 46 Vlvd (at FFF8) Unassigned */ UNASSIGNED_ISR, /* Int.no. 47 Virq (at FFFA) Unassigned */ UNASSIGNED_ISR, /* Int.no. 48 Vswi (at FFFC) Unassigned */ _Startup /* Int.no. 49 Vreset (at FFFE) Reset vector */};

/* END MCUinit */

Pag. 21 de 21

Documents

Trabajo Práctico 1 - UNR · Web viewDepartamento de Sistemas e Informática Electrónica Facultad de Cs. Exactas, Ingeniería y Agrimensura Trabajo de promoción Manejo de un motor