Sistemas Electrónicos Digitales
|
|
- Virginia Caballero Arroyo
- hace 7 años
- Vistas:
Transcripción
1 1. Realizar un programa en ensamblador para que parpadee el bit P1.0, utilizando un bucle para realizar el retardo. ;************************************************************* ; Plantilla que se crea automáticamente ; Conviene especificar el microcontrolador usado, describir ; el programa y si fuera posible las patillas utilizadas ; Microcontrolador: MSP430G2553 ; Descripción: ; MSP430G2553 ; ; / \ XIN - ; ; -- RST XOUT - ; ; P1.0 -->LED ; ; Autor: ; Empresa: UA ; Fecha: 07/07/14 ; Herramienta: IAR Embedded Workbench Version: 5.51 ;************************************************************* #include "msp430g2553.h" misp EQU 0x400 ; define el puntero de la Pila ORG 0FC00h ; inicio del programa en memoria ; RESET MOV.W #misp,sp ; Inicializa el SP MOV.W #WDTPW+WDTHOLD,&WDTCTL ; para el watchdog BIS.B #001h,&P1DIR ; el bit P1.0 como salida INICIO L1 XOR.B #001h,&P1OUT ; Conmuta el bit P1.0 MOV.W #050000,R15 ; R15=50000 para realizar un retardo ; se realiza veces el bucle L1 DEC.W R15 ; Decrementando R15 JNZ L1 ; retardo=(1+2)*50000=150000t JMP INICIO ; vuelve a empezar ; ; VECTORES ; ORG 0FFFEh DW RESET END 1
2 2. Realizar un programa en C para que parpadee el bit P1.0, utilizando un bucle para realizar el retardo. //************************************************************* int main(void) WDTCTL = WDTPW + WDTHOLD; P1DIR = 0x01; for (;;) volatile unsigned int i; P1OUT ^= 0x01; // Para el watchdog // Configura P1.0 como salida direction // Conmuta P1.0 usando la XOR i = 50000; do (i--); while (i!= 0); // Retardo 3. Realizar un programa en C que haga parpadear el bit P1.6, utilizando la función delay_cicles(nº ciclos) /* */ Enciende el led verde P1.6 Utilizando delay_cicles() #include <inttypes.h> void main() WDTCTL= WDTPW+WDTHOLD; //inclusiones. //funcion principal //Apagamos el watchdog P1SEL= 0x00; P1DIR = BIT6; //Salida el bit 6 del puerto 1 P1OUT =BIT6; //LED parte apagado while(1) //Loop infinito P1OUT =BIT6; //prende el LED delay_cycles(100000); //espera P1OUT&=~BIT6; //apaga el LED delay_cycles(100000); //espera 2
3 4. Escribe un programa en lenguaje ensamblador en el cual inicialmente el bit P1.6 esté apagado, cuando se pulse el botón colocado en P1.3 se ponga a uno el bit P1.6 y si se vuelve a pulsar que se apague. Esto se debe realizar de forma indefinida. ;******************************************************************** #include "msp430g2553.h" ; ORG 0FC00h ; Definimos la direccion de inicio ; RESET MOV.W #0400h,SP ; Establecemos el SP MOV.W #WDTPW+WDTHOLD,&WDTCTL ; Detenemos el watchdog timer MOV.B #040h,&P1DIR ; Colocamos P1.6 salida resto entrada MOV.B #00h,&P1OUT BIS.B #BIT3, &P1REN ; Resistencia en la entrda P1.3 BIS.B #BIT3, &P1OUT ; Resistencia de pull-up SIGUE BIT.B #BIT3, &P1IN ; si pulsado AND XXXX 0XXX JZ ENCIENDE ; si pulsado salta y enciende P1.6 JMP APAGA JMP SIGUE APAGA BIC.B #BIT6,&P1OUT JMP SIGUE ENCIENDE BIS.B #BIT6,&P1OUT JMP SIGUE ; ; Vectores Interrupción ; ORG 0FFFEh ; Vector RESET MSP 430 DW RESET ; END 3
4 5. Escribe un programa en lenguaje C en el cual inicialmente el bit P1.6 esté apagado, cuando se pulse el botón colocado en P1.3 se ponga a uno el bit P1.6 y si se vuelve a pulsar que se apague. Esto se debe realizar de forma indefinida. #include <msp430g2553.h> int i; void main(void) WDTCTL = WDTPW + WDTHOLD; P1OUT &= ~0x40; P1DIR = 0x40; P1DIR &= ~0x08; P1REN = 0x08; P1OUT = 0x08; // para el watchdog // P1.6 a cero // P1.6 (LED) como salida // P1.3 (push button) como entrada // P1.3 (botón) resistencia habilitada // P1.3 (botón) resistencia pull-up while (1) if( BIT3 & ~P1IN ) // Si se pulsa botón P1OUT ^= 0x40; // led encendido 6. Añade un antirrebotes al ejercicio 3 7. Añade un antirrebotes al ejercicio 4 8. Supongamos que la ejecución normal del programa consiste en el desplazamiento de un bit, empezando en el P2.0, después se encenderá el P2.0 y el P2.1, después el P2.0, P2.1 y P2.2, así sucesivamente hasta llega al P2.7, que vuelve a empezar. Si en el bit P1.3 hay un flanco de bajada se debe atender la interrupción ejecute el correspondiente servicio (ISR) que deberá sacar por P2 la siguiente secuencia: secu DC b, b, b, b DC8 DC8 DC8 Finsecu DC b, b, b, b b, b, b, b b, b, b, b b Cuando se encuentre el valor b se debe salir de la interrupción y continuar por donde iba. Escribir el programa en ensamblador 4
5 ; #include "msp430g2553.h" #define misp 0x400 main - ORG 0xFC00 ;Inicio del programa - RESET MOV.W #misp,sp ; Inicia SP MOV.W #WDTPW+WDTHOLD,&WDTCTL ; Detiene WD ; esto es opcional para conseguir la frecuencia MOV.B &CALDCO_1MHZ, &DCOCTL ; calibra la f a 1MHz MOV.B &CALBC1_1MHZ, &BCSCTL1 ; calibra la f a 1MHz - BIC.B #BIT3, &P1DIR ; P1.3 IN # b BIS.B #BIT3, &P1OUT ; P1.3 Resist pullup, resto a cero b BIS.B #BIT3, &P1REN ; P1.3 Resist pullup habilitada BIS.B #BIT3, &P1IES ; flanco de bajada para P1.3 BIC.B #BIT3, &P1IFG ; borrar flags de interrup para P1.3 BIS.B #BIT3, &P1IE ; interrup locales habilita para P1.3 EINT ; GIE <--1 MOV.B #0xFF,&P2DIR ; P2 como salida b ; ; PROGRAMA PRINCIPAL EN EJECUCIÓN ; MOV.B #00h,&P2SEL ; obligatorio para que P2.6 y P2.7 sean salida sigue MOV.B #00h,&P2OUT ; apagamos los diodos MOV.W #00010h,R14 ; R14 y R15 para pasar parámetros MOV.W #020000,R15 ; R14 y R15 para pasar parámetros CALL #retardo ; que se note que se apagan todos SETC ; C <-- 1 MOV.B #00h, R7 ; R7 < vuelta RLC.B R7 ; rotar R7 a la izda incluido C MOV.B R7,&P2OUT ; P2.0 a P2.7 pone ceros, apaga, MOV.W #0005h,R14 ; R14 y R15 para pasar parámetros MOV.W #025000,R15 ; R14 y R15 para pasar parámetros CALL #retardo MOV.B R7,R8 ; R7 --> R8 para saber si he terminado XOR.B #0FFh,R8 ; averigua si se han apagado P2.0 a P2.7 JZ sigue ; si es así, volvemos a empezar JMP vuelta ; si no, se continua rotando 5
6 ; P1_3_ISR; Rutina de servicio a la interrupción ; PUSH R7 PUSH R8 PUSH R11 PUSH R12 MOV #secu,r5 ; Asigna a la secu1 el puntero (R5) ETQ1 MOV.W #7,R14 ; R14 y R15 para pasar parámetros MOV.W #25000,R15 ; a la subrutina retardo CALL #retardo CMP Finsecu,0(R5) JNE ETQ1 BIC.B #BIT3,&P1IFG ; Borra la flag de la interrupción POP R12 POP R11 POP R8 POP R7 RETI ; retardo ; MOV R14,R11 ; Valores del retardo b2 MOV R15,R12 ; se pueden ajustar b1 DEC.W R12 ; bucle fino R12 JNZ b1 DEC.W R11 ; bucle grueso JNZ b2 RET ; ; Definicion de las secuencias ; secu DC b, b, b, b DC b, b, b, b DC b, b, b, b DC b, b, b, b Finsecu DC b ; ; Vectores de Interrupción y Reset ; ORG 0FFFEh ; Vector para el reset DW RESET ORG 0FFE4h ; Vector para la interrupción del P1 DW P1_3_ISR END main 6
7 9. Supongamos que la ejecución normal del programa consiste en el desplazamiento de un bit, empezando en el P2.0, después se encenderá el P2.0 y el P2.1, después el P2.0, P2.1 y P2.2, así sucesivamente hasta llega al P2.7, que vuelve a empezar. Si en el bit P1.3 hay un flanco de bajada se debe atender la interrupción ejecute el correspondiente servicio (ISR) que deberá sacar por P2 la siguiente secuencia: secu DC b, b, b, b DC8 DC8 DC8 DC8 Finsecu DC b, b, b, b b, b, b, b b, b, b, b b, b, b, b b Cuando se encuentre el valor b se debe salir de la interrupción y continuar por donde iba. Esrcribir el programa en C 7
8 char secu[21] = 0x01,0x02,0x04, 0x08,0x10,0x20,0x40,0x80, 0x40,0x20, 0x10, 0x08,0x04,0x02,0x01; char secu_interrup[24] = 0x01,0x03,0x07, 0x0F,0x1F,0x3F,0x7F,0xFF, 0x7F,0x3F, 0x1F, 0x0F,0x07,0x03,0x01,0x00,0xFF,0x00, 0xFF,0x00,0xFF,0x00,0xFF,0x00; int i,r,j; // Rutina de Retardo void RETARDO(void) r = 20000; do (r--); while (r!= 0); void main(void) WDTCTL = WDTPW + WDTHOLD; // para el watchdog DCOCTL = CALDCO_1MHZ; //calibra la f a 1MHz BCSCTL1 = CALBC1_1MHZ; // configuración de los puertos P2SEL &= ~0xFF; // P2 como I/O general (GPIO) P2DIR = 0xFF; // P2 como salida P1DIR &= ~0x08; // P1.3 (push button) como entrada P1REN = 0x08; // P1.3 (botón) resistencia habilitada P1OUT = 0x08; // P1.3 (botón) resistencia pull-up // configuración de la interrupción de P1.3 P1IES = 0x08; // flanco de bajada para P1.3 P1IFG &= ~0x08; // borrar flags de interrup para P1.3 P1IE = 0x08; // interrup locales habilita para P1.3 _BIS_SR(GIE); // GIE <--1 // enable_interrupt(); // equivalente a la anterior, se debe cambiar // msp430.h por <io430.h> while(1) for (i = 0; i <15 ; i++) if( BIT3 & P1IN ) // Si NO se pulsa botón P2OUT = secu[i]; RETARDO(); // // Rutina de atención de interrupción del puerto P1 // #pragma vector=port1_vector interrupt void P1_Interrupt(void) for (j = 0; j <24 ; j++) P2OUT = secu_interrup[j]; RETARDO(); P1IFG &= ~BIT3; // Reseta IFG para P1.3 8
9 10. El circuito de la figura tiene el μc alimentado a 3,3V, y los displays de 7 segmentos son de cátodo común. Encenderemos los segmentos mediante los bits del P1 y seleccionamos el que debe encenderse mediante el P2(P2.0 y P2.1). Calcula el valor de las resistencias R1 y R2, sabiendo que: I LED =5mA; V LED =1,8V V CEsat =0,2V; β= 200 La corriente proporcionada por cada patilla de un puerto de salida debe estar entre 4 y 5 ma como máximo y la corriente máxima que debe proporcionar un puerto en conjunto no debe exceder de los 25 ma. Fig.1 circuito R1=300Ω 330Ω ; R2=21600Ω 22KΩ 11. Escribir un programa en C para el circuito del problema anterior. Al pulsar el botón se iniciará la cuenta de 0 a 99 con un periodo aproximado de 1s. El pulsador solicita una interrupción en P1.3 por flanco de bajada 9
10 #include <msp430g2553.h> unsigned int r, i, j; char display[10] = 0x77,0x06,0xB3, 0x97,0xC6,0xD5,0xF5,0x07,0xF7,0xC7; //gfedcba -> p1.7,6,5,4,2,1,0 // Rutina de Retardo void RETARDO(void) r = 200; do (r--); while (r!= 0); int main(void) WDTCTL = WDTPW + WDTHOLD; // Paramos el WDT BCSCTL1 = CALBC1_1MHZ; // Y establecemos una frecuencia DCOCTL = CALDCO_1MHZ; // de un 1MHz P1DIR = 0xF7; // P1.3 como entrada, resto como salidas P2DIR = BIT0+BIT1; // P2.0 y P2.1 como salidas P1OUT = BIT3; // resitencia pull-up P1REN = BIT3; // P1.3 con resistencia de pullup P1IE = BIT3; // P1.3 con interrupción habilitada P1IES = BIT3; // y activa por flanco de bajada _BIS_SR(LPM0_bits + GIE); // Habilita interrupciones y deshabilita la CPU y MCLK #pragma vector=port1_vector // Rutina de servicio para la interrupción del P1 interrupt void Port_1(void) // forma de llamar a la ISR del P1 i = 0; j = 0; for (j = 0; j < 10; j++) for (i = 0; i < 10; i++) int k; for (k=0; k< 100; k++) P1OUT = display[i]; // Pone el número en P1 P2OUT = 0x01; // Y activa el display de las unidades RETARDO(); P1OUT = display[j]; // Pone el otro número en P1 P2OUT = 0x02; // Y activa el display de las decenas RETARDO(); P2OUT = 0x03; // deja activos los dos displays P1IFG &= ~0x08; // borra el flag de petición de interrupción 10
11 12. Escribir un programa en ensamblador para el circuito del problema anterior. Al pulsar el botón se iniciará la cuenta de 0 a 99 con un periodo aproximado de 1s. El pulsador solicita una interrupción en P1.3 por flanco de bajada. #include <msp430g2553.h> Tmux DEFINE 300 main ;Esto viene bien por lo del "run tu main", aunque se puede quitar ORG 0F800h RESET ; Configuración MOV #0280h,SP MOV #WDTPW+WDTHOLD,&WDTCTL MOV.B &CALBC1_1MHZ,&BCSCTL1 ; Funciones de Calibración a 1MHz MOV.B &CALDCO_1MHZ,&DCOCTL MOV.B #BIT6+BIT0,&P1DIR MOV.B #0x0,&P1OUT ; para que estén apagados MOV.B #0F7h,&P1DIR ; P1.3 como entrada y el resto como salidas BIS.B #BIT3,&P1REN ; Resistencia en la entrada P1.3 BIS.B #BIT3,&P1OUT ; Decimos que sea de pull-up BIS.B #BIT3,&P1IES ; Defino P1.3 como activo por flanco de bajada BIS.B #BIT3,&P1IE ; Y lo habilito como entrada de interrupción BIS.B #BIT0+BIT1,P2DIR ; Defino P2.0 y P2.1 como salidas MOV.B #GIE,SR ; Habilitación global de las interrupciones jmp $ ; Programa principal 11
12 ; Rutina de tratamiento de la interrupción P1_ISR MOV #TSeg,R4 ; Inicializamos los punteros de Unidades y MOV #TSeg,R5 ; Decenas con la dirección de la tabla de segmentos CLR R6 ; Unidades = 0 CLR R7 ; Decenas = 0 Tiempo MOV.B #100,R10 ETIQ1 ; PUni al Puerto de Salida MOV.B #001h,&P2OUT ; Visualiza dato en posicion de las Unidades CALL #RETARDO ; Tiempo que está encendido el dígito ; PDcn al Puerto de Salida MOV.B #002,&P2OUT ; Visualiza dato en posicion de las decenas CALL #RETARDO ; Tiempo que está encendido el dígito DEC R10 JNZ ETIQ1 INC R6 ; Unidades = Unidades + 1 INC R4 ; Actualiza el puntero de unidades CMP #10,R6 ; Unidades es 9? JNE Tiempo CLR R6 ; Unidades = 0 MOV #TSeg,R4 ; Restaura la dirección de la Tabla de segmentos INC R7 ; Decenas = Decenas + 1 INC R5 ; Actualiza el puntero de decenas CMP #10,R7 ; Decenas es 9? JNE Tiempo CLR R6 ; Unidades = 0 MOV #TSeg,R4 ; Restaura la dirección de la Tabla de segmentos INC R7 ; Decenas = Decenas + 1 INC R5 ; Actualiza el puntero de decenas CMP #10,R7 ; Decenas es 9? JNE Tiempo MOV.B #BIT3,&P1OUT ; Para apagar el display al terminar MOV.B #BIT0+BIT1,&P2OUT BIC.B #BIT3,&P1IFG ; Borra el flag de interrupcion RETI 12
13 ; Subrutina de retardo RETARDO MOV #Tmux,R15 ETIQ2 DEC R15 JNZ ETIQ2 RET ; Tabla de 7 segmentos ; Están ordenados g-f-e-d-c-b-a TSeg ; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 DC8 77h,06h,0B3h,97h,0C6h,0D5h,0F5h,07h,0F7h,0C7h ; Vectores de interrupción y reset ORG 0FFFEh ; Vector de reset DW RESET ORG 0FFE4h ; Vector de interrupción para P1 DW P1_ISR END main 13. Escribe un programa en C para que cuando cada vez que se pulse el P1.3, interrupción por flanco de bajada, cambie la frecuencia de parpadeo de los dos diodos colocados en P1.0 y P1.6 13
14 #include <inttypes.h> int j=0; int Tini=30000; void main() WDTCTL= WDTPW+WDTHOLD; P1SEL= 0x00; P1DIR = (BIT0+BIT6); P1DIR&=~BIT3; P1REN =BIT3; P1OUT =BIT3; //resistencia en la entrada habilitada // de pull-up P1IE =BIT3; P1IES =BIT3; P1IFG&=~BIT3; //Habilitamos las interrupciones, //mas información en la userguide. P1OUT =BIT0; P1OUT&=~BIT6; _BIS_SR(GIE); //Habilitamos las interrupciones generales. IMPORTANTE!! while(1) for(j=0;j<tini;j++); //El mismo código anterior P1OUT^=BIT6; P1OUT^=BIT0; if(tini<=1500)tini=30000; Rutina de interrupción. #pragma vector= PORT1_VECTOR interrupt void Led_ISR (void) P1IFG&=~BIT3; //Al salir de una interrupción //SIEMPRE es necesario limpiar la bandera. Tini=Tini-5000; 14
15 14. Escribir un programa en ensamblador para que el bit P1.0 parpadee utilizando la interrupción del Watchdog. El periodo de parpadeo será aproximadamente 30ms, si la fuente del reloj es por defecto DCO=SMCLK ;*********************************************************************** ; ORG 0FC00h ; Reset ; RESET mov.w #0400h,SP ; Inicializa stackpointer SetupWDT mov.w #WDT_MDLY_32,&WDTCTL ; WDT~30ms intérvalo del timer bis.b #WDTIE,&IE1 ; habilita interrupción del WD SetupP1 bis.b #001h,&P1DIR ; P1.0 salida ; Mainloop bis.w #CPUOFF+GIE,SR ; CPU off, habilita Interrup Jmp $ ; se para aquí ; ; WDT_ISR; Cambia P1.0 ; xor.b #001h,&P1OUT ; cambia P1.0 reti ; ; ; ; Vectores de Interrupción ; ORG 0FFFEh ; MSP430 RESET Vector DW RESET ; ORG 0FFF4h ; WDT Vector DW WDT_ISR ; END 15
16 15. Escribir un programa en ensamblador para que el bit P1.0 parpadee utilizando la interrupción del Watchdog. El periodo de parpadeo será exactamente 250ms basado en el cristal de 32KHz colocado en las patillas del microcontrolador. Teniendo en cuenta que la fuente del reloj será ACLK=LFXT1=32768Hz, y MCLK=SMCLK=DCO. Si dividimos los 2 15 / 2 13 obtendremos una frecuencia de 4Hz, es decir un T=250ms. ;********************************************************************* ; ORG 0FC00h ; Reset ; RESET mov.w #0400h,SP ; Inicializa stackpointer Setup mov.w #WDT_ADLY_250,&WDTCTL ; WDT 250ms bis.b #WDTIE,&IE1 ; habiita la INT del WDT SetupP1 bis.b #001h,&P1DIR ; P1.0 salida ; Mainloop bis.w #LPM3+GIE,SR ; Modo LPM3, INT habilitadas Jmp $ ; WDT_ISR; Cambia P1.0 ; xor.b #001h,&P1OUT ; Cambia P1.0 reti ; ; ; ; Interrupt Vectors ; ORG 0FFFEh ; MSP430 RESET Vector DW RESET ; ORG 0FFF4h ; WDT Vector DW WDT_ISR ; END 16
17 16. Escribe un programa que utilizando la interrupción software TA_0, cambie el P1.6 cada ciclos de SMCLK. SMCLK proporciona la fuente de reloj para TACLK. Durante la ISR de TA_0, P1.6 se enciende y apaga cada ciclos de reloj. La CPU está normalmente apagada y se pone en marcha sólo durante el ISR de TA. ;************************************************************************* ; ORG 0FC00h ; Reset ; RESET mov.w #0400h,SP ; Inicializa SP StopWDT mov.w #WDTPW+WDTHOLD,&WDTCTL ; Stop WDT SetupP1 bis.b #BIT0,&P1DIR ; P1.0 salida SetupC0 mov.w #CCIE,&CCTL0 ; habilita INT de CCR0 mov.w #50000,&CCR0 ; SetupTA mov.w #TASSEL_2+MC_2,&TACTL ; SMCLK, modo cont ; Mainloop bis.w #CPUOFF+GIE,SR ; CPU off, INT habilitadas jmp $ ; TA0_ISR; Cambia P1.0 ; xor.b #001h,&P1OUT ; Cambia P1.0 add.w #50000,&CCR0 ; AñAde el Offset a CCR0 reti ; ; ; ; Interrupt Vectors ; ORG 0FFFEh ; MSP430 RESET Vector DW RESET ; ORG 0FFF2h ; Timer_A0 Vector DW TA0_ISR ; END 17
18 17. Escribir un programa en ensamblador que visualice ACLK en P1.0, SMCLK en P1.4 y que en P1.1 se obtenga una frecuencia de aproximadamente SMCLK/ Utilizando consulta (polling), de los bits P1.4 y P1.5. Generar el programa que permita realizar lo siguiente: a) Cuando P1.4 tengan un flanco de bajada se realizará una salida por el puerto P2 (irán apagándose los leds de mayor a menor peso), con un tiempo de aproximadamente 500ms b) Cuando P1.5 tengan un flanco de bajada se realizará una salida por el puerto P2 (irán apagándose los leds de menor a mayor peso), con un tiempo de aproximadamente 1s SOLUCIÓN 18
19 19. Qué ventaja tiene utilizar _BIS_SR(GIE)frente a enable_interrupt()para habilitar las interrupciones globales. Con _BIS_SR(GIE)se puede, además, modificar el resto de bits del registro SR, por ejemplo establecer el modo de trabajo LPM0, que sería, _BIS_SR(LPM0+GIE)mientras que con enable_interrupt()solamente podemos habilitar las interrupciones globales. 19
20 20. Escribir un programa que realice lo siguiente. Cuando se pulsa reset se está ejecutando una secuencia que consiste en desplazar un bit a uno de izquierda a derecha y de derecha a izquierda por los 8 bits del puerto 2. Cuando se pulsa por primera vez el pulsador S2, colocado en P1.3, se para la secuencia y cuando se vuelve a pulsar por segunda vez se continúa por donde iba la secuencia. char secuencia[15] = int i,j; int ii=0; int parar=0; 0x01,0x02,0x04, 0x08,0x10,0x20,0x40,0x80, 0x40,0x20, 0x10, 0x08,0x04,0x02,0x01; // variable para saber por donde va las secuencia void main(void) WDTCTL = WDTPW + WDTHOLD; // para el watchdog DCOCTL = CALDCO_1MHZ; //calibra la f a 1MHz BCSCTL1 = CALBC1_1MHZ; // configuración de los puertos P2SEL &= ~0xFF; // P2 como I/O general (GPIO) P2DIR = 0xFF; // P2 como salida P1DIR &= ~0x08; // P1.3 (push button) como entrada P1REN = 0x08; // P1.3 (botón) resistencia habilitada P1OUT = 0x08; // P1.3 (botón) resistencia pull-up // configuración de la interrupción de P1.3 P1IES = 0x08; // flanco de bajada para P1.3 P1IFG &= ~0x08; // borrar flags de interrup para P1.3 P1IE = 0x08; // interrup locales habilita para P1.3 //_BIS_SR(GIE); // GIE <--1 enable_interrupt() ; //es equivalente a la anterior 20
21 while(1) for (i = ii; i <15 ; i++) P2OUT = secuencia[i]; if (parar==1) break; //P2OUT = secu[i]; delay_cycles(100000); ii=i; //para saber por donde va la secuencia if (ii==15) ii=0; // si se ha llegado al final de la secuencia // ponerla a cero while (parar==1) P2OUT = secuencia[ii-1]; //se resta para que muestre el adecuado // // Rutina de atención de interrupción del puerto P1 // #pragma vector=port1_vector interrupt void P1_Interrupt(void) delay_cycles(250000); //antirrebotes software este valor es el más adecuado parar ^= 1; P1IFG &= ~BIT3; // Pone a cero IFG para P1.3 21
22 21. Utilizar el Timer 1 en modo continuo con el módulo captura/compara 0 para que el led P1.0 parpadee cada 0,1s (utilizar MCLK = 1MHz). int main(void) WDTCTL = WDTPW + WDTHOLD; DCOCTL = CALDCO_1MHZ; BCSCTL1 = CALBC1_1MHZ; P1DIR = 0x01; TA1CCTL0 = CCIE; TA1CCR0 = 50000; // Paramos el WDT //calibra la f a 1MHz // P1.0 como salida para el LED // Habilito la interrupciones del // Registro Captura/Compara 0 del Timer A1 // Y cargo este registro con el número de // ciclos que quiero contar TA1CTL = TASSEL_2 + ID_1 + MC_2; // Seleccionamos SMCLK como fuente de reloj, //la divido por dos y modo continuo // *********************************************************************** // f= ; /2= à T= 2us; cuento pulsos*2us=0,1ms // *********************************************************************** //En registro de control del timer, para cada uno de los campos está la opción //elegir los bits de forma individual o directamente el modo (aparecen con //subguión) //Como voy a trabajar en modo comparación no hace falta que modifique el bit CAP _BIS_SR(LPM0_bits + GIE); // habilitamos el modo 0 de bajo //consumo y habilitamos las interrupciones // Rutina de servicio de la interrupción del Timer 1 #pragma vector=timer1_a0_vector interrupt void Timer_A0 (void) P1OUT ^= 0x01; TA1CCR0 += 50000; // Hacemos cambiar al LED // Se recarga el registro con valor que //debe contar para conseguir 0,1s 22
23 22. Utilizar el Timer 1 en modo ascendente con el módulo captura/compara 0 para que el led P1.0 parpadee cada 0,1s (utilizar MCLK = 1MHz) int main(void) WDTCTL = WDTPW + WDTHOLD; DCOCTL = CALDCO_1MHZ; BCSCTL1 = CALBC1_1MHZ; P1DIR = 0x01; TA1CCTL0 = CCIE; TA1CCR0 = 50000; // Paramos el WDT //calibra la f a 1MHz // P1.0 como salida para el LED // Habilito la interrupciones del // Registro Captura/Compara 0 del Timer A1 // Y cargo este registro con el número de // ciclos que quiero contar TA1CTL = TASSEL_2 + ID_1 + MC_1; // Seleccionamos SMCLK como fuente de reloj, //la divido por dos y modo ASCENDENTE // *********************************************************************** // f= ; /2= à T= 2us; cuento pulsos*2us=0,1ms // *********************************************************************** //En registro de control del timer, para cada uno de los campos está la opción //elegir los bits de forma individual o directamente el modo (aparecen con //subguión) //Como voy a trabajar en modo comparación no hace falta que modifique el bit CAP _BIS_SR(LPM0_bits + GIE); // habilitamos el modo 0 de bajo //consumo y habilitamos las interrupciones // Rutina de servicio de la interrupción del Timer 1 #pragma vector=timer1_a0_vector interrupt void Timer_A0 (void) P1OUT ^= 0x01; // Hacemos cambiar al LED 23
24 23. Escribir un programa para que el led P1.0 parpadee unas 8 veces por segundo (suponiendo que MCLK = 1 MHz) por desbordamiento del timer. Cuando se desborda el timer el flag TAIFG se activa y se produce la llamada a la interrupción. Para saber quien ha producido la llamada a la interrupción bastaría consultar los flags (CCIFG1, CCIFG2, TAIFG), pero habría que hacerlo por encuesta. Para evitarlo, el MSP430 tiene el registro TAIV, que nos ayudará a identificar la fuente de interrupción rápidamente. Este registro contiene un valor que viene determinado por la fuente de interrupción, 0x000A para el overflow del Timer. Este ejemplo es interesante verlo en ensamblador. int main(void) WDTCTL = WDTPW + WDTHOLD; P1DIR = 0x01; TA0CTL = TASSEL_2 + MC_2 + ID_1 + TAIE; // Paramos el WDT // P1.0 como salida para el LED // Seleccionamos SMCLK como fuente // de reloj, modo continuo, % por 2 y // habilita interrupciones _BIS_SR(LPM0_bits + GIE); #pragma vector=timer0_a1_vector interrupt void Timer_A0 (void) /* switch(ta0iv) */ case 2: break; case 4: break; // habilitamos el modo 0 de bajo // consumo y habilitamos // las interrupciones globales // Este es el caso de que se haya activado CCIFG1 // Este es el caso de que se haya activado CCIFG2 case 10: P1OUT ^= 0x01; // Y este es el timer overflow break; P1OUT ^= 0x01; 24
25 24. Repetir el ejercicio anterior, en ensamblador. HOJA DE EJERCICIOS (curso 2014/15) #include <msp430g2553.h> ORG 0F800h RESET mov.w #0400h,SP ;Incializamos el SP mov.w #WDTPW+WDTHOLD,&WDTCTL ;Paramos el WDT bis.b #001h,&P1DIR SetupTA mov.w #TASSEL_2+ID_1+MC_2+TAIE,&TACTL ;Seleccionamos SMCLK ; ;como fuente de reloj y se % 2 ;modo ascendente Mainloop bis.w #LPM0+GIE,SR ;CPU OFF e interrupciones nop ; ISR genérica para CCR1 a 4 y overflow ; TA0IV contiene 2, 4, 6, 8 ó 10 (0A). Lo que se hace es añadir su contenido al ; PC. ; si los ponemos de forma consecutiva, siempre sabremos quién ha producido la ; interrupción y saltar a donde toque. ; Los reti también ocupan 2 bytes, por lo que también es correcto ;En este caso, como en caso de desbordamiento el contenido de TA0IV es 10 (0A) ; y es el último, no hace falta poner salto. ;Eso sí, hay que poner los todos los CCR1 a 4, aunque el nuestro solo tenga 3 ; porque los valores son fijos. TA0_ISR add.w &TA0IV,PC reti ; No hay interrupción pendiente (TA0IV = 0) reti ; CCR1 reti ; CCR2 reti ; CCR3 - Este no existe en nuestro MSP430 reti ; CCR4 - Este no existe en nuestro MSP430 TA_over xor.b #001h,&P1OUT ; Desbordamiento, también JMP tratar_over reti ; ; Interrupt Vectors ORG 0FFFEh ; MSP430 RESET Vector DW RESET ; ORG 0FFF0h ; Vector del Timer0_A1 DW TA0_ISR ; END 25
26 25. Escribir un programa para que por la patilla P1.1 se muestre TA.0 (suponiendo que MCLK = 1 MHz) y que la frecuencia obtenida por P1.1 sea de 1KHz. Utilizando como reloj SMCLK Se utiliza la patilla P1.1 como salida de TA.0. No hay llamada a interrupciones, se desconecta la CPU y queda simplemente funcionando el Timer con el reloj. El registro TA0CCR0 deberemos cargarlo con un valor que obtenemos de f sal = f SMCLK /TA0CCRO cargamos el registro de comparación con: TA0CCR0 = f SMCLK / f sal =1000, es decir, como tenemos el tiempo a cero y el tiempo a uno, 1000/2=500, y se empieza la cuenta en 0, TA0CCRO=499 int main(void) WDTCTL = WDTPW + WDTHOLD; BCSCTL1 = CALBC1_1MHZ; DCOCTL = CALDCO_1MHZ; // P1SEL = 0x02; P1DIR = 0x07; TA0CCTL0 = OUTMOD_4; TA0CCR0 = 499; TA0CTL = TASSEL_2 + MC_1; // Paramos el WDT // Ajustamos frecuencia a 1MHz // Configuramos P1.1 como salida del Timer // Y la habilitamos como salida // Registro Captura/Compara del Timer A0 pongo // modo Salida Toggle // Y en registro del control de timer // seleccionamos SMCLK como fuente de reloj // modo ascendente. _BIS_SR(LPM0_bits); // habilitamos el modo 0 de bajo consumo 26
27 26. Escribir un programa en ensamblador para que el bit P1.6 se encienda cuando la señal introducida por A1 sea mayor de 0,5*Vcc, utilizar el convertidor ADC tomando 16 muestras por segundo ;******************************************************************************* ORG 0FC00h #define misp 0x400 RESET mov.w #misp,sp ; inicializa stackpointer mov.w #WDTPW+WDTHOLD,&WDTCTL ; Stop WDT mov.w #ADC10SHT_2+ADC10ON+ADC10IE,&ADC10CTL0 ; 16x, enable int. mov.w #INCH_1, &ADC10CTL1 bis.b #0x02,&ADC10AE0 ; P1.1 entrada de ADC10 bis.b #0x040,&P1DIR ; P1.6 salida ; vuelta bis.w #ENC+ADC10SC,&ADC10CTL0 ; empezar muestreo y conversión bis.w #CPUOFF+GIE,SR ; modo LPM0, int global hab bic.b #0x40,&P1OUT ; P1.6 = 0 cmp.w #01FFh,&ADC10MEM ; ADC10MEM = A1 > 0.5*Vcc jlo vuelta ; otra vez bis.b #0x40,&P1OUT ; P1.6 = 1 jmp vuelta ; otra vez ADC10_ISR; Salir de LPM0 y reti bic.w #CPUOFF,0(SP) ; sale de LPM0 y reti reti ; COMMON INTVEC ; Interrupt Vectors ORG ADC10_VECTOR ; ADC10 Vector DW ADC10_ISR ORG RESET_VECTOR ; POR, ext. Reset DW RESET END 27
28 27. Escribir un programa en C para que el bit P1.6 se encienda cuando la señal introducida por A1 sea mayor de 0,5*Vcc, utilizar el convertidor ADC tomando 16 muestras por segundo. int main(void) WDTCTL = WDTPW + WDTHOLD; // Stop WDT ADC10CTL0 = ADC10SHT_2 + ADC10ON + ADC10IE; // 16x, enable int. ADC10CTL1 = INCH_1; // entrada A1 ADC10AE0 = 0x02; // PA.1 entrada a convertir P1DIR = 0x40; // P1.6 salida for (;;) ADC10CTL0 = ENC + ADC10SC; // inicio de muestro y conversión bis_sr_register(cpuoff + GIE); // modo LPM0 e inter. globales hab. if (ADC10MEM < 0x1FF) P1OUT &= ~0x40; // apagar P1.6 else P1OUT = 0x40; // encender P1.6 // ADC10 interrupt service routine #pragma vector=adc10_vector interrupt void ADC10_ISR(void) bic_sr_register_on_exit(cpuoff); // sacar de LMP0(CPUOFF) 28
29 28. Escribir un programa para que por la patilla P1.1 se muestre TA.0 (suponiendo que MCLK = 1 MHz) y que la frecuencia obtenida por P1.1 sea de 1KHz. Utilizando como reloj ACLK El registro TA0CCR0 deberemos cargarlo con un valor que obtenemos de f sal = f ACLK /TA0CCRO cargamos el registro de comparación con: TA0CCR0 = f ACLK / f sal =32768/1000=32,7, es decir, como tenemos el tiempo a cero y el tiempo a uno, 32,7/2=16,35 y se empieza la cuenta en 0, TA0CCRO=15 int main(void) WDTCTL = WDTPW + WDTHOLD; P1SEL = 0x02; P1DIR = 0x07; TA0CCTL0 = OUTMOD_4; TA0CCR0 = 15; TA0CTL = TASSEL_1 + MC_1; // Paramos el WDT // Configuramos P1.1 como salida del Timer // Y la habilitamos como salida // Registro Captura/Compara del Timer A0 pongo // modo Salida Toggle // Y en registro del control de timer // seleccionamos ACLK como fuente de reloj // modo ascendente. _BIS_SR(LPM3_bits); // habilitamos el modo 3 de bajo consumo 29
30 29. Generar una salida PWM en la patilla P1.2 con una frecuencia de 2KHz y un Duty Cycle del 75% y utilizando el Timer A0 en modo ascendente y salida reset/set, utilizando SMCLK como fuente del reloj El valor de TA0 define el periodo del PWM y el valor en TACCR1 define el duty cycle que viene dado por TA0CCR1/TA0CCR0. Calculamos el valor de TA0CCR0=500, para obtener un duty cycle del 75% tendremos que poner en TA0CCR1=375, es decir, (500*0.75)=375 f SAL = f SMCLK / TA0CCR0 = 2 KHz à TA0CCR0= f SMCLK /f SAL = 10 6 /2000 = 500 à 499 (0 a 499)à 75% de 500 =375 int main(void) WDTCTL = WDTPW + WDTHOLD; BCSCTL1 = CALBC1_1MHZ; DCOCTL = CALDCO_1MHZ; P1SEL = 0x04; P1DIR = 0x04; // Paramos el WDT // f=1mhz // Configuramos P1.2 como salida del Timer // Y la habilitamos como salida TA0CCTL1 = OUTMOD_7; TA0CCR0 = 499; TA0CCR1 = 375; // Registro Captura/Compara 1 del Timer A0 // el modo Salida Reset/Set // TA0CCR0 determina el periodo // TA0CCR1 determina el flanco TA0CTL = TASSEL_2 + MC_1; //modo ascendente y SMCLK fuente del reloj _BIS_SR(LPM0_bits); // habilitamos el modo 0 de bajo consumo 30
31 30. Generar una salida PWM en la patilla P1.2 con una frecuencia de 2KHz y un Duty Cycle del 75% y utilizando el Timer A0 en modo ascendente y salida reset/set, utilizando ACLK como fuente del reloj El valor de TA0 define el periodo del PWM y el valor en TACCR1 define el duty cycle, que viene dado por TA0CCR1/TA0CCR0. Calculamos el valor de TA0CCR0=16, para obtener un duty cycle del 75% tendremos que poner en TA0CCR1=375, es decir, (500*0.75)=12 f SAL = f ACLK / TA0CCR0 = 2 KHz à TA0CCR0= f ACLK /f SAL = 16,3 à 15(0 a 15) à 75% de 16 =12 int main(void) WDTCTL = WDTPW + WDTHOLD; BCSCTL1 = CALBC1_1MHZ; DCOCTL = CALDCO_1MHZ; P1SEL = 0x04; P1DIR = 0x04; // Paramos el WDT // f=1mhz // Configuramos P1.2 como salida del Timer // Y la habilitamos como salida TA0CCTL1 = OUTMOD_7; TA0CCR0 = 15; TA0CCR1 = 12; // Registro Captura/Compara 1 del Timer A0 // el modo Salida Reset/Set // TA0CCR0 determina el periodo // TA0CCR1 determina el flanco TA0CTL = TASSEL_1 + MC_1; //modo ascendente y SMCLK fuente del reloj _BIS_SR(LPM0_bits); // habilitamos el modo 0 de bajo consumo 31
32 31. Realizar un programa para que la UART transmita el abecedario con la siguiente configuración: 9600, 8bits, 1bit de stop, y sin paridad y que se pueda visualizara través del USB en el hyperteminal. unsigned int contador = 97; unsigned int i; void main(void) WDTCTL = WDTPW + WDTHOLD; // Stop WDT BCSCTL1 = CALBC1_1MHZ; // frecuencia 1MHz DCOCTL = CALDCO_1MHZ; P1SEL = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD P1SEL2 = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD UCA0CTL1 = UCSSEL_2; // SMCLK UCA0BR0 = 104; // 1MHz 9600 UCA0BR1 = 0; // 1MHz 9600 UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1 UCA0CTL1 &= ~UCSWRST; // **Inicializa máquina de estado de la USCI IE2 = UCA0RXIE + UCA0TXIE; // habilita las interru`ciones de RX y TX bis_sr_register(lpm0_bits + GIE); // Enter LPM0, interrupts enabled // ISR de TX #pragma vector=usciab0tx_vector interrupt void USCI0TX_ISR(void) for(i=97; i<123; i++) while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer preparado? if (contador <123) UCA0TXBUF = i; // Envío caracter i=97 delay_cycles(1500); //tiempo para transmitir un caracter ~1,5ms else if (contador==123) UCA0TXBUF = 0x0D; // Retorno de carro (13 en decimal) IE2 &= ~UCA0TXIE; //deshabilita la transmisión de caracteres contador=contador+1; // ISR de RX #pragma vector=usciab0rx_vector interrupt void USCI0RX_ISR(void) while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer está preparado? UCA0TXBUF = UCA0RXBUF; // TX -> RXed 32
33 33. Utilizando la patilla P1.2 como salida TA0.1, generar dos frecuencias con un DC=50% y de 1KHz y 1,25KHz, respectivamente, separadas ente sí por un retardo de 0,5s. De esta manera colocando un Altavoz de 8Ω en dicha patillas obtendremos un sonido semejante a una sirena. El reloj debe ser SMCLK. La sirena no sonará hasta que se solicite la interrupción por flanco de bajada mediante P1.3, en dicho momento la alarma se repetirá 20 veces Mientras se está en reposo la CPU debe estar en modo LPM2. 33
34 int PVez=0; int main(void) WDTCTL = WDTPW + WDTHOLD; // Paramos el WDT BCSCTL1 = CALBC1_1MHZ; // f=1mhz DCOCTL = CALDCO_1MHZ; P1SEL = BIT2; // Configuramos P1.2 como salida del Timer P1DIR = BIT2; // Y la habilitamos como salida // CONFIGURACIÓN DE LA INTERRUPCIÓN P1DIR &=~BIT3; // P1.3 entrada P1REN =BIT3; // P1.3 resistencia pull-up HABILITADA P1OUT =BIT3; // P1.3 resistencia pull-up P1IE =BIT3; //Habilitamos las interrupciones, P1IES =BIT3; // FLANCO DE BAJADA P1IFG &=~BIT3; // flag a cero no hay INT pendiente // CONFIGURACIÓN DEL TIMER TA0CCTL1 = OUTMOD_7; TA0CTL = TASSEL_2 + MC_1; // Registro Captura/Compara 1 del Timer A0 // el modo Salida Reset/Set //modo ascendente y SMCLK fuente del reloj // Programa principal bis_sr_register(lpm2_bits + GIE); no_operation(); // Enter LPM2 y habilita INT #pragma vector=port1_vector interrupt void Port_1(void) int t; for (t=0;t<20;t++) //sonará 10s pues cada tono suena 0,5s if (PVez==0) TA0CCR0 = 999; //f1 = fsmclk / TA0CCR0 = 10e6/1000=1KHZ TA0CCR1 = 500; // DC=TA0CCR1/TA0CCR0=(500/1000)%=50% PVez++; delay_cycles(500000); //duración de la frecuencia 1; 0,5s else TA0CCR0 = 799; //f2 = fsmclk / TA0CCR0 = 10e6/800=1,25KHZ TA0CCR1 = 400; // DC=TA0CCR1/TA0CCR0=(400/800)%=50% PVez=0; delay_cycles(500000); //duración de la frecuencia 2; 0,5s P1IFG &= ~0x08; // P1.3 IFG BORRADO, permite nueva interrupción 34
35 34. Este problema reúne los conceptos de emisión- recepción serie entre dos microcontroladores //****************************************************************************** // MSP430G2553 USCI_A0, UART 9600 Full-Duplex, 32kHz ACLK // // Descripción: USCI_A0 se comunica de forma contínua en modo full-duplex // con otro microcontrolador. Está en modo LPM3, con actividad únicamente // cuando se transmiten o se reciben datos. // La ISR de RX transmite un carácter a 9600,8,N,1 en aproximadamente 1ms // La ISR de TX indica a la USCI_A0 que ha recibido un carácter. // ACLK = BRCLK = LFXT1 = 32768Hz, MCLK = SMCLK = DCO ~1MHz // Baud rate 32768Hz = 32768Hz/9600 = 3.41 // // MSP430G2xx3 MSP430G2xx3 // // XIN - / \ XIN - // 32kHz 32kHz // XOUT - -- RST XOUT - // / \ // RST --- // // // UCA0TXD/P > P1.1 // 9600 // UCA0RXD/P1.1 < P1.2 // // // GND GND // // // //****************************************************************************** #include <io430.h> #include "LCD4bits.c" int main(void) WDTCTL = WDTPW + WDTHOLD; // Stop watchdog LCD_INI (Dos_Lineas_5x8, Derecha_NoDesplaza); LCD_Control (CurOFF_BliOFF); LCD_Control (ClearDisplay); delay_cycles(500000); P1OUT = 0x00; // P1.0/6 setup for LED output P1DIR = BIT0 + BIT6; P1SEL = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD P1SEL2 = BIT1 + BIT2; UCA0CTL1 = UCSSEL_1; // CLK = ACLK UCA0BR0 = 0x03; // 32kHz/9600 = 3.41 UCA0BR1 = 0x00; UCA0MCTL = UCBRS1 + UCBRS0; // Modulation UCBRSx = 3 UCA0CTL1 &= ~UCSWRST; // **Inicializa USCI máquina estados** 35
36 IE2 = UCA0RXIE + UCA0TXIE; // habilita interrupción USCI_A0 TX/RX LCD_FilaColumna(0,1); LCD_Cadena ("ESPERANDO..."); delay_cycles( ); bis_sr_register(lpm3_bits + GIE); // Modo LPM3 e interrupciones globales /* En el microcontrolador que sea transmisor hay que descomentar esta rutina USCI A0/B0 Transmisión ISR y comentar la siguiente USCI A0/B0 Recepción ISR */ // USCI A0/B0 Transmisión ISR //#pragma vector=usciab0tx_vector // interrupt void USCI0TX_ISR(void) // // // unsigned char TxByteT=0; // TxByteT = 'S'; // LCD_Control (ClearDisplay); // delay_cycles( ); // LCD_FilaColumna(0,1); // LCD_Cadena ("TRANSMIT:"); // LCD_FilaColumna(0,10); // LCD_Caracter(TxByteT); // delay_cycles(500000); // // UCA0TXBUF = TxByteT; // Lee, y transmite // /* En el receptor cargamos con la rutina USCI A0/B0 Transmisión ISR comentada y la rutina USCI A0/B0 Recepción ISR descomentada */ // USCI A0/B0 Recepción ISR #pragma vector=usciab0rx_vector interrupt void USCI0RX_ISR(void) unsigned char TxByteR=0; TxByteR=UCA0RXBUF; LCD_Control (ClearDisplay); delay_cycles(500000); LCD_FilaColumna(1,1); LCD_Cadena ("RECIBIDO:"); LCD_FilaColumna(1,10); delay_cycles(500000); LCD_Caracter(TxByteR); delay_cycles( ); 36
Figura 1. Diagrama de bloques del Timer_A
TIMER_A El Timer_A es un timer/contador de 16 bit con tres registros de captura/comparación. El Timer_A soporta múltiples capturas/comparaciones y temporización de intervalos de tiempo; también genera
Más detallesPráctica No. 4 del Curso "Microcontroladores" Uso del Convertidor ADC
Objetivos Práctica No. 4 del Curso "Microcontroladores" Uso del Convertidor ADC Caracterizar el convertidor ADC del Microcontrolador MSP430 y con base en él realizar algunas aplicaciones para la medición
Más detallesUNIVERSIDAD TECNICA FEDERICO SANTA MARIA DEPARTAMENTO DE ELECTRONICA Diseño con Microcontroladores
WATCHDOG TIMER El watchdog timer es un temporizador de 16 bit que puede ser usado como watchdog o por intervalos de tiempo. Al iniciarse un programa, el watchdog timer está activo y configurado por defecto
Más detallesSEMINARIO DE COMPUTADORES I DISE~NO CON MICROCONTROLADORES MSP430: Manejo de motor servo
SEMINARIO DE COMPUTADORES I DISE~NO CON MICROCONTROLADORES MSP430: Manejo de motor servo Nombres: Daniel Arancibia Carocca Alex Garay Herrera Juan Carlos Jarur Mu~noz Bruno Mundaca Moraga Rodrigo Vizcarra
Más detallesRelación de Problemas I
Relación de Problemas I 352) $1'5e6 52/'È1 $5$1'$ 1. Realizar el cálculo del tiempo que transcurre durante la ejecución del bloque de instrucciones sombreado, en función del contenido de los registros
Más detallesDiseño Basado en Microcontroladores. Programa Detallado
Diseño Basado en Microcontroladores. Programa Detallado Tema 5. Temporizadores e Interrupciones. (4 horas + 8 horas de laboratorio) 5.1.Temporizadores A y B. Modos de funcionamiento. 5.2. Temporizador
Más detallesPráctica No. 3 del Curso "Microcontroladores" Contador de Objetos
Objetivos Práctica No. 3 del Curso "Microcontroladores" Contador de Objetos Hacer un sistema con base en el MSP430 que cuente los objetos que pasan con base en un detector infrarrojo, cada que pasen 10
Más detalles26/09/2012. Microcontroladores PROCESADORES DE TEXAS INSTRUMENTS ORGANIZACIÓN INTERNA DE LOS MICROCONTROLADO RES FAMILIA DE MICROCONTROLADORES MSP430
PROCESADORES DE TEXAS INSTRUMENTS ORGANIZACIÓN INTERNA DE LOS MICROCONTROLADO RES 1 Microcontroladores F. Hugo Ramírez Leyva Octubre 2012 2 MICRCONTROLADOR (MCU) MSP430 FAMILIA DE MICROCONTROLADORES MSP430
Más detallesPIC 18F45XX EL TIMER 0
PIC 18F45XX EL TIMER 0 1. Hardware asociado 2. Características Se puede configurar como temporizador o contador de 8/16 bits. Se puede leer o escribir en él a través del registro TMR0. Dispone de un preescaler
Más detallesFigura 2. Formato de un dato serie síncrono.
ELECTRÓNICA DIGITAL II 1 COMUNICACIÓN SERIE EN EL 8051 En la comunicación serie los datos se transfieren bit por bit. Una interfaz en el microcontrolador los transfiere el dato en paralelo del CPU a serie
Más detallesProgramación en C para Sistemas Embebidos
SASE 2012 Programación en C para Sistemas Embebidos (con ejemplos basados en MSP430) Mg. Guillermo Friedrich UTN-FRBB Tópicos destacados - Generalidades sobre la arquitectura MSP430 - Paso de parámetros
Más detallesProgramación de Microcontroladores
Programación de Microcontroladores Simulación en Crocodile Technology Práctica Nº 1 Encender un led cuando arranque el microcontrolador. Práctica Nº 2 Encender un led tres veces consecutivas. 1 Práctica
Más detallesTUTORIAL PRIMERA PARTE: GENERACIÓN DE UN RETARDO CON TIMER.
1 TUTORIAL OBJETIVOS Familiarizarse con el TMR0 como contador de pulsos internos y generador de retardos. Conocer el método del polling para verificar banderas de dispositivos. Crear y manipular variables
Más detallesConceptos de Arquitectura de Computadoras Curso 2015
PRACTICA 1 Assembly, Instrucciones, Programas, Subrutinas y Simulador MSX88 Objetivos: que el alumno Domine las instrucciones básicas del lenguaje assembly del MSX88. Utilice los diferentes modos de direccionamiento.
Más detallesControl remoto del EDUKIT08 vía PC...
COMENTARIO TECNICO Mundo EDUKIT08 Por: Ing. Roberto Simone Ingeniero de aplicaciones Freescale robertosimone@arnet.com.ar Ing. Daniel Di Lella D.F.A.E www.edudevices.com.ar dilella@arnet.com.ar (MDO_EDUKIT_012)
Más detallesBucles: o Bucles infinitos o Bucles finitos o Bucles anidados Medir tiempos con MPLAB Ejemplos y ejercicios
SISTEMAS ELECTRÓNICOS Y AUTOMÁTICOS PRACTICAS DE MICROCONTROLADORES PIC PRÁCTICA 3: Bucles Bucles: o Bucles infinitos o Bucles finitos o Bucles anidados Medir tiempos con MPLAB Ejemplos y ejercicios -
Más detallesBLOQUE 3. Enrique Mandado Pérez María José Moure Rodríguez. Microcontroladores
SISTEMAS ELECTRÓNICOS DIGITALES BLOQUE 3 MICROCONTROLADORES (PARTE 4) DESARROLLO DE SISTEMAS ELECTRÓNICOS DIGITALES Interrupciones,Temporizadores/Contadores y Puerto serie Enrique Mandado Pérez María José
Más detallesProgramar y depurar código para el MSP430 en Linux
Programar y depurar código para el MSP430 en Linux El presente documento describe los pasos necesarios para instalar un ensamblador, monitor, compilador y depurador para la linea de microcontroladores
Más detallesLa familia PIC18 USB posee 4 timers: Timer0, Timer1, Timer2 y Timer3, cada uno de los cuales tiene sus características únicas.
59 5 TIMERS Todos los microcontroladores poseen circuitos temporizadores (timers), los cuales son útiles para: Programar tareas con alta precisión. Contar pulsos externos. Medir intervalos de tiempo. etc.
Más detallesTemporizadores y contadores en tiempo real: El módulo Timer0 del PIC.
Temporizadores y contadores en tiempo real: El módulo Timer0 del PIC. 1. Introducción... 1 2. Funcionamiento del Timer0... 1 2.1. Estructura general del Timer0...2 2.2. Entrada de reloj del modulo Timer0...2
Más detallesTemporizadores y contadores en tiempo real: El módulo Timer0 y el prescaler del PIC
Temporizadores y contadores en tiempo real: El módulo Timer0 y el aler del PIC 1. Introducción...1 2. Estructura del Timer0...1 3. Funcionamiento del Timer0...2 3.1. Entrada de reloj del modulo Timer0...
Más detallesPRACTICA #1. Aprender a programar una interrupción software empleando C y/o Ensamblador.
PRACTICA #1 Aprender a programar una interrupción software empleando C y/o Ensamblador. Aprender a manipular dispositivos externos (8253, 8255) desde C y/o ensamblador. PROCEDIMIENTO: Vamos a programar
Más detallesPIC16C5X (GAMA BAJA) Solo en dispositivos de 28 pins. Encapsulado y patillaje:
PIC6C5X (GAMA BAJA) Oscilador RESET SLEEP WatchDog Timer (WDT) Protección de código e IDs Periféricos: Timer/Contador de 8bits (T) con prescaler compartido para WDT o TMR Hasta 3 puertos I/O (RA,RB,RC)
Más detallesGuía resumida para utilizar el microcontrolador CY7C68013
Guía resumida para utilizar el microcontrolador CY7C68013 Camilo Quintáns Graña Miguel Ángel Domínguez Gómez Vigo, 2011 Índice 1. DESCRIPCIÓN DEL HARDWARE... 3 1.1. Introducción... 3 1.2. Recursos de memoria...
Más detallesTEMPORIZADORES Y CONTADORES (T/C) (Timers/Counters)
TEMPORIZADORES Y CONTADORES (T/C) (Timers/Counters) Objetivos? Conocer y comprender la utilidad de los temporizadores y contadores.? Comprender su estructura y lógica de funcionamiento.? Sintetizar programas
Más detallesRegistros SFR vistos hasta ahora: Microcontroladores PIC
Registros SFR vistos hasta ahora: Microcontroladores PIC Microcontroladores PIC: Timer Características del Timer TMR0: Cumple básicamente la función de contador de eventos (o divisor de frecuencia). El
Más detallesSISTEMAS ELECTRÓNICOS AVANZADOS. ING. TÉC. INDUSTRIAL ELECTRÓNICO
INTERRUPCIONES Interrumpen la ejecución de un programa y pasan a la rutina de servicio del evento que provoca la interrupción. El vector de interrupción se encuentra en la dirección 04H de la memoria de
Más detallesGuía rápida para gestionar el puerto paralelo del PC
Guía rápida para gestionar el puerto paralelo del PC Descarga desde: http://eii.unex.es/profesores/jisuarez/descargas/ip/guia_rapida_pp.pdf José Ignacio Suárez Marcelo Universidad de Extremadura Escuela
Más detalles17 Con el chorro de agua pequeño, la cubeta se llena en 10 minutos
17 Con el chorro de agua pequeño, la cubeta se llena en 10 minutos Cuál será el valor de precarga necesario para que este sistema nos indique que ha transcurrido un tiempo de 6 minutos? Seria depositar
Más detallesCiclos de máquina. Otro ejemplo: decremento de un registro par (donde rp = HL, DE, BC, SP) DCX rp
Ciclos de máquina Otro ejemplo: decremento de un registro par (donde rp = HL, DE, BC, SP) DCX rp Acceso a periféricos: función del pin IO/M Este μp cuenta con dos instrucciones específicas para I/O, llamadas
Más detallesSISTEMAS BASADOS EN MICROPROCESADORES
SISTEMAS BASADOS EN MICROPROCESADORES Grado en Ingeniería Informática Escuela Politécnica Superior UAM COLECCIÓN DE PROBLEMAS DE LOS TEMAS 5.5 A 7.2 P1. Escribir una rutina de ensamblador que se quede
Más detallesÁngel Castillo Jordán TFC EPSC 78
OBJETIVO: substituir el pulsador del Proyecto_3 por un potenciómetro. Su función será la misma que el pulsador, es decir, aumentar o disminuir la frecuencia de salida de nuestra señal senoidal almacenada
Más detallesPráctica 3: El teclado del PC
Práctica 3: El teclado del PC Gustavo Romero López Arquitectura y Tecnología de Computadores 7 de junio de 2016 Gustavo Romero López Práctica 3: El teclado del PC 1 / 11 Objetivos Objetivos: Fuentes: Recordar
Más detallesTema 3 SUBRUTINAS. Estructura de Computadores OCW_2015 Nekane Azkona Estefanía
Tema 3 SUBRUTINAS ÍNDICE Definición e instrucciones básicas Soporte para el tratamiento de subrutinas (ejecución de la subrutina y gestión del bloque de activación) Interrupciones vs llamadas a procedimiento
Más detalles7. CONVERTIDORES DIGITAL A ANALÓGICO (DAC) Y ANALÓGICO A DIGITAL (ADC).
7. CONVERTIDORES DIGITAL A ANALÓGICO (DAC) Y ANALÓGICO A DIGITAL (ADC). ÍNDICE 7.1. Introducción. Interfaces entre el mundo digital y el analógico. 7.2. Convertidores DAC. Características de funcionamiento.
Más detallesArquitectura de Computadores II 8086 Parte II
8086 Parte II Facultad de Ingeniería Universidad de la República Instituto de Computación Contenido Funciones recursivas Manejadores de dispositivos Rutinas recursivas(1/10) Introducción Salvar contexto.
Más detallesRECURSOS FUNDAMENTALES
RECURSOS FUNDAMENTALES Los recursos que se considerarán son : Temporizadores Puertos de E/S La Palabra de Configuración EEPROM de datos 1 TEMPORIZADORES Una labor habitual en los programas de control suele
Más detallesPIC16F882/883/884/886/ Funcionamiento de Timer1 6 EL MODULO TMR1 CON PUERTA DE CONTROL Selección de Fuente de reloj
6.1. Funcionamiento de Timer1 6 EL MODULO TMR1 CON PUERTA DE CONTROL El módulo TMR1 es un temporizador/contador de 16 bits con las siguientes características: Temporizador/Contador de 16 bits (TMR1L:TMR1H)
Más detallesMICROCONTROLADORES PIC
MICROCONTROLADORES PIC LOS TIMER DE LOS 16F87x TEMA EL TIMER 1 CCFF D.P.E. MÓDULO DE PROYECTOS 1 Diagrama de Bloques del TIMER1 CCFF D.P.E. MÓDULO DE PROYECTOS 2 INTRODUCCIÓN El módulo TIMER1 es un temporizador/contador
Más detallesNT 3 PROGRAMACION ON-LINE DE TODA LA FAMILIA APPCON
NT 3 PROGRAMACION ON-LINE DE TODA LA FAMILIA APPCON Introducción El objetivo de esta nota técnica es que el usuario tenga la capacidad de configurar los parámetros de los módulos de toda la familia APPCON
Más detallesSISTEMAS ELECTRÓNICOS DIGITALES
SISTEMAS ELECTRÓNICOS DIGITALES PRÁCTICA 6 SISTEMA DE ENCRIPTACIÓN 1. Objetivos - Estudio del funcionamiento de memorias RAM y CAM. - Estudio de métodos de encriptación y compresión de datos. 2. Enunciado
Más detallesEjemplo del uso de las subrutinas
Ejemplo del uso de las subrutinas Enunciado del problema: Diseñar un contador BCD que cuente de 0 a 59 para simular un timer de 60 segundos y que el conteo de dos dígitos BCD, sea desplegado en los displays
Más detallesElectrónica Digital. Actividad Dirigida. Implementación de un Cronómetro Digital
Electrónica Digital Actividad Dirigida Implementación de un Cronómetro Digital Trabajo a realizar La actividad consiste en la implementación de un cronómetro digital con capacidad de cuenta de minutos
Más detallesEL MICROCONTROLADOR ARDUINO
EL MICROCONTROLADOR ARDUINO Arduino es una plataforma libre de computación de bajo coste basada en una placa de entrada-salida y en un entorno de desarrollo IDE que implementa el lenguaje Processing/WiringHardware.
Más detallesINSTRUCCIONES PROGRAMADOR ATR-901. Introducción...2
INSTRUCCIONES PROGRAMADOR ATR-901 Índice Introducción...2 1. Funciones de los displays y teclas...2 1.1 Indicadores numéricos (displays)...3 1.2 Significado de los indicadores luminosos (leds)...3 1.3
Más detallesPIC16F88. Características
Osciladores PIC16F88. Características Osciladores a cristal: LP, XT y HS hasta 20Mhz Oscilador externo hasta 20Mhz Oscilador interno: 31Khz 8Mhz Periféricos Módulo PWM/CCP CCP (captura/comparación) ->
Más detallesCOMUNIDAD DE FORMADORES DEL EMPRENDIMIENTO TECNOLÓGICO FEMPRETEC
COMUNIDAD DE FORMADORES DEL EMPRENDIMIENTO TECNOLÓGICO FEMPRETEC Propuesta para el desarrollo de semilleros de investigación en Automatización y control. wcastillo90@hotmail.com, hugo.alex30@gmail.com,
Más detallesDependiendo del dispositivo usado, se tienen hasta 5 puertos de entrada/salida disponibles: PORTA PORTB PORTC PORTD PORTE
25 3 ENTRADA / SALIDA Dependiendo del dispositivo usado, se tienen hasta 5 puertos de entrada/salida disponibles: PORTA PORTB PORTC PORTD PORTE Cada uno de estos puertos es de 8 bits, sin embargo no todos
Más detallesEl módulo LCD Ejemplos de funcionamiento
SISTEMAS ELECTRÓNICOS Y AUTOMÁTICOS PRACTICAS DE MICROCONTROLADORES PIC PRÁCTICA 7: El módulo LCD El módulo LCD Ejemplos de funcionamiento - 1 - 1. Objetivos: - Conocer el funcionamiento y programación
Más detallesEntradas y Salidas. Componentes básicos de una PC
Entradas y Salidas a) Con periféricos de mediana velocidad conviene trabajar por FLAG (control por programa). b) Con periféricos rápidos utilizando el esquema de la línea READY. c) Con periféricos de Actuación
Más detallesExamen 23 de Febrero de 2007
Instrucciones Examen 23 de Febrero de 2007 Indique su nombre completo y número de cédula en cada hoja. Numere todas las hojas e indique la cantidad total de hojas que entrega en la primera. Escriba las
Más detallesProgramación en C para plataforma CADmega128, basada en microcontrolador Atmel megaavr
Laboratorio Equipos y Sistemas de Control Digital Guía Laboratorio Nº 1 Programación en C para plataforma CADmega128, basada en microcontrolador Atmel megaavr En esta experiencia se verá en forma aplicada
Más detallesAR 9 T. Tutorial 9: Display LCD
9 T Tutorial 9: Display LCD En este tutorial, se va a mostrar cómo conectar una pantalla LCD 1602A a una placa Arduino UNO para mostrar texto por pantalla. Material 1 Arduino uno 1 cable AB 1 Protoboard
Más detallesLector de códigos de barras con microcontrolador Motorola HC11
Lector de códigos de barras con microcontrolador Motorola HC11 Alumno: Pinat Gastón José Legajo: 10.813 Introducción: Los códigos de barras son ampliamente utilizados por los fabricantes para identificar
Más detallesIntroducción al microcontrolador MSP430
FAMILIA MSP430 Los Procesadores de Señales Mixtas 1 (Mixed Signal Processor) MSP 430 de Texas Instruments son una familia de microcontroladores con capacidad añadida para operaciones de procesamiento analógico
Más detallesSISTEMAS BASADOS EN MICROPROCESADOR 2º Grado Ingeniería Informática (EPS UAM) EXAMEN FINAL EXTRAORDINARIO JULIO 2013 ENUNCIADO DEL PROBLEMA
SISTEMAS BASADOS EN MICROPROCESADOR 2º Grado Ingeniería Informática (EPS UAM) EXAMEN FINAL EXTRAORDINARIO JULIO 2013 ENUNCIADO DEL PROBLEMA IMPLEMENTACIÓN DE UN DRIVER DOS INTERFAZ CON UN SISTEMA DE RADIO
Más detallesConexionado del módulo LCD para ser controlado por conexión serie: Instrucciones para el control del LCD(comandos de control):
Conexionado del módulo LCD para ser controlado por conexión serie: El PICAXE-18 puede ser el entrenador de sistemas PICAXE-18x. La conexión de salida del PICAXE-18 (output7) tiene que ser directa sin pasar
Más detallesLaboratorio 3 Capa de Transporte (TCP)
Redes de Datos Laboratorio - Informe Laboratorio 3 Capa de Transporte (TCP) Fecha: Estudiante: Estudiante: Estudiante: Puesto de trabajo: Firma: Firma: Firma: Procedimiento. Se recomienda salvar las capturas
Más detallesLa comunicación asíncrona de los sistemas periféricos con la CPU, en ambos sentidos, se puede establecer de dos maneras fundamentales:
CAPITULO 8 Interrupciones 8.1. INTRODUCCION La comunicación asíncrona de los sistemas periféricos con la CPU, en ambos sentidos, se puede establecer de dos maneras fundamentales: a) Consultas (polling):
Más detallesGuía de práctica. Dispositivo
Guía de práctica Que queremos hacer? Vamos a hacer el Hello World del mundo de la electrónica que no es más que prender y apagar un LED a intervalos regulares. PROYECTO LAPEGÜE 1 = Prende Dispositivo 0
Más detallesEnsamblador. Introducción. Dpto. Física y Arquitectura de Computadores. Universidad Miguel Hernandez
Dpto. Física y Arquitectura de Computadores Universidad Miguel Hernandez Es el lenguaje de más bajo nivel que admite una máquina. El ensamblador hace que el código binario(máquina sea transparente al usuario)
Más detallesTEMA 7: Ficheros. TEMA 7: Ficheros. 7.1.-Concepto de fichero
TEMA 7: Ficheros 7.1.-Concepto de fichero Todas las estructuras de datos que hemos visto hasta ahora utilizan memoria principal. Esto tiene dos limitaciones importantes: 1. Los datos desaparecen cuando
Más detallesSistemas Elec. Digitales. Instrumentación del laboratorio. Pag. 1 1. INSTRUMENTACIÓN DEL LABORATORIO.
Sistemas Elec. Digitales. Instrumentación del laboratorio. Pag. 1 1. INSTRUMENTACIÓN DEL LABORATORIO. Sistemas Elec. Digitales. Instrumentación del laboratorio. Pag. 2 1.1. Fuente de alimentación CPS250
Más detallesProgramación en ensamblador y en alto nivel (C)
Programación en ensamblador y en alto nivel (C) Taller de Microcontroladores año 2012 Optativa de grado y Curso de Posgrado El ISAdel AVR Preliminares 32 registros de 8 bits: R0 a R31 Los registros pueden
Más detallesGuía rápida de utilización
1. Interfaz del usuario La interfaz del usuario de la consola KaptiaKlever consta de dos partes: - Un panel de interacción, en el cual el usuario podrá encender y apagar el dispositivo, así como conectar
Más detallesTEMA III - Interrupciones en Sistemas en Tiempo Real
1 TEMA III - Interrupciones en Sistemas en Tiempo Real 3.1. Introducción Definición. Objetivo. Mecanismo básico. Ejemplo. Muestreo o polling. 3.2. Interrupciones Simples Componentes. Mecanismo. Ejemplo.
Más detallesDISPLAY LCD MICROPROCESADORES
Módulo LCD HD4478 de de Hitachi Módulo LCD HD4478 de de Hitachi E R / W D-D7 D-D7 VDD Vo Vss Controlador Controlador del del LCD LCD HD4478 HD4478 Manejador Manejador Del Del LCD LCD Manejador Manejador
Más detallesPRÁCTICA 4 LOS BITS DE CONFIGURACIÓN DEL PIC16F628
Los Bits de Configuración del PIC16F628 44 PRÁCTICA 4 LOS BITS DE CONFIGURACIÓN DEL PIC16F628 OBJETIVOS Identificar cada uno de los bits de configuración que rigen el funcionamiento del PIC16F628. Verificar
Más detallesÁngel Castillo Jordán TFC EPSC 25
OBJETIVO: Usar la pantalla LCD USER MODULE LCD con sus APIS de dibujo para realizar un mini juego con dos barras horizontales que crecen. Una barra controlada por PSoC (velocidad constante) y la otra barra
Más detallesAUTOMATIZACIÓN - CURSO: 2010-2011- Práctica 4: Sistema de Monitorización de tiempo mediante Arduino
AUTOMATIZACIÓN - CURSO: 2010-2011- Juan Antonio Corrales Ramón Carlos Alberto Jara Bravo Fernando Torres Medina Grupo de Innovación Educativa en Automática Departamento de Física, Ingeniería de Sistemas
Más detallesCONSTRUCCIÓN DE TIMER PARA VUELO CIRCULAR CON NANO ARDUINO
CONSTRUCCIÓN DE TIMER PARA VUELO CIRCULAR CON NANO ARDUINO Para aquellos que se inician en el vuelo circular eléctrico, pueden realizar su propio timer basándose en una placa nano arduino totalmente configurable.
Más detalles1. Proponer un circuito que tenga el puerto b como salida conectando 8 leds, realizando un programa que me encienda los bits 0, 1, 3, 5, 7.
1. Proponer un circuito que tenga el puerto b como salida conectando 8 leds, realizando un programa que me encienda los bits 0, 1, 3, 5, 7. a. Diagrama de flujo b. Circuito C1 4 MHZ C2 R2 10k 16 15 4 R1
Más detallesLUCES SECUENCIALES REVERSIBLES DE 6 LED. Simula que tienes un scanner o una alarma en tu vehículo
LUCES SECUENCIALES REVERSIBLES DE 6 LED Simula que tienes un scanner o una alarma en tu vehículo Tabla de Contenido DEFINICIÓN FUNCIONAMIENTO LISTA DE PARTES ENSAMBLE DEFINICIÓN 4017 El 4017b es un circuito
Más detallesSISTEMAS BASADOS EN MICROPROCESADORES
SISTEMAS BASADOS EN MICROPROCESADORES Grado en Ingeniería Informática ENUNCIADO PROBLEMA 1 A continuación se incluye el código de una aplicación formada por un programa principal escrito en lenguaje C,
Más detalles6 MODULACIÓN DE ANCHO DE PULSO (PWM)
69 6 MODULACIÓN DE ANCHO DE PULSO (PWM) En el PWM, se produce un pulso rectangular con un ciclo de trabajo determinado (comúnmente producido por un Timer), este ciclo de trabajo puede variar de 0 a 100%.
Más detallesInstrucciones de Control de Flujo y Usos de la Pila
1 Instrucciones de Control de Flujo y Usos de la Pila Objetivos Generales Facultad: Estudios Tecnologicos. Escuela: Electrónica Asignatura: Microprocesadores Analizar la forma en que se ejecutan algunas
Más detallesEspecificaciones técnicas de los prototipos:
Especificaciones técnicas de los prototipos: Sensor de Temperatura y Humedad Relativa Sensor de Humedad de la Hoja CARACTERÍSTICAS SENSOR HUMEDAD DE LA HOJA El Sensor de Humedad de la hoja está diseñado
Más detallesTema 14. Interrupciones. Las. C. F. G.S. D.P.E. Módulo de Proyectos 1
Tema 14 Las Interrupciones C. F. G.S. D.P.E. Módulo de Proyectos 1 Los PIC de la familia 16F8X poseen 4 fuentes de interrupción: Interrupción externa a través del pin RB0/INT Interrupción por overflow
Más detallesINDICE Programa Entrada Unidad de control Unidad aritmética y lógica (ALU)
INDICE Capitulo 1. Qué es un computador? 1.1. Introducción 1 1.2. El computador como dispositivo electrónico 2 1.3. Cómo se procesa la información? 3 1.4.Diagrama de bloques de un computador 1.4.1. Información
Más detallesCurso sobre Microcontroladores Familia HC9S08 de Freescale
Curso sobre Microcontroladores Familia HC9S08 de Freescale Por Ing. Daniel Di Lella EduDevices www.edudevices.com.ar e-mail: info@edudevices.com.ar Responsable Area Educación ELKO / ARROW www.elkonet.com
Más detallesPROYECTO DE ELECTRÓNICA
PROYECTO DE ELECTRÓNICA Sistema de Alarma Raúl Lapaz de Juan Francisco Javier López Alcarria 1 ÍNDICE - Objetivo:... 3 - Justificación:... 3 - Plan de trabajo:... 3 A) Montaje del circuito en protoboards:...
Más detallesFuncionamiento de la Pila (o stack)
Funcionamiento de la Pila (o stack) Todo μp cuenta con una memoria de almacenamiento temporal denominada Pila Es una estructura de datos de tipo secuencial (LIFO) Existen dos operaciones básicas posibles:
Más detalles1-Introducción. KIT ARM- Ténicas Digitales II - Ing. Ruben M. Lozano /9
1-Introducción -Este apunte pretende ser una guía para aquellos alumnos que se inician en la programación de microntroladores con arquitectura ARM, utilizando como plataforma de hardware el kit de desarrollo
Más detallesEnsamblador. Interrupciones. Dentro de una computadora existen dos clases de interrupciones:
Ensamblador Interrupciones Definición: Una interrupción es el rompimiento en la secuencia de un programa para ejecutar un programa especial llamando una rutina de servicio cuya característica principal
Más detallesUART. Diseño de Sistemas con FPGA 1er cuatrimestre 2013 Patricia Borensztejn
UART Diseño de Sistemas con FPGA 1er cuatrimestre 2013 Patricia Borensztejn UART Universal Asynchronous receiver and transmitter: dispositivo (controlador ) que envía datos paralelos sobre una línea serie.
Más detallesManual de Usuario TMU-V1
@-sa.com www.-sa.com Manual de Usuario, S.A. Pag. 1 de 10 @-sa.com www.-sa.com Manual de Usuario Indice: 1.0.- Descripción: 2.0.- Características: 2.1.- Componentes básicos 3.0.- Descripción de funcionamiento
Más detallesCAN-101, HT6P20x2 Encoder para aplicaciones remotas de control
Nota de Aplicación: CAN-101 Título: HT6P20x2 Encoder para aplicaciones remotas de control Autor: Ing Iván C Sierra Revisiones Fecha Comentarios 0 28/01/13 En esta oportunidad le presentamos un nuevo encoder,
Más detallesLaboratorio de Sistemas Embebidos Conceptos generales (2009)
Laboratorio de Sistemas Embebidos Conceptos generales (2009) Índice Introducción a los PIC Conceptos generales sobre el dspic30f Reloj del sistema Entrada/salida con puertos paralelos Timers Interrupciones
Más detalles[CURSO BÁSICO DE PIC TABLAS]
2009 GRUPO ESTUDIANTIL INVENTRONICA Joel Oswaldo Campos Pérez [CURSO BÁSICO DE PIC ] En esta sección explicaremos que son las tablas, para que se usan y como se hacen. Se describe un ejercicio completo
Más detallesINSTITUTO POLITÉCNICO NACIONAL
INSTITUTO POLITÉCNICO NACIONAL ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA ENROLLADORA DE BOLSAS BIODEGRADABLES QUE PARA OBTENER EL TÍTULO DE: INGENIERIO EN COMUNICACIONES Y ELECTRÓNICA PRESENTAN:
Más detallesEncender un LED utilizando un pulsador (Ref libro 1 pg 82 pero como 1.2.2 y pg 132 como 1.2.3)
Libro de Actividades de Robótica Educativa 1.2.3. Encender un LED utilizando un pulsador (Ref libro 1 pg 82 pero como 1.2.2 y pg 132 como 1.2.3) La tercera actividad, es nuestra última actividad con el
Más detallesLaboratorio 8: Interrupción por Lectura de Entradas y por Desbordamiento del TMR0.
Laboratorio 8: Interrupción por Lectura de Entradas y por Desbordamiento del TMR0. 8.1 Objetivo. Familiarizarse con la utilización de la interrupción por cambio en las Entradas digitales mediante la implementación
Más detalles1.10 PUERTOS GENERALES DE ENTRADA Y SALIDA
Notas Técnicas de Uso y Aplicación 1.10 PUERTOS GENERALES DE ENTRADA Y SALIDA USO DE PUERTOS PARA GENERAR SEÑALES Y DETECTAR SEÑALES DIGITALES Preparado por: Rangel Alvarado Estudiante Graduando de Lic.
Más detallesV.- V.-El El manejo de de las las Interrupciones
Las Las V.- V.-El El manejo de de las las Conceptos Conceptos BásicosB Básicos Modos Modos de de Manejo Manejo Ejemplos Ejemplos de de aplicación aplicación Las Las El manejo de las en el 8051 Las interrupciones
Más detallesControl Digital en PC con MS-DOS
Control Digital en PC con MS-DOS Abel Alberto Cuadrado Vega 19 de abril de 2006 1. Introducción Un PC puede ser utilizado para realizar un sistema de control digital. Para ello necesita lo siguiente: tarjeta
Más detallesPIC MICRO ESTUDIO Reloj en tiempo real RTCU2 Clave: 719 www.electronicaestudio.com
PIC MICRO ESTUDIO Reloj en tiempo real RTCU2 Clave: 719 www.electronicaestudio.com Guía de Operación Reloj en tiempo real Modulo: RTCU2iempo real Clave: 719 El modulo 719 Reloj en tiempo real- utiliza
Más detallesEntrada/Salida. Polling e Interrupciones. Verano de 2011. Mariano Moscato. Organización del Computador 1
Entrada/Salida Polling e Interrupciones Mariano Moscato Organización del Computador 1 Verano de 2011 El GuidoBot Robot docente Basado en tecnología ORGA1 tiene un procesador y una memoria ORGA1 Sus dispositivos
Más detallesMANUAL DE PRODUCTO QUAD. Sensor Analógico Digital ZN1IO-4IAD. Versión Programa: 5.0 Edición Manual: a
MANUAL DE PRODUCTO QUAD Sensor Analógico Digital ZN1IO-4IAD Versión Programa: 5.0 Edición Manual: a ÍNDICE Actualizaciones del documento... 3 1. Introducción... 4 1.1. QUAD... 4 1.2. Instalación... 5 2.
Más detallesAuricular Calisto II de Plantronics con Adaptador Bluetooth USB Guía del usuario FEBRERO 2013
Auricular Calisto II de Plantronics con Adaptador Bluetooth USB Guía del usuario FEBRERO 2013 56-K61S-23016 Contenido Contenido del paquete... 1 Características del producto... 2 Encendido del auricular
Más detallesAPUNTE DEL 8155 ELECTRÓNICA DIGITAL III
APUNTE DEL 8155 ELECTRÓNICA DIGITAL III Revisión 1.1 Marzo, 2011 Interfaz a periférico 8155 Descripción general El chip 8155 es un dispositivo introducido por Intel en 1977. Contiene memoria RAM (SRAM)
Más detalles