Informe SD

Facultad de Ciencias e Ingeniera
Seccin Electricidad y Electrnica
Tarea Acadmica - Sistemas Digitales (IEE256)
Proyecto: DADO
Integrantes: Nota
Karla Lucia Honorio Heredia
Eduardo Bryan Prada Licla
Asesor: Luis Raymi
Horario: 0526
Observacin: _________________________________________________
_________________________________________________
30 de junio del 2017

INDICE
I. DESCRIPCION DEL PROYECTO .. 3
II. METODOLOGA DE DESARROLLO . 4
III. DESCRIPCION DEL HARDWARE Y SOFTWARE . 5
Hardware:
3.1 Diagrama de bloques 5
3.2 Diagrama esquemtico. 5
3.3 Explicacin del circuito. 6
3.4 Lista de componentes y precio... 6
Software:
3.5 Diagrama de flujo del programa principal. .. 7
3.6 Diagramas de flujo de las funciones relevantes 7
3.7 Descripcin de las variables utilizadas. 8
3.8 Explicacin del algoritmo.. 8
3.9 Documentacin de las funciones. 9
IV. RESULTADOS 11
V. MANUAL DE USUARIO .. 11
VI. OBSERVACIONES 11
VII. CONCLUSIONES . 12
VIII. SUGERENCIAS 12
IX. BIBLIOGRAFA . 13
ANEXOS ... 14
2
I. DESCRIPCIN DEL PROYECTO
El proyecto consiste en un juego basado en un dado. Su funcionamiento se debe dar usando 6 leds
RGB, un acelermetro, un buzzer y un microcontrolador (TM4C123GH6PM). Para lograr la transmisin
de datos entre el acelermetro y el microcontrolador se us la comunicacin i2c. Adems, para
determinar la orientacin del dado usamos una funcin que nos deber devolver un valor entre 1 y 6.
Por otro lado, el control de los LEDs RGB se pudo conseguir mediante la implementacin de una
funcin para determinar el color y la cantidad de parpadeos. Igualmente, se us SYSTICK y una
funcin de retardo en milisegundos basado en este ltimo, para controlar el tiempo de duracin de
encendido de los leds. Con todo lo anterior, se emple la lgica de juego la cual permite la interaccin
de dos jugadores, y ganar el que, despus de un nmero definido de tiros, se acerque ms al dos o
doce, con posibilidad de empate. En este caso, cada jugador tiene dos tiros. Al inicio del juego el
dado entre en un modo demo , el cual consta de tres parpadeos de los leds RGB, luego espera a que
el jugador uno realice su primer tiro. Al caer el dado, se podr conocer el puntaje obtenido pues el
led de la cara superior mostrar el valor obtenido mediante parpadeos, luego esperar el segundo
tiro del jugador y de la misma manera para el jugador nmero dos. Al final, el dado mostrar el color
del jugador ganador, en caso de empate se prendera ambos colores.
3
II. METODOLOGA DE DESARROLLO
Para poder completar el proyecto, era necesario cumplir dos objetivos: lectura de datos de
acelermetro y lgica de leds. Dicho trabajo fue dividido de manera que un integrante se encargue de
la implementacin del acelermetro y el otro desarrollara el manejo de los leds y el buzzer. Ahora
bien, se trat de cumplir el cronograma enviado en el primer avance, pero surgieron una serie de
inconveniente como son problemas con el acelermetro, no se lograba enviar los datos al Tiva, los
cuales no permitieron que se alcanzaran los objetivos en las fechas indicadas.
Con respecto a la asignacin de actividades tenemos lo siguiente. Primero la programacin de los
mdulos para determinar orientacin del dado fue realizada por la alumna Karla Honorio. Segundo, el
control de manejo de los leds RGB durante el juego fue conseguido por el alumno Bryan Prada.
Tercero, en el caso del modo DEMO, este fue dividido de manera que cada alumno una parte de este
(configuracin del buzzer y respuesta de los leds ). Por un lado, la configuracin del buzzer fue
designada al alumno Bryan Prada, sin embargo, al presentar este problemas para dicha configuracin.
Esta parte termin siendo desarrollada por ambos alumnos. Por otro lado, la lgica del comportamiento
de leds fue obtenida por la alumna Karla Honorio. Sobre este ltimo aspecto, hay que resaltar que para
la lgica del juego se desarrollaron mltiples funciones como las de parpadeo, posicin, ganador, etc.
Estas funciones fueron desarrolladas en conjunto por ambos alumnos durante la semana 14.
Finalmente, la construccin del dado fue durante la semana 15, dicha actividad fue realizada por el
grupo. Con respecto a la realizacin del informe, los captulos fueron completados por los alumnos de
la siguiente manera. La alumna Karla Honorio desarroll los captulos II, III (3.3-3.9), IV, VI; mientras,
el alumno Bryan Prada se encarg de la elaboracin de los captulos I, III (3.1-3.2), V, VII y VIII.
4
III.- DESCRIPCIN DEL HARDWARE Y SOFTWARE
3.1.- Diagrama de bloques
3.2.- Diagrama esquemtico, con todos sus componentes etiquetados y con valores
5
3.3.- Explicacin del circuito.
Los puertos PA2, PA4, PA6, PD0, PD2, PE2 pertenecen al jugador 1 y los puertos PA3, PA5, PA7,
PD1, PD3, PE3 pertenecen al jugador 2. Adems, representan los valores del 1 al 6. Dichos jugadores
tienen asignados el color azul y rojo respectivamente.
Ahora bien, los ctodos de los leds son conectados a los puertos segn el color y posicin que se
desee que tengan. Por otro lado, los nodos son conectados al VCC del tiva. En el caso del buzzer,
su terminal positivo se encuentra conectado al PC4, mientras que el negativo al GND del Tiva.
Finalmente, la conexin entre el acelermetro (MPU-6050) y el Tiva se da de la siguiente manera. Se
encuentran conectados tanto sus VCC como sus GND de ambos, SCL con PB2( SCL(0) del Tiva ) y
SDA con PB3 (SDA(0) del Tiva). Esta conexin le permite al acelermetro enviar y recibir la informacin
necesaria para el correcto funcionamiento del programa.
3.4.- Lista de componentes y precio.
CANTIDAD Precio unitario(s/.) Precio(s/.)
Acelermetro MPU-6050 1 18.00 18.00
Leds RGB 12 1.00 12.00
Cables Macho-Hembra 1 paquete 6.00 6.00
Cables Macho-Macho 1 paquete 6.00 6.00
Protoboard 1 15.00 15.00
Tiva LaunchPad 1 83.00 83.00
Trupan (1.20mx0.7m) 1 15.00 15.00
Pegamento 1 5.00 5.00
6
Software:
3.5.- Diagrama de flujo del programa principal.
3.6.- Diagramas de flujo de las funciones relevantes (por su complejidad o tiempo invertido en ella
los considere importantes) y de la funcin de interrupcin, si utilizaron interrupciones.
7
3.7.- Descripcin de las variables utilizadas
MAIN
e,f.- variables usadas para comparar el estado del dado(se movi o no)
J1,J2.- Guardan el puntaje de las jugadas
Ganador
a.- indica la posicin del dado
b,c,d,e .-ayudan a saber si el puntaje obtenido es ms cercano al 2 o al 12
Juego
a,b .- Guardan los valores obtenidos en ambas tiradas
ValoresCara
Inicio
modo Demo
b.- indica el nmero de veces que se repite el parpadeo
espera
POSICIN
ax, ay,az.- Guardan los valores ledos por el acelermetro
i.- contador
acX, acY, acZ.-valores que adoptan ax,ay y az despus de ser convertidos .
. .para poder ser utilizados en el programa.
Pos.- posicin del dado. La funcin devuelve dicho valor
convertG
r.- Compara el valor para poder devolver 0,1,9 segn el intervalo
en el que pertenece
PARPADEOxxLED (para cualquiera de las 6 funciones de parpadeo)

e,k variables que sirven como contadores
3.8.- Explicacin del algoritmo utilizado.
Lgica de funcionamiento:
Al posicionar el dado este debe entrar en un modo Demo y luego esperar a que sea lanzado. El jugador
1 tiene dos tiros, al finalizar su turno el dado debe entrar en modo de espera hasta que el jugador 2
realice su tiro, al acabar el turno se debe mostrar el color ganador en las caras laterales
Descripcin.
Utilizar un sensor acelermetro, esto nos permite la posicin del dado. Asignar todas las posiciones
posibles del acelermetro un nmero que le identifique (1-6). Esto nos permitir determinar el nmero
de cara en que se encuentra el dado. Para determinar el color que se debe encender el led se debe
8
saber el turno del jugador. Si es J1, entonces debe ser de color azul y si es J2 debe ser rojo. El led que
se debe encender se conoce mediante los datos entregados por el acelermetro despus de ser
tratados. El acelermetro entrega datos de 8 bits. En un mdulo son tratados de manera que se
obtengan solo tres nmeros (0,1,9) que nos permitirn saber de manera ms sencilla la posicin del
dado. Para el juego de luces los leds fueron conectados a VCC y un puerto del tiva(esta conexin se
da porque son leds con lgica negativa) ya configurado en el programa. Cuando la el puerto conectado
est en 0 el led se encender y cuando este en 1 se apaga. El estado del puerto depender de la
posicin del dado.
3.9.- Documentacin de las funciones:
genera_PWM
Funcin que nos permite generar una onda PWM para lograr hacer sonar el . .
. buzzer
Entrada:freq_pwm,DC
sin salida
Funciones que invoca: Ninguna
retardo_ms
Funcin que genera un retardo
Entrada: demora_ms
sin salida
PARPADEOxxLED (para cualquiera de las 6 funciones de parpadeo)

Calcula cuntas veces debe parpadear el led
Entrada: TurnoJugador, cara
Sin salida
parpadeo
Funcin que nos permite mostrar la cantidad de parpadeos
Entrada: cara,TurnoJugador
Sin salida
Funciones que invoca: PARPADEOxxLED
convertG
Trata los valores obtenidos por el acelermetro
Entrada: valor entregado por el acelermetro
Salida: valores 0,1,9. Se utilizarn en las funciones de posicin
posicion
Calcula la posicin del dado
Sin entradas
Salida: El valor de la cara superior del dado
Funciones que invoca: lee_I2C
9
espera
Funcin que espera a que el dado se mueva,luego espera a que se quede . . .
quieto
Sin entrada
Sin salida
Funciones que invoca: lee_I2C, retardo_ms
modoDemo
Bienvenida del juego
Sin entrada
Sin salida
Funciones que invoca:posicion, genera_PWM, retardo_ms.
inicio
Modo de espera. Se queda un led encendido hasta que se lance
Entrada: turnoJugador
Sin salida
Funciones que invoca:posicion
ValoresCara
Entrega el valor de la cara superior del dado.
Sin entrada
Salida: El valor de la cara superior
Funciones: lee_I2C, retardo_ms, posicion
Juego
Nos entrega el puntaje obtenido en los dos tiros por cada jugador
Entrada: turnoJugador
Salida: puntaje total
Funciones que invoca: espera, ValoresCara, parpadeo, retardo_ms
Ganador
Esta funcin nos permite saber qu jugador gan la ronda
Entrada: puntaje total de cada jugador
sin salida
Funciones que invoca: posicion
10
IV.- RESULTADOS
Para lograr completar exitosamente el proyecto era necesario cumplir estos objetivos:
- Hacer que el acelermetro pueda transmitir los datos que lea
- Emitir sonidos con un buzzer
- Desarrollar funciones de control para los leds
Como se puede observar en el video, todos los objetivos planteados fueron logrados y el cubo fue
implementado exitosamente.
V.- MANUAL DE USUARIO
1. Para iniciar el juego, se debe colocar el dado en el piso.
2. Al hacer esto, se iniciar el modo Demo.
3. El jugador 1 deber lanzar el dado.
4. Se esperar a que los leds terminen de parpadear (3 veces) para volver a tirar el dado.
5. Luego de los dos tiros del jugador 1, es turno del jugador 2, el cual tambin contar con
dos turnos.
6. Gana el jugador que se acerca ms a dos o doce.
7. Al finalizar el juego, se mostrar el color del jugador ganador. En caso de empate, se

mostrarn ambos colores.
8. Para volver a iniciar el juego, se tiene que colocar el dado nuevamente en el piso.
VI.- OBSERVACIONES
Para un correcto funcionamiento del acelermetro dentro de nuestro proyecto, fue necesario realizar
una investigacin sobre este. En nuestro caso, empleamos el modelo MPU-6050, el cual requiri que
el grupo averiguase sobre la comunicacin I2C ya que esta resulta de suma importancia para que dicho
acelermetro transmite los datos.
En la etapa de implementacin algunos problemas, puesto que no exista una comunicacin entre el
acelermetro antes mencionado y tiva. Sin embargo, luego de una serie de intentos, pudimos notar el
error cometido, el cual se haba originado porque no se haba conectado correctamente los puertos
SCL y SDA al tiva. Una vez que se corrigi dicha falla, nuestro grupo consigui que se diese la
comunicacin entre nuestro acelermetro y el Tiva
Por otro lado, al momento de implementar los leds tuvimos un gran obstculo, esto debido a que no
habamos cado en la cuenta de que los leds que se estaban empleando eran de nodo comn. Dicho
descuido ocasion que cuando estaba en curso el programa empleado, los mencionados leds no se
comportan como desebamos (nunca prendieron). Al final dicho inconveniente ese arreglo al momento
de volver a conectar los leds de manera adecuada. Despus de solucionar el problema anteriormente
detallado, lo que sucedi es que el led rojo nunca se apagaba ya que se apreciaba que durante todo
el tiempo de juego se poda notar un pequeo resplandor rojo juego, durante todo el tiempo de juego
se poda notar un pequeo resplandor rojo. Esto se solucion conectando de nuevo todos los leds.
11
VII. CONCLUSIONES
Se alcanzaron los objetivos planteados? S o no, y por qu. Breve, no ms de 10 lneas en total, cada
conclusin numerada.
Si, se alcanzaron con los objetivos planteados, debido a que se logr implementar todas las partes del
proyecto y hacerlas funcionar en conjunto. Desde la parte del software: como la comunicacin i2c y la
lgica de juego, hasta el hardware, como la estructura del cubo y todo el cableado interno.
1. Se logr implementar la comunicacin i2c.
2. Se realiz las funciones de control de leds y buzzer.
3. Se cre la lgica de juego, la cual requera el uso de las funciones anteriores.
VIII. SUGERENCIAS
Se deberan seguir casi al pie de la letra lo que colocaron en el cronograma inicialmente, ya

que , de no hacerlo, se acumulan tareas y al final terminan muy saturados.
Mayor atencin y preocupacin por parte del asesor.
Los horarios de los laboratorios no se adecuan a muchas personas y en el almacn no cuentan
con muchos mdulos tival, por ello es recomendable comprar uno a inicio del curso.
Ser autodidacta, porque mucha de la informacin que se necesita para la configuracin de los
dispositivos como los sensores, se encuentran en internet en su datasheet o en algn libro, lo cual no
te ensean en clase
12
IX. BIBLIOGRAFA.
LED
Jonathan Valvano and Ramesh Yerraballi
2014 Embedded Systems - Shape the World Consulta: 15 de mayo de 2017.
http://users.ece.utexas.edu/~valvano/Volume1/E-Book/C8_SwitchLED.htm
ACELEROMETRO
Tr4nsduc7or
2014 Tutorial de Arduino y MPU-6050. Consulta: 10 de mayo de 2017.
https://robologs.net/2014/10/15/tutorial-de-arduino-y-mpu-6050/
Register map MPU-6050

https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-Register-Map1.pdf
Data sheet MPU-6050

https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-Datasheet1.pdf
13
ANEXOS
Dado
El juego se desarrolla entre dos jugadores, por turnos. En su turno cada jugador har rodar
el dado en dos oportunidades obteniendo un determinado puntaje acumulado. Ganar quien
se acerque ms al puntaje 2 o al puntaje 12. Objetivo Implementar un juego basado en el uso
de un dado, el cual ser implementado mediante el uso de un microcontrolador
TM4C123GH6PM, un acelermetro y seis leds RGB. El acelermetro ser usado para que el
microcontrolador pueda determinar en qu posicin se encuentra y los leds para que por
medio de dos colores brindar la informacin durante el juego. Descripcin Implementar un
dado que en cada cara contenga un led RGB que ser usado para indicar el punto obtenido
y a que jugador corresponde. El juego se desarrolla entre dos participantes por turnos. Cada
jugador depositar el dado en el suelo y en la cara superior se mostrar el led encendido con
el color azul (color para el primer jugador). A continuacin, el jugador deber hacer rodar el
dado. Una vez que el dado se detiene la cara que quede hacia arriba deber mostrar el valor
obtenido mediante el parpadeo del led en tres oportunidades (por ejemplo, si el jugador sac
dos, el led parpadear dos veces, luego se mantiene apagado para volver a parpadear dos
veces ms y luego otras dos veces ms, quedando finalmente apagado). El primer jugador
tendr un tiro ms, para lo cual deber rodar el dado una segunda vez, repitindose el proceso
anterior. Luego le toca el turno al siguiente jugador. Esto se indicar mostrando el led de la
cara superior encendido en rojo (color para el segundo jugador). Esta vez el led en cada
jugada parpadea en el color que le corresponde al segundo jugador. Luego de los tiros del
segundo jugador gana quien se haya acercado ms a 2 o a 12. Para ello las caras laterales
se encienden del color del ganador. En caso de empate la mitad de las caras laterales se
enciende del color del primer jugador y la otra mitad con el color del segundo jugador. Al inicio
del juego el dado entra en un modo de demo en el que se muestra el parpadeo de todas las
caras excepto la que este de cara al suelo y emite una pequea tonada de bienvenida.
14
#include<stdlib.h>
#include<stdint.h>
// Configuraciones //
// ***************************** PWM **********************************//

void configura_pwm(void){ // PWM0 en PC4
uint32_t temp;
SYSCTL_RCGC0_R |= 0X100000; //Se habilita el reloj para el PWM0
SYSCTL_RCGC2_R |=SYSCTL_RCGC2_GPIOC; //Habilitamos el puerto C para seleccionar
PC4 como PWM
temp=SYSCTL_RCGC2_R;
GPIO_PORTC_DIR_R |= (1<<4);
GPIO_PORTC_DR8R_R |=(1<<4);
GPIO_PORTC_DEN_R |= (1<<4);
GPIO_PORTC_AFSEL_R |= (1<<4); // Funcion Alterna para PC4, no GPIO
GPIO_PORTC_PCTL_R=((GPIO_PORTC_PCTL_R & 0xFFF0FFFF)|0x00040000); //
Seleccionamos
//funcion 4 (PWM) de PC4
SYSCTL_RCC_R = (SYSCTL_RCC_R & ~0x1E0000)| (9<<17); // Pre: 64
PWM0_3_CTL_R= ((PWM0_3_CTL_R &~ ((3<<6)|(1<<4)|(1<<3)|(1<<1)|(1<<0)))|(1<<2));
//cuenta
//descendente y sincronizacion local
PWM0_3_GENA_R &= ~ ((3<<10) | (3<<0));
PWM0_3_GENA_R |= (2<<2)|(3<<6);//PC4 es 1 cuando la cuenta llega al valor de
COMPA
PWM0_INVERT_R &= ~(1<<6);//Seal no invertida
}
// Configuracin obtenida de las guias de laboratorio

// *************************************************************************//
void ConfiguraSysTick(void){
// Contador configurado en carrera libre
NVIC_ST_CTRL_R &= ~NVIC_ST_CTRL_ENABLE;
NVIC_ST_RELOAD_R = (NVIC_ST_RELOAD_R&0xFF000000)|0x00FFFFFF;
NVIC_ST_CURRENT_R &= ~(0x00FFFFFF);
NVIC_ST_CTRL_R |= NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE;
}
// ***************************** I2C **********************************//
void configurar_I2C(void){ //Se us PB2 (SCL0) y PB3(SDA0)

SYSCTL_RCGCI2C_R |= (0x01);
while((SYSCTL_PRI2C_R & 0x01)==0){
}
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOB;
while((SYSCTL_PRGPIO_R & 0x02)==0){
}
GPIO_PORTB_AMSEL_R &= ~(0x0C);

GPIO_PORTB_AFSEL_R |= 0X0C;
GPIO_PORTB_ODR_R |= 0x08;
GPIO_PORTB_DEN_R |= 0x0C;
15
GPIO_PORTB_PCTL_R &= ~0xFF000000;
GPIO_PORTB_PCTL_R &= (GPIO_PORTB_PCTL_R & 0xFFFF00FF) + 0x00003300;
I2C0_MCR_R = 0x10; //Activar Master
I2C0_MTPR_R = 0x07;
I2C0_MCS_R &= ~0x10;
}
int lectura_I2C(uint8_t direccion, uint8_t registro){

uint8_t dato,estado;
I2C0_MSA_R = (I2C0_MSA_R & ~0xFF) + (direccion<<1);
do{
I2C0_MDR_R =(I2C0_MDR_R & ~0xFF) + registro;
I2C0_MCS_R = (I2C0_MCS_R & ~0x17)|0x3;
while((I2C0_MCS_R & 1)!=0);
do{
estado = I2C0_MCS_R;
}while(estado & 0x01 !=0);
}while((I2C0_MCS_R & 0x02)!=0);
do{
I2C0_MSA_R = (I2C0_MSA_R & ~(0xFF)) + (direccion<<1) + 1;
I2C0_MCS_R = (I2C0_MCS_R & 0x1F)|0x7;
do{
estado=I2C0_MCS_R;
}while(estado & 0x01 !=0);
}while((I2C0_MCS_R & 0x02)!=0);
dato = I2C0_MDR_R & 0xFF;

return dato;
}
void escribir_I2C(uint8_t direccion, uint8_t registro,uint8_t valor){

char estado;
do{
I2C0_MDR_R = (I2C0_MDR_R & ~0xFF) + registro;
I2C0_MCS_R = (I2C0_MCS_R & ~0x17)|0x3;
do{
}while((estado & 0x01)!=0);
}while((I2C0_MCS_R & 0x02)!=0);
do{
I2C0_MDR_R = (I2C0_MDR_R & ~0xFF) + valor;
I2C0_MCS_R = (I2C0_MCS_R & ~0X1F)| 0x5;
do{
}while((estado & 0x01)!=0);
}while((I2C0_MCS_R & 0x02)!=0);
}
// *****************************************************************************//
// ****************************** LED
***************************************//
void LED_Init(void){ volatile unsigned long delay;
SYSCTL_RCGC2_R |= 0x01;
delay = SYSCTL_RCGC2_R;
GPIO_PORTA_PCTL_R &= ~0x000FFF00;

GPIO_PORTA_AMSEL_R &= ~0xFC;
GPIO_PORTA_DIR_R |= 0xFC;
16
GPIO_PORTA_AFSEL_R &= ~0xFC;
GPIO_PORTA_DEN_R |= 0xFC;
// Port D
GPIO_PORTD_PCTL_R &= ~0x000FFF00;

GPIO_PORTD_AMSEL_R &= ~0xFF;
GPIO_PORTD_DIR_R |= 0xFF;
GPIO_PORTD_AFSEL_R &= ~0xFF;
GPIO_PORTD_DEN_R |= 0xFF;
//PortE
GPIO_PORTE_PCTL_R &= ~0x000FFF00;

GPIO_PORTE_AMSEL_R &= ~0xFF;
GPIO_PORTE_DIR_R |= 0xFF;
GPIO_PORTE_AFSEL_R &= ~0xFF;
GPIO_PORTE_DEN_R |= 0xFF;
}
// *****************************************************************************//
//FUNCIONES //
void genera_PWM( uint32_t freq_pwm, uint32_t DC)

{ //uint32_t pre_clk=250000; //debido al PRE:64 entonces 16000000/64 =250000
uint32_t valor_freq;
uint32_t valor_DC;
PWM0_ENABLE_R &= ~0x40; // Deshabilita PWM6
PWM0_3_CTL_R &= ~1; //Desactiva generador 3 Modulo 0
valor_freq=(250/freq_pwm)-1;
valor_DC= (DC*(valor_freq +1)/100)-1; //Porcentaje de la carga DC%
PWM0_3_LOAD_R &= ~0xFFFF;
PWM0_3_LOAD_R |= valor_freq; // carga el valor para la freq en PWM_LOAD
PWM0_3_CMPA_R &= ~0xFFFF;
PWM0_3_CMPA_R |= valor_DC; // carga el valor para el DC en CMPA
PWM0_3_CTL_R |=1; //Activa generador 3 Modulo 0
PWM0_ENABLE_R |= (1<<6); //habilita PWM6
}
//Funcion genera_PWM obtenida de las guias de laboratorio
void retardo_ms(uint32_t demora_ms){
uint32_t inicioContador, actualContador, diferenciaContador;
uint32_t i;
for(i=0; i<demora_ms; i++){
inicioContador = NVIC_ST_CURRENT_R & 0x00FFFFFF;
do{
actualContador = NVIC_ST_CURRENT_R & 0x00FFFFFF;
diferenciaContador = (inicioContador-actualContador)&0x00FFFFFF;
}while(diferenciaContador<16000);
}
}
//Funcion retardo_ms obtenida de las guias de laboratorio
// funciones que controla del parpadeo, con datos de entrada como TurnoJugador
//(que indica el color del led) y las veces que parpadeara
void parpadeo01LED(uint8_t TurnoJugador, uint8_t cara){

uint8_t i,e;
uint32_t k;
e=0;
while(e<3){
i=0;
while(i<cara){
if (TurnoJugador==1){
17
for(k=0; k<300000; k++); // se puede modificar el valo max de k
dependiendo PA2 (j1)
GPIO_PORTA_DATA_R &= ~(0x04); //de el tiempo que se desee que dure el
parpadeo
for(k=0; k<500000; k++);
GPIO_PORTA_DATA_R |= 0xFF;
}
if (TurnoJugador==2){ //PA3 (ROJO)
for(k=0; k<300000; k++);
GPIO_PORTA_DATA_R &= ~(0x08);
for(k=0; k<500000; k++);
} i++;
} for(k=0; k<999999; k++);
e=e+1;}
}
uint8_t i,e;
uint32_t k;
e=0;
while(e<3){
i=0;
while(i<cara){
dependiendo
parpadeo
for(k=0; k<500000; k++);
}
for(k=0; k<300000; k++);
for(k=0; k<500000; k++);
} i++;
} for(k=0; k<999999; k++);
e=e+1;}
}
uint8_t i,e;
uint32_t k;
e=0;
while(e<3){
i=0;
while(i<cara){
dependiendo
parpadeo
for(k=0; k<500000; k++);
}
for(k=0; k<300000; k++);
for(k=0; k<500000; k++);
} i++;
} for(k=0; k<999999; k++);
e=e+1;}
}
uint8_t i,e;
uint32_t k;
e=0;
18
while(e<3){
i=0;
while(i<cara){
dependiendo
GPIO_PORTD_DATA_R &= ~(0x01); //de el tiempo que se desee que dure el
parpadeo
for(k=0; k<500000; k++);
GPIO_PORTD_DATA_R |= 0xFF;
}
for(k=0; k<300000; k++);
GPIO_PORTD_DATA_R &= ~(0x02);
for(k=0; k<500000; k++);
} i++;
} for(k=0; k<999999; k++);
e=e+1;}
}
uint8_t i,e;
uint32_t k;
e=0;
while(e<3){
i=0;
while(i<cara){
dependiendo
GPIO_PORTD_DATA_R &= ~(0x04); //de el tiempo que se desee que dure el
parpadeo
for(k=0; k<500000; k++);
}
for(k=0; k<300000; k++);
GPIO_PORTD_DATA_R &= ~(0x08);
for(k=0; k<500000; k++);
} i++;
} for(k=0; k<999999; k++);
e=e+1;}
}
uint8_t i,e;
uint32_t k;
e=0;
while(e<3){
i=0;
while(i<cara){
dependiendo
GPIO_PORTE_DATA_R &= ~(0x04); //de el tiempo que se desee que dure el
parpadeo
for(k=0; k<500000; k++);
GPIO_PORTE_DATA_R |= 0xFF;
}
for(k=0; k<300000; k++);
GPIO_PORTE_DATA_R &= ~(0x08);
for(k=0; k<500000; k++);
} i++;
} for(k=0; k<999999; k++);
e=e+1;}
}
19
void parpadeo(int8_t cara,int8_t TurnoJugador){
if (cara==1){
parpadeo01LED(1,cara);
}
}
}
if (cara==2){
}
}
}
if (cara==3){
}
}
}
if (cara==4){
}
}
}
if (cara==5){
}
}
}
if (cara==6){
}
}
}
//Funciones Acelerometro
int convertG(int16_t x){

int8_t r;
if (x>60 && x<80){r=0;}
if (x>175 && x<205){r=1;}
if(x<15||x>240){r=9;}
return r;
}
int posicion(void){
uint32_t ax, ay,az,i,pos,acX,acY,acZ;
ax = lectura_I2C(0x68,0x3B); //dato x MSB

ay = lectura_I2C(0x68,0x3D); //dato y MSB
az = lectura_I2C(0x68,0x3F); //dato z MSB
20
acX=convertG(ax);
acY=convertG(ay);
acZ=convertG(az);
if((acZ==0) && (acX==9) && (acY==9)){

pos=1;
}else if((acZ==1) && (acX==9) && (acY==9)){
pos=6;
}else if((acY==0) && (acX==9) && (acZ==9)){
pos=5;
}else if((acY==1) && (acX==9) && (acZ==9)){
pos=2;
}else if((acX==0) && (acZ==9) && (acY==9)){
pos=4;
}else if((acX==1) && (acZ==9) && (acY==9)){
pos=3;
}
for(i=0;i<8000;i++);
return pos;}
/////********************************///////
void espera(void){
int8_t e,f;
f=lectura_I2C(0x68,0x3F) ;
do{ // espera a que se mueva el dado
e=f;
retardo_ms(250);
e=f-e;
} while((e<10)&&(e>-10));
do{ // inicializa el juego (espera a que se quede quieto)
e=f;
retardo_ms(500);
e=f-e;
} while((e>10)||(e<-10));
}
//////*****************/////////
void modoDemo(void){
int8_t a,b;
uint32_t freq_pwm=40; //Frecuencia inicial 40KHz
uint32_t DC=50; // duty cycle inicial 50%
a=0;b=0;
// conf();
do{a=posicion();} while ((a>6)||(a<1));
while (b<3){
genera_PWM(freq_pwm, DC);
retardo_ms(250);
genera_PWM(0, DC);
retardo_ms(200);
genera_PWM(freq_pwm, DC);
retardo_ms(250);
genera_PWM(0, DC);
//cara6 abajo
if(a==1){
GPIO_PORTA_DATA_R &= ~(0x04); //1

GPIO_PORTD_DATA_R &= ~(0x01); //4
}
//cara5 abajo
if(a==2){
21
GPIO_PORTE_DATA_R &= ~(0x04); //6
}
//cara4 abajo
if(a==3){

}
//cara3 abajo
if(a==4){

}
//cara2 abajo
if(a==5){

}
//cara1 abajo
if(a==6){

}
retardo_ms(750);
retardo_ms(750);
b=b+1;
}}
void inicio (int8_t turnoJugador){

int8_t a;
a=0;
if (turnoJugador==1) {
if(a==1){
}
if(a==2){
}
if(a==3){
}
if(a==4){
22
}
if(a==5){
}
if(a==6){
if (turnoJugador==2) {
if(a==1){
}
if(a==2){
}
if(a==3){
}
if(a==4){
}
if(a==5){
}
if(a==6){
}
}}
int ValoresCara (void){

int8_t a,e,f;
f=lectura_I2C(0x68,0x3B);
a=0;
retardo_ms(500);
e=f;
retardo_ms(250);
f=lectura_I2C(0x68,0x3B) ;
e=f-e;
} while((e<10)&&(e>-10));
retardo_ms(500);
f=lectura_I2C(0x68,0x3B);
do{ // inicializa el juego (espera a que se quede quieto)
e=f;
retardo_ms(250);
f= lectura_I2C(0x68,0x3B) ;
e=f-e;
} while((e>10)||(e<-10));

return a;
}
int Juego (int8_t TurnoJugador){

int8_t a,b;
inicio(TurnoJugador);
23
espera();
a=ValoresCara();
parpadeo(a,TurnoJugador);
retardo_ms(300);
espera();
b=ValoresCara();
parpadeo(b,TurnoJugador);
retardo_ms(300);
a=a+b;
return a;
}
void Ganador(int8_t j1,int8_t j2){

int8_t a,b,c,d,e;
a=0;
e=j1-2; //f,g,h,y k calculan la diferencia Jugadores a 12 y 2
b=12-j1;
c=j2-2;
d=12-j2;
if(e>b){j1=b;} //define si se acerc ms al 2 o el 12
if(e<b){j1=e;}
if(e==b){j1=e;}
if(c>d){j2=d;}
if(c<d){j2=c;}
if(c==d){j2=c;}
if (j1<j2) {
//cara6 abajo
if(a==1){
}
//cara5 abajo
if(a==2){
}
//cara4 abajo
if(a==3){

}
//cara3 abajo
if(a==4){

}
//cara2 abajo
if(a==5){
24
}
//cara1 abajo
if(a==6){

}}
///*************************************//
if (j2<j1) {
//cara6 abajo
if(a==1){
}
//cara5 abajo
if(a==2){
}
//cara4 abajo
if(a==3){

}
//cara3 abajo
if(a==4){

}
//cara2 abajo
if(a==5){

}
//cara1 abajo
if(a==6){

}}
////empate*******
25
if (j1==j2) {
//cara6 abajo
if(a==1){
}
//cara5 abajo
if(a==2){
GPIO_PORTA_DATA_R &= ~(0x04); //1j1
GPIO_PORTA_DATA_R &= ~(0x40); //3j1
}
//cara4 abajo
if(a==3){
GPIO_PORTA_DATA_R &= ~(0x04); //1 j1

}
//cara3 abajo
if(a==4){

}
//cara2 abajo
if(a==5){

}
//cara1 abajo
if(a==6){

}}
}
void main(void){
int8_t e,f,J1,J2;
configurar_I2C();
ConfiguraSysTick();
LED_Init();
configura_pwm();
I2C0_MCR_R = 0x10;
I2C0_MDR_R = (I2C0_MDR_R & ~0xFF) + 0x1A;
I2C0_MCS_R = 0x03;
I2C0_MSA_R = (I2C0_MSA_R & ~0xFF) + (0x68<<1);
while((I2C0_MCS_R & 1)!=0);

escribir_I2C(0x68,0x6B,0x00);
escribir_I2C(0x68,0x1A,0x3A);
26
while(1){
J1=0;J2=0;
espera();
modoDemo();
J1=Juego(1); //turno, jugador 1 puntaje
J2=Juego(2); // turno jugador 2 puntaje
//
Ganador(J1,J2);
e=f;
retardo_ms(250);
e=f-e;
} while((e<10)&&(e>-10));
retardo_ms(400);
27

Informe SD

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Informe SD

Загружено:

Авторское право:

Доступные форматы

Facultad de Ciencias e Ingeniera

Seccin Electricidad y Electrnica

Tarea Acadmica - Sistemas Digitales (IEE256)

Karla Lucia Honorio Heredia

Eduardo Bryan Prada Licla

Asesor: Luis Raymi

30 de junio del 2017

I. DESCRIPCION DEL PROYECTO .. 3

II. METODOLOGA DE DESARROLLO . 4

III. DESCRIPCION DEL HARDWARE Y SOFTWARE . 5

3.1 Diagrama de bloques 5

3.2 Diagrama esquemtico. 5

3.3 Explicacin del circuito. 6

3.4 Lista de componentes y precio... 6

3.5 Diagrama de flujo del programa principal. .. 7

3.6 Diagramas de flujo de las funciones relevantes 7

3.7 Descripcin de las variables utilizadas. 8

3.8 Explicacin del algoritmo.. 8

3.9 Documentacin de las funciones. 9

3.1.- Diagrama de bloques

3.4.- Lista de componentes y precio.

CANTIDAD Precio unitario(s/.) Precio(s/.)

Acelermetro MPU-6050 1 18.00 18.00

Leds RGB 12 1.00 12.00

Cables Macho-Hembra 1 paquete 6.00 6.00

Cables Macho-Macho 1 paquete 6.00 6.00

Protoboard 1 15.00 15.00

Tiva LaunchPad 1 83.00 83.00

Trupan (1.20mx0.7m) 1 15.00 15.00

Pegamento 1 5.00 5.00

PARPADEOxxLED (para cualquiera de las 6 funciones de parpadeo)

3.8.- Explicacin del algoritmo utilizado.

3.9.- Documentacin de las funciones:

PARPADEOxxLED (para cualquiera de las 6 funciones de parpadeo)

V.- MANUAL DE USUARIO

1. Para iniciar el juego, se debe colocar el dado en el piso.

2. Al hacer esto, se iniciar el modo Demo.

3. El jugador 1 deber lanzar el dado.

6. Gana el jugador que se acerca ms a dos o doce.

7. Al finalizar el juego, se mostrar el color del jugador ganador. En caso de empate, se

Se deberan seguir casi al pie de la letra lo que colocaron en el cronograma inicialmente, ya

Register map MPU-6050

Data sheet MPU-6050

// ***************************** PWM **********************************//

// Configuracin obtenida de las guias de laboratorio

// ***************************** I2C **********************************//

void configurar_I2C(void){ //Se us PB2 (SCL0) y PB3(SDA0)

GPIO_PORTB_AMSEL_R &= ~(0x0C);

int lectura_I2C(uint8_t direccion, uint8_t registro){

}while((I2C0_MCS_R & 0x02)!=0);

dato = I2C0_MDR_R & 0xFF;

void escribir_I2C(uint8_t direccion, uint8_t registro,uint8_t valor){

GPIO_PORTA_PCTL_R &= ~0x000FFF00;

GPIO_PORTD_PCTL_R &= ~0x000FFF00;

GPIO_PORTE_PCTL_R &= ~0x000FFF00;

void genera_PWM( uint32_t freq_pwm, uint32_t DC)

void parpadeo01LED(uint8_t TurnoJugador, uint8_t cara){

int convertG(int16_t x){

ax = lectura_I2C(0x68,0x3B); //dato x MSB

if((acZ==0) && (acX==9) && (acY==9)){

GPIO_PORTA_DATA_R &= ~(0x04); //1

GPIO_PORTA_DATA_R &= ~(0x04); //1

GPIO_PORTA_DATA_R &= ~(0x04); //1

// * PWM ******//

// * I2C ******//