Universidad Autónoma de Baja California

Facultad de Ingeniería
Ingeniería en Mecatrónica

Microcontroladores
EXAMENES Y FIRMAS DEL 3ER PARCIAL

Docente
Mtra. Valenzuela Delgado Mónica

Alumnos
Torres Sandoval Diana Karina
González Díaz Jesús Alonso

Grupo
694
Desarrollo
EXAMEN 3, EJERCICIO 1 (NOMBRE CON MATRIZ DE LEDS)
Mostrar en una matriz de leds de 8x8 un nombre o al menos las primeras 4
letras del mismo utilizando el fenómeno de persistencia visual.
Se eligió para este ejercicio se utilizó el nombre de “Alonso” realizando únicamente las
primeras 4 letras hasta “Alon”. Para ello se elaboró una tabla para ordenar tanto las
columnas como renglones de la matriz de leds que encenderán y los respectivos bits
de su puerto a utilizar. Es importante destacar que las columnas encienden con 1 y los
renglones con 0, es por ello que en el caso de los renglones cuando en el código para
el orden de los bits de dicho puerto para utilizado para los renglones el 0 es
encendido.
Es importante mencionar que de acuerdo
al tipo de matriz de leds que se tenga los
renglones encienden con 1´s o con 0´s (lo
Para la letra A contrario para las columnas).

Para la letra L
Para la letra O

Para la letra N

Por último, se realiza un compilado de cada letra de acuerdo a su encendido

de renglones por columna.

Letra C1 C2 C3 C4 C5 C6 C7 C8
A 0xFF 0x01 0xF6 0xF6 0xF6 0x01 0xFF 0XFF
L 0xFF 0x80 0xBF 0xBF 0xBF 0xBF 0xFF 0xFF
O 0xFF 0x00 0x7E 0x7E 0x7E 0x00 0xFF 0xFF
N 0x00 0XF9 0XF3 0xE7 0xCF 0xF9 0x00 0xFF
Diagrama del circuito

Código documentado

#include <avr/io.h>
#include <util/delay.h>
int contador=0;
int i,j;
int numero[4][8]= {//PARA LA A
{0xFF,0x01,0xF6,0xF6,0xF6,0x01,0xFF,0XFF},
//PARA LA L
{0xFF,0x80,0xBF,0xBF,0xBF,0xBF,0xFF,0xFF},
//PARA LA O
{0xFF,0x00,0x7E,0x7E,0x7E,0x00,0xFF,0xFF},
//PARA LA N
{0x00,0xF9,0xF3,0xE7,0xCF,0x9F,0x00,0xFF}};
int main (void)
{
DDRD=0xFF;
DDRB=0xFF;
PORTB=0x80; //Inicializar el puerto B para el barrido de las
columnas
while(1)
{
for(j=0;j<100;j++) //Ciclo de numero de barridos
{
for(i=0;i<8;i++) //Ciclo de barrido de columnas
{
PORTD=numero[contador][i]; //Se le asigna al PORTD
el código respecto a la columna
_delay_ms(.2);
PORTB=PORTB>>1; //Siguiente columna
 }
PORTB=0x80; //Se inicializa a la primera columna
}
contador++; //Incrementar en 1 el contador
if (contador==4) //Si el contador llega a la ultima letra
contador=0; //que vuelva a empezar en la primera letra
}
}

EXAMEN 3 EJERCICIO 2 (Control de Motor a pasos con ADC e

interrupciones)
Diagrama del circuito

Código documentado

#include <avr/io.h>
#include <avr/interrupt.h> //Libreria necesaria para manejar las
interrupciones
#include <util/delay.h>
int temp,filtro,ValorADCH,girar;
void retardo();
int main (void){

DDRB=0x0F; //Se configura a los primeros 4 bits (B0, B1, B2 Y B3 de salida

al motor de pasos)
temp=0x01;
girar=0x01;// se le puede dar el valor de 0 para que no gire a ningun lado al
principio que se enciende el motor
 cli(); //Desactivamos las interrupciones para en caso de que alguna
esté a 1 la reconfiguremos
MCUCR=0x0F; //Habilitamos los primeros 4 bits del registro para indicar qué
tipo de pulso provocará la interrupción (pulso ascendente)
GIFR=0xC0; //Configuramos las banderas de cada interrupción de este registro
(limpiar las banderas)
GICR=0xC0;// se indica cuales interrupciones se utilizarán

sei(); //Set enable interruptions para activar las interrupciones de

nuevo
ADCSRA=0x80; //Configurar el registro ADCSRA
ADMUX=0x20; //Configurar el registro ADMUX

while(1)
{
//PARTE DEL CÓDIGO PARA EL GIRO DEL MOTOR
if((PINB&0x10)==0x10)// condición para que el motor encienda leyendo lo
que hay en PB4 (filtra los datos de salida del puerto B del motor)
{
if(girar==0x01) // para el giro a la izquierda
{
PORTB=temp;
retardo();
temp=temp<<1;
filtro=temp&0x0F;
if(filtro==0)
temp=0x01;
}
else // Para el giro a la derecha
{
PORTB=temp;
retardo();
temp=temp>>1;
filtro=temp&0x0F;
if(filtro==0)
temp=0x08;
}
}
PORTB=0; //si no está leyendo un 1 o nada en PB4 (ON OFF) el motor no se
enciende
} //hasta aquí termina el ciclo infinito para que el motor siempre esté
girando hacia algún lado o para que no se encienda
}

//PARA LAS INTERRUPCIONES ESTAS PUEDEN IR COLOCADAS FUERA DEL WHILE PERO DENTRO DE
LA FUNCIÓN PRINCIPAL VOID COMO EN EL EJEMPLO DE LA PAG 40(interrupciones externas)
ISR(INT0_vect){ //Interrupción externa INT0
girar=0x01; // En vez de utilizar el puerto y filtrarlo
en la parte principal del codigo solamente al utilizar la interrupcion este valor
irá directamente (girar) a compararse con las condiciones de giro izquierda o
derecha
}

ISR(INT1_vect){// Interrupción externa INT1

girar=0x00; // lo mismo ocurre para la otra interrupcion
 }

//PARTE DEL CÓDIGO PARA LA CONVERSIÓN DE ANALÓGICO

DIGITAL PARA LOS RETARDOS O VARIAR LA VELOCIDAD DEL MOTOR
//FUNCION DE RETARDO PARA LOS BITS DE LA VELOCIDAD PERO MEDIANTE EL CONVERTIDOR
ANALÓGICO DIGITAL
void retardo(){ // se crea porque no podemos mandar una variable al delay
int i;
ADCSRA|=_BV(ADSC); //Activar el bit ADSC del registro ADCSRA
inicio de conversion
ValorADCH=(ADCH*7)/255; ////Ajustar la recta para que vaya de 0
a 7
for(i=0;i<=ValorADCH;i++)
_delay_ms(2);
}

EXAMEN 3 EJERCICIO 3 (TECLADO MATRICIAL CON LCD)

Diagrama del circuito
Código documentado
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
#define Enable_On PORTC|=_BV(PC2) //Definiciones
#define Enable_Off PORTC&=~_BV(PC2)
#define RS_On PORTC|=_BV(PC0)
#define RS_Off PORTC&=~_BV(PC0)
#define RW_On PORTC|=_BV(PC1)
#define RW_Off PORTC&=~_BV(PC1)
#define Data PORTD
#define DelayL _delay_ms(5)
int i=0;
void pulso();//definimos todas las funciones a utilizar al inicio
void prendeLCD();
void ClearLCD();
void LCD_init ();
void movercursor(int pos);
void PORT_init();
void caracter(char c);
void backspace();
void comando(int valor); //declaracion de la matriz de numeros, y letras de acuerdo
a las funciones del teclado
char
teclado[4][4][4]={{{'1','2','3',0x04},{'4','5','6',32},{'7','8','9',0xC0},{'*','0','
#',0x01}},
{{'A','D','G',0x04},{'J','M','P',32},{'S','V','Y',0xC0},{'+',',','#',0x01}},
{{'B','E','H',0x04},{'K','N','Q',32},{'T','W','Z',0xC0},{'-',';','#', 0x01}},
{{'C','F','I',0x04},{'L','O','R',32},{'U','X','*',0xC0},{'/','.','#', 0x01}}};
int main(void)
{
uint8_t tiempo=30;
uint8_t c; //columnas
uint8_t f; //filas
char car;//inicio, LCD
PORT_init();
LCD_init();
prendeLCD();
ClearLCD();
DDRB = 0xF0;
PORTB=0xFF;
DDRC=7;
PORTC=0;

while(1)
{
for(c=4;c<=7;c++){ //columnas de PD4 a PD6 salidas
PORTB&=~(1<<c); //para hacer PD4 a PD7 a 0
for(f=0;f<4;f++){ //ve si alguna fila esta a 0
if((PINB&(1<<f))==0)
{
int selector=(PINC&0x18)>>3;
car=teclado[selector][f][c-4];
if(car==0x04)
backspace();// ejecuta el escribir un espacio pero
en sentido inverso como si estuviese borrando caracter
else
if(car==0xC0||car==0x01)
 comando(car);
else
caracter(car);
}
while((PINB&(1<<f))==0);
_delay_ms(tiempo);
car=0;
}
PORTB|=(1<<c);
}

}
}

void comando(int valor)

{ RS_Off;
Data=valor;
pulso();
}
void backspace()
{
comando(0x04);//Entry Mode Set: decrementar dirección de cursor
caracter(' ');//Envía un espacio al LCD
comando(0x06);//Entry Mode Set: incrementar dirección de cursor
caracter(' ');
comando(0x04);
caracter(' ');
comando(0x06);
}

void backspace2()
{comando(0x10);
caracter(' ');
comando(0x10);
}
void PORT_init (void)
{ //Función para inicializar puertos
DDRC=0x07;
DDRD=0xFF;
PORTC=0x00;
PORTD=0x00;
}
void LCD_init (void)
{ //Función para inicializar el LCD
RS_Off;
Data=0x38;
pulso();
Data=0x38;
pulso();
Data=0x38;
pulso();
}
void pulso()
{
Enable_On;
DelayL;
Enable_Off;
DelayL;
}
void ClearLCD(void) // limpia el LCD poniendo DATA en 0x01 de acuerdo a la
configuración que se envía a las entradas del LCD para configurarse
{
RS_Off;
Data=0x01;
pulso();
}
void prendeLCD ()// se enciende el LCD
{
RS_Off;
Data=0x0F;
pulso();
RS_On;
}
void movercursor(int pos) //se recorre el cursor al escribir un caracter o numero,
es decir al pulsar el teclado y escribir algo
{
RS_Off;
Data=pos;
pulso();
RS_On;

}
void caracter(char c) //escribe un caracter al pulso
{
RS_On;
Data=c;
pulso();
}

Resultados

Circuito o ejercicio 1
Al realizar el circuito del ADC funcionó de la misma forma que un motor de pasos
normal, sin embargo, la diferencia es que ahora la velocidad de giro del motor fue
determinada por la resistencia o la variación de esta mediante el potenciómetro entre
los pines de configuración para el mismo ADC, de esta forma se incrementaba el ancho
de pulso que le llegaba al motor en vez de un delay o retardo como en prácticas
anteriores. Además, el sentido de giro se controló mediante 2 botones al pulsarlos 1
vez programándose como interrupciones.
Circuito o ejercicio 2
En el circuito de la matriz de leds al igual que los anteriores fue más visual, pues el
efecto que se consiguió fue mostrar letra por letra (4 letras en total) un nombre o
palabra a elegir, efecto conseguido por un corto retardo (para controlar el efecto) y un
retardo variable (mediante un ciclo) para determinar cuánto duró el microcontrolador
mostrando mediante la matriz de leds una letra. Cuando la matriz de leds mostró la
última letra al volver a cambiar, empezó nuevamente en la primera letra del nombre
de tal forma que volvió a mostrarse sucesivamente cada letra una y otra vez.

Circuito o ejercicio 3
En el circuito del teclado matricial con LCD la función principal fue entre alternar los
caracteres y números dadas las entradas mediante el teclado y la programación por
medio de la interpretación de pulsos para escribirlos, esto alternando entre un switch
el escribir caracteres y números. No obstante, se realizan las funciones de borrado y
movimiento de cursor con funciones que modifican o envían valores de acuerdo al
registro de configuración del LCD.

CONCLUSIONES
Para cada uno de los ejercicios exceptuando el motor a pasos con interrupciones se
utilizó el manejo de tablas de datos en C por lo que demuestra lo útil que pueden
llegar a ser al momento de intentar mostrar diversos valores de datos y
comportamientos de manera visual mediante un microcontrolador. Por otro lado, el
ADC incluido en el microcontrolador es útil para dada una señal analógica por medio
del divisor de voltaje con el potenciómetro (como se utilizó) convertir esta señal a un
valor lógico o digital pudiendo a su vez variar el ancho de pulso de una salida para la
cual queremos controlar.
Para la matriz de leds se realizan arreglos de vectores que puedan mostrar en estas
diferentes letras que se almacenan en estos vectores.
Para el motor a pasos con interrupciones ADC solamente se utiliza la configuración del
ancho de pulso que se puede utilizar con un microcontrolador variando el retardo de
los pulsos de acuerdo al valor de la señal de voltaje o voltaje de referencia para el ADC
en el pin 21.
Para el teclado matricial con LCD la principal característica es realizar funciones que
mediante la lectura de ciertos valores como lo son el teclado, pueda cmabiarse el
comportamiento del microcontrolador y a la vez llamar a esas funciones configurando
el LCD por medio de los pines o la hoja de datos de este los valores que debe de tener
para interactuar de alguna manera como el cambio de renglón, borrado de un
carácter, etc. Esto resulta útil pues puede diseñarse una interfaz para interpretar de
manera binaria estos valores de funciones en vez de utilizar solamente caracteres para
enviar al LCD mediante el microcontrolador. Este comportamiento es similar a los
teclados utilizados en los bancos o cajeros, de tal manera que se ingresan también
valores y no solamente caracteres que posteriormente son interpretados por otro
circuito y finalmente realizan la función de retirar dinero, depositar una cierta cantidad
de dinero o dar algún pago.
Firmas de los ejercicios de los exámenes