UNIVERSIDAD TECNOLÓGICA DE LA MIXTECA MICROCONTROLADORES
REPORTE DE PRACTICAS 1ER PARCIAL
Ingeniería en Computación 902
Alumno: Cervantes Martínez Julio Cesar
Fecha de entrega: 31 de octubre de 2016
INTRODUCCIÓN Un controlador es un dispositivo de procesamiento que recibe información por medio de sensores, desde una entrada proveniente de un cambio de voltaje o un sensor avanzado, como el infrarrojo. Durante el pasar de los años la forma física de ellos ha disminuido debido al crecimiento exponencial de la electrónica, pasando de transistores a pequeños circuitos integrados, llegando así, a centrar todas los procesos de un controlador en un solo chip, un controlador, y más específicamente, un microcontrolador, cuenta con todas las características para considerarse una computadora, pero generalmente será un dispositivo dedicado para un propósito general. En este curso programaremos con el microcontrolador ATMega328p, usando como interfaz la integración de dicho chip en el dispositivo Arduino UNO, programando en c, ensamblador y el propio lenguaje de arduino. En este reporte presento las 3 primeras prácticas del curso de microcontroladores, las cuales son: El parpadeo de un led, un decodificador de binario a 7 segmentos y un ALU de 3 bits. OBJETIVO GENERAL Con el desarrollo de las siguientes prácticas nos familiarizaremos con el uso de Arduino y la programación de microcontroladores, analizaremos con que herramientas contamos para desarrollar aplicaciones de hardware aprovechando las ventajas que nos presenta. Las diferentes practicas suponen las bases de la programación de los microcontroladores, pues vamos desde un pequeño encendido de un led, hasta operaciones a nivel de bits. También nos familiarizaremos con el entorno de desarrollo arduino y atmel studio. PRÁCTICA #1
Parpadeo de un led
El primer circuito a implementar es un el parpadeo de un led, en la figura 1 podemos apreciar cómo se desarrollará físicamente el circuito, a simple vista no puede detectarse que parte desarrollará el intercambio de encendido a apagado.
Figura 1. Diagrama del circuito (parpadeo de un led).
Gracias al uso del microcontrolador podemos programar un retar do de tiempo para cambiar la salida del pin. En el diagrama de la figura 2 puede observarse el comportamiento lógico que se espera de nuestro circuito y que programaremos en el microcontrolador.
Figura 2. Diagrama de flujo del comportamiento lógico de nuestro circuito.
Practica #1 – Programación en Ensamblador .include
SER R16 OUT DDRB, R16 LDI R16, 0xFF LDI R17, 0x08 OUT SPL, R16 OUT SPH, R17 LOOP: LDI R16,0x01 OUT PORTB,R16 RCALL Espera_500ms CLR R16 OUT PORTB, R16 RCALL Espera_500ms RJMP LOOP Espera_500ms: LDI
R18,2
et3:LDI R17,250 et2:LDI R16,250 et1:NOP
;Itera 250 veces emplea 4 us por iteración DEC R17 ;es decir, un milisegundo BRNE et1
DEC R17 BRNE et2;250 milisegundos
DEC R13 BRNE et3;500 milisegundos, 0.5 segundos
Practica #1 – Programación en C #include #define F_CPU 16000000UL #include "util/delay.h" int main(void){ DDRB = 0xFF;//Puerto B como salida while (1) { PINB = 0x01; //PINB0 como envia un alto para encender el LED _delay_ms(500); PINB = 0x00;//Despues de 0.5 segundo apagamos el LED _delay_ms(500); } }
Practica #1 – Programación en arduino void setup() { // initializa pin 8 como salida pinMode(8, OUTPUT); }
void loop() { digitalWrite(8, HIGH); // Enciende el LED delay(500);
// Espera medio segundo
digitalWrite(8, LOW); delay(500); }
// Apaga el LED
// Espera un segundo
Practica #1 – Resultado
Figura 3. Circuito físico, podemos observar la configuración física del circuito para el parpadeo de un LED.
Figura 4.Resultado de la simulación
PRÁCTICA #2
Decodificador de binario a 7 segmentos
El segundo circuito a implementar es un decodificador de binario a 7 segmentos, en la figura 2 podemos apreciar cómo se desarrollará físicamente el circuito, donde las entradas serán procesadas por el microcontrolador, encargándose de la lógica de salida.
Figura 5. Diagrama del circuito (Decodificador de binario a 7 segmentos). La entrada en los puertos PD0 a PD3 representara un número binario, siendo 15 (b1111) el número más grande a representar, la siguiente lista representa los pines encendidos y apagados de g hasta a, y su valor hexadecimal representará la salida de los puertos en serie.
Figura 6. Tabla de valores de las salidas del display
Figura 7. Diagrama de flujo del comportamiento lógico de nuestro circuito.
Practica #2 – Programación en Ensamblador .include
LOOP:
s1:
LDI R16, 0x00 OUT DDRD, R16 LDI R16, 0xFF OUT PORTD, R16 OUT DDRB, R16 IN R20, PIND ANDI R20, 0x0F LDI R30, LOW(tabla << 1); Z apunta al inicio de la tabla LDI R31, HIGH(tabla << 1) ADD R30, R20 BRCC s1 INC R31 LPM R0, Z OUT PORTD, R0 RJMP LOOP
tabla: .DB 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07 .DB 0x7F, 0x67, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71
Practica #2 – Programación en C (anodo común) #include #define F_CPU 16000000UL
const int tabla[] PROGMEM = {-0x40,-0x07,-0x5C,-0x50,-0x67,-0x6E,-0x7E,-0x08,-0x80,-0x68,-0x78,-0x7D,-0x3A,-0x5F,-0x7A,0x72};
int main(void){ char bcd; DDRB = 0x00; DDRD = 0xFF; char hab; while(1){ bcd = PINB & 0x0F; hab = PINB & 0x10;
if(hab == 0x10){ PORTD = pgm_read_byte(&(tabla[bcd])); } } }
Practica #2 – Programación en arduino (anodo común) const int numeros[16][7] = { //ABCDEFG 1,1,1,1,1,1,0, // 0 0,1,1,0,0,0,0, // 1 1,1,0,1,1,0,1, // 2 1,1,1,1,0,0,1, // 3 0,1,1,0,0,1,1, // 4 1,0,1,1,0,1,1, // 5 0,0,1,1,1,1,1, // 6 1,1,1,0,0,0,0, // 7 1,1,1,1,1,1,1, // 8 1,1,1,0,0,1,1, // 9 1,1,1,0,1,1,1, // A 0,0,1,1,1,1,1, // b
1,0,0,1,1,1,0, // c 0,1,1,1,1,0,1, // d 1,0,0,1,1,1,1, // E 1,0,0,0,1,1,1 // F }; //
b,..,..,B, ha
const int PinesEntrada[5]= {9,10,11,12,13}; //
A,B,C,D,E,F,G
const int PinesSalida[7] = { 2,3,4,5,6,7,8}; int numero = 0; boolean input;
void setup() { // put your setup code here, to run once:
for(int i=0;i<5;i++){ pinMode(PinesEntrada[i],INPUT); } for(int i=0; i < 7; i++){ pinMode(PinesSalida[i], OUTPUT); } }
void loop() { numero=8*digitalRead(PinesEntrada[0]) + 4*digitalRead(PinesEntrada[1]) + 2*digitalRead(PinesEntrada[2]) + 1*digitalRead(PinesEntrada[3]); if(digitalRead(PinesEntrada[4])){ for(int i=0;i<7;i++){ input = numeros[numero][i]; digitalWrite(PinesSalida[i],!input); } } }
Practica #2 – Resultado
Figura 8. Circuito físico, podemos observar la configuración física del circuito para el parpadeo de un LED.
Figura 9.- PuertoB con salidas en alto,
Práctica 3 Diseño de una ALU de 3 bits. Para el diseño de la ALU de 3 bits fueron necesarios.Se usaron 3 líneas de selección correspondientes a las operaciones: suma, resta y multiplicación el resultado se visualizaba en las salidas que estaban conectadas a cada uno de los led’s.
Figura 10. Diagrama del circuito. Práctica #3 – Programación en Ensamblador .include
LOOP:
caso_valido:
LDI R16, 0x00 OUT DDRB, R16 OUT DDRC, R16 LDI R16 , 0xFF OUT PORTB, R16 OUT PORTC, R16 OUT DDRD, R16 IN R20, PINB ANDI R20, 0x0F IN R21, PINB ANDI R21, 0xF0 SWAP R21 IN R22, PINC ANDI R22, 0x07 CPI R22, 5 BRGE caso_valido LDI R30, LOW(tabla) LDI R31, HIGH(tabla) ADD R30, R22 BRNE no_carry
INC R31 no_carry:
IJMP
no_valido:
LDI R22, 5 RJMP caso_valido
tabla: RJMP RJMP RJMP RJMP RJMP RJMP caso_0:
caso_1:
caso_2:
caso_3:
caso_4:
default: fin_case:
caso_0 caso_1 caso_2 caso_3 caso_4 default
MOV R23, R20 ADD R23,R21 RJMP fin_case MOV R23,R20 SUB R23,R21 RJMP fin_case MUL R21, R20 MOV R23,R0 RJMP fin_case MOV R23, R20 AND R23, R21 RJMP fin_case MOV R23, R20 OR R23, R21 RJMP fin_case CLR R23 OUT PORTD, R23 RJMP LOOP
Práctica #3 – Programación en C #include #define F_CPU 16000000UL char A,B,op;
int main(void){ DDRD = 0x00; // Taking portD as input port DDRB = 0x00; DDRC = 0xFF; //taking porta as output port //char hab; PIND = 0x00;
//DDRD = 0b11111111; //taking portd as output while(1){ A = (PIND & 0x0F); B = (PIND & 0xF0)>>4;
op = PINB & 0x07; if(op == 0){ PORTC = A + B; } if(op == 1){ //PORTC = 0x00; PORTC = A - B; } if(op == 2){ //PORTC = 0x00; PORTC = A * B; } if(op == 3){ //PORTC = 0x00; PORTC = A & B; } if(op == 4){ //PORTC = 0x00; PORTC = A | B; }else{ PORTC = 0x00; } //if(hab == 0x10){ //PORTD = pgm_read_byte(&(tabla[bcd]));
//} } } Práctica #3 – Programación en Arduino int a0,a1,a2,b0,b1,b2,s0,s1,s2,operacion,c2,c1,c0,r3,r2,r1,r0,numa,numb; int num2; int LEDP[] = {A5, A4, A3, A2, A1, A0}; void setup() { pinMode(2, INPUT); pinMode(3, INPUT); pinMode(4, INPUT); pinMode(5, INPUT); pinMode(6, INPUT); pinMode(7, INPUT);
pinMode(8, INPUT); pinMode(9, INPUT); pinMode(10, INPUT);
pinMode(A0, OUTPUT); pinMode(A1, OUTPUT); pinMode(A2, OUTPUT); pinMode(A3, OUTPUT); pinMode(A4, OUTPUT); pinMode(A5, OUTPUT); }
void numeros (int num){
num2 = int(num); for (int i = 0; i < 6; i++) { if (num2 % 2 == 1) { digitalWrite(LEDP[i], HIGH); } else { digitalWrite(LEDP[i], LOW); } num2 = num2 / 2; } }
void loop() { a2 = digitalRead(10); a1 = digitalRead(9); a0 = digitalRead(8);
b2 = digitalRead(7); b1 = digitalRead(6); b0 = digitalRead(5);
s0 = digitalRead(2); s1 = digitalRead(3); s2 = digitalRead(4);
operacion = 4*s2 + 2*s1 +1*s0;
switch(operacion){ case 0: //suma
numa = 4*a2 + 2*a1 +1*a0; numb = 4*b2 + 2*b1 +1*b0; numeros(numa + numb); break; case 1: //resta numa = 4*a2 + 2*a1 +1*a0; numb = 4*b2 + 2*b1 +1*b0; numeros(numa - numb); break; case 2: //mult numa = 4*a2 + 2*a1 +1*a0; numb = 4*b2 + 2*b1 +1*b0; numeros(numa * numb); break; case 3: //and display(0,0,0,a2 and b2, a1 and b1, a0 and b0); break; case 4: //or display(0,0,0,a2 or b2, a1 or b1, a0 or b0); break; default: display(0,0,0,0,0,0); break; } }
void display (int r5, int r4, int r3, int r2, int r1, int r0) {
digitalWrite (A5,r0); digitalWrite (A4,r1); digitalWrite (A3,r2); digitalWrite (A2,r3); digitalWrite (A1,r4); digitalWrite (A0,r5); }
Figura 11.Resultado de la simulación. PRACTICA#3 RESULTADO
Figura 12. Circuito físico del alu de 3 bits
