Simon Dice

Proyecto Simn:
DISEO SISTEMAS MVILES Y EMPOTRADOS

DSEM
ngel Castillo
Sergi Martnez
Hctor Ortiz
Toni Torronteras
NDICE
1.
2.
INTRODUCCIN ......................................................................................................... 3
DISEO ANALGICO.................................................................................................. 4
2.1. Pulsadores .......................................................................................................... 5
2.2. Caja..................................................................................................................... 7
3. Placa Wiring............................................................................................................... 8
4. Cdigo...................................................................................................................... 10
4.1. Funcionamiento del programa ........................................................................ 11
4.2. Modo 1 player .................................................................................................. 11
4.3. Modo 2 player .................................................................................................. 12
5. Presupuesto............................................................................................................. 15
6. Conclusiones............................................................................................................ 15
7. Anexo cdigo placa esclavo..................................................................................... 16
8. Anexo cdigo placa maestro ................................................................................... 22
1. INTRODUCCIN
DSEM (Diseo de Sistemas Mviles y Empotrados) es una de las optativas de la
ingeniera tcnica de telecomunicaciones, en la cual hemos aprendido a desarrollar
aplicaciones para PDAs, telfonos mviles y adems a programar en un nuevo
lenguaje para nosotros, Processing. Es un lenguaje basado en Java, pero de mucho mas
alto nivel, es decir, mucho mas entendible para el usuario, ya que no utiliza un cdigo
demasiado complejo. Este lenguaje naci precisamente para que gente poco
habituada a la programacin pudiera realizar proyectos de un cierto grado de
complejidad. A partir de haber descubierto esta nuevo tipo de lenguaje y su facilidad
para la programacin, habiendo realizado una serie de pruebas, estudio de libreras y
diferentes tipos de programas realizados por variedad de programadores, conocimos
la programacin Wiring, muy similar a Processing, pero con un dispositivo hardware
por en medio. Este dispositivo hardware consta principalmente de una placa donde
tenemos una BIOS donde cargamos el cdigo del programa, puertos de entrada/salida,
entrada USB, para conectar con el ordenador y una entrada para la alimentacin
despus de aprender el funcionamiento de Wiring se decidi realizar un proyecto final
de asignatura basado en este lenguaje.
Para ello y tras una seleccin de diferentes propuestas de proyectos, decidimos
elaborar el proyecto sobre un juego tradicional, Simn Dice. Este juego trata de
seguir la secuencia de colores, pulsando el botn adecuado a cada color, en el que
adems incluye la opcin de dos jugadores. A priori, parece que no tiene gran
complejidad, pero como veremos mas adelante, tiene mas de la que parece. Para
hacer este proyecto mas atractivo, y como el mismo nombre de la asignatura indica,
decidimos realizar todo el montaje del proyecto, es decir, tanto la parte de
programacin como mecnica, la construccin fsica del aparato a partir de la placa
Wiring.
2. DISEO ANALGICO
Antes de empezar a elaborar todo el proyecto, empezamos a tomar ideas para realizar
el diseo del aparato en cuestin que el usuario debera tener para poder jugar.
El diseo en estara basado en una caja de metraquilato donde colocaramos la placa
Wiring y toda la electrnica que necesitramos. Esta caja debe tener unas dimensiones
adecuadas para que dentro de ella cupiera la placa, circuitera interna, una pequea
fuente de alimentacin en forma de pila. En un principio la caja no deba ser cerrada,
ya que los pulsadores deberan estar por fuera y necesitbamos tener la cara de arriba
libre, pero tras la adquisicin de la caja cerrada, con la posibilidad de abrirla por la
parte superior, decidimos que sera una mejor opcin hacer los agujeros en la tapa
para la colocacin de los pulsadores. La caja en cuestin tiene las siguientes medidas
160mm de largo, 100mm de ancho y 50mm de alto.
Para el montaje de los pulsadores desde el principio tenamos en mente soldar cuatro
botones en las esquinas de una placa de baquelita de unos 35cmx35cm, con suficiente
espacio para poder pegarla en la parte superior de la caja de metraquilato de
exactamente 35cm. y colocar 4 leds en el centro de la placa como muestra la figura 1,
haciendo as que la cabeza del led saliera dos milmetros por encima de la placa de
baquelita, y las dos patas por cada led por debajo, que quedaran dentro de la caja de
metraquilto. Una vez hecho esto, pensamos en una primera instancia sacar dos cables
por cada botn, pero al final fue una idea descartada, ya que era inviable la idea de
sacar 8 cables de los 4 botones mas las 8 patas de los leds, por cada pulsador por falta
de espacio dentro de la caja, por lo tanto, decidimos unir las pistas de la placa de
metraquilato, uniendo as los cuatro botones en paralelo y sacar nicamente 3 cables
por cada pulsador mas las dos patas de cada led.
FIG. 1 Esquema pulsador
Una vez definido el esquema de este pulsador, decidimos colocar encima de los cuatro
botones, una placa de metraquilato de cada color y la uniramos con pegamento.
Con lo que quedara un prototipo como el de ver Fig. 2.
FIG. 2 Vista area del prototipo
Una vez realizado esto, tenamos que decidir como colocar de manera visible el nivel
de la partida elegida y el jugador activo en ese momento, para ello colocamos en
nuestro diseo, tres led`s indicando la dificultad. Un led encendido significa nivel fcil,
dos leds encendidos, nivel medio, tres led`s encendidos significa nivel difcil. El jugador
que esta activo lo mostrara mediante un siete segmentos.
Fig. 3 Vista area del prototipo versin 2.
2.1.
Pulsadores
Empezamos cortando la placa de baquelita para realizar los pulsadores. Aqu tuvimos
el primer problema, ya que si cortbamos mal, la placa se rompera fcilmente, por lo
tanto no era posible cortar esta placa con tijeras, ni con cutex, as que al final optamos
por utilizar una Dremel, herramienta ptima para cortar, perforar este tipo de
material, de una manera limpia y segura.
Empezamos serrando cuadrados de baquelita de 30x 30, un total de 8. Una vez
cortados, tuvimos que realizar cuatro perforaciones por cada cuadrado de baquelita,
para introducir los leds. Continuamos soldando los botones en las esquinas como
mostraba la Fig. 1, acto seguido, usando estao creamos las pistas necesarias para
poder colocar los botones en paralelo y finalmente enganchamos los leds. En resumen,
de cada placa de baquelita nos salen 2 cables por led, un cable comn para todos los
pulsadores y 2 cables que se unirn para el otro polo de los pulsadores.
Fig. 4 Esquema electrnico pulsador.
En la FIG. 4, se muestran en rojo las conexiones a los cables de salida. Estas 4 placas de
baquelita van pegadas con loctite a la caja del juego.
En la siguiente FIG. 5, se muestra el modo en el que van conectados los pulsadores en
la placa. De este modo conseguimos un 0 o un 1 lgico evitando el estado de alta
impedancia.
Fig. 5 Esquema electrnico pulsador individual.
Los 4 leds deben estar conectados en paralelo con una resistencia de valor resistivo
bajo y en serie.
Fig. 6 Esquema electrnico leds boton.
El resultado final se puede observar en la siguiente imagen (ver FIG. 7) :
Fig. 7 Fotografa pulsador final.
2.2. Caja
El montaje de la caja tiene menor complejidad que los pulsadores, ya que la caja de
metraquilatro ya estaba fabricada a medida, como hemos dicho anteriormente,
aprovechbamos la tapa de la caja para insertar los pulsadores, para ello perforamos la
caja con una Dremel en las cuatro posiciones indicadas en la Fig. 2 para marcarlas y
posteriormente hacer un agujero mucho mayor con una corona, con unas dimensiones
adecuadas inferior a los 30x30, para que la placa de baquelita no caiga dentro de la
perforacin.
Una vez perforamos realizado este paso, queda enganchar los pulsadores y el
resultado es el siguiente (ver FIG. 8) :
Fig. 8 Fotografa montage botones.
Una vez realizados estos pasos, hicimos tres perforaciones para indicar el grado de
dificultad de la partida; Dos ms para indicar cul de los dos jugadores tiene el turno y
adems un 7 segmentos para indicar las vidas restantes. En la misma caja, incluimos
un botn especial para seleccionar estos parmetros del juego.
3. Placa Wiring
El corazn de la placa lo integra un microcontrolador modelo ATMEGA128 del
fabricante ATMEL. Hemos extraido las caractersticas del datasheet que proporciona
este fabricante y son las siguientes:
Fig. 9 caracteristicas atmel128, 8-Bit microcontroller with 128KBytes In-System Programmable Flash.
La placa Wiring esta adaptada a este microcontrolador mediante un esquema

electrnico con las conexiones I/O realizadas mediante agrupaciones de pines, es
decir, PUERTOS. Tambien incluye una conexin USB para facilitar la conexin al PC y
con ello su programacin, un led de power, un botn de reset, etc.
Fig. 10 Placa Wiring.
43 Pines digitales I/O.

5 Puertos digitales (8 bits por puerto).
8 Entradas analgicas (10 bits de resolucin).
6 Salidas analgicas de Pulse Width Modulation PWM.
2 Puertos series.
2 Pines Two Wire Interface, ms conocido como i2c.
8 Interrupciones externas.
Conector para alimentacin, fuente 7-13 V a 800mA.
El entorno de programacin consiste en un software de libre descarga y diseado para

la programacin de la placa Wiring. El lenguaje de programacin utilizado es C pero
con unas series de libreras (ya integradas en el software) que facilitan la tarea. No
olvidemos que esta iniciativa esta enfocada a un publico no familiarizado con la
electrnica ni con programacin.
Fig. 11 Entorno de programacin wiring.
Tal como vemos en la FIG. 11 se trata de un software bastante sencillo comparado con
otros entornos de programacin (Microsoft Visual Studio, MPLAB, ). Unicamente
disponemos de 7 botones: play (compila), stop, new, save, load, upload to I/O board
(grabar en placa wiring) y serial monitor (herramienta ms prxima a un debuger).
4. Cdigo
Nuestro programa se puede dividir en cuatro partes:
1. Variables globales: aqu se declaran aquellas variables que podemos utilizar en
cualquier momento del programa. Tambin declaramos nombres a los pines a
utilizar.
2. Funciones: en esta parte del programa, definiremos todas aquellas funciones
que necesitaremos a lo largo del programa. Estas funciones puden ser llamadas
en la parte Loop y dentro de otras funciones.
3. Setup: esta parte consiste en la configuracin de la placa, es decir,
estableceremos que pines sern de salida o de entrada y activaremos la
interfaz para los pines de comunicacin.
4. Loop: es el equivalente al main() de cualquier lenguaje de programacin, con la
diferencia que se ejectua en modo bucle infinito.
10
4.1. Funcionamiento del programa

Nuestro proyecto consiste en emular el juego conocido por todos como SIMON tanto
para 1 jugador como para 2 jugadores.
Cuando encendemos (conectamos alimentacin) la placa wiring espera 10 segundos
para introducirle el nmero de jugadores, esto ser indicado mediante ledPlayer1 en
pin 20 y ledPlayer2 en pin 21 usando el pulsador central conectado al pin 19. Si
queremos jugar en modo multijador debemos establecer player 2 en las dos placas.
Sino cada placa funcionaran de manera independiente.
El siguiente paso consiste en elegir el modo de dificultad deseada. Hemos programa
tres niveles de dificultad para un mximo de 10 turnos. Disponemos de otros 10
segundos para elegir modo mediante el mismo pulsador central (pin19) y se visualiza
mediante tres leds conectados a los pines 16, 17, 18.
A continuacin describimos las cabeceras de las funciones:
int seleccionaplayer();
int seleccionadificultad();
int hazturno(int turnos, int aleatorio[],int error);
void apagarLEDS();
void leeentrada(int vectoruser[],int turnos);
void muestravector(int vector[],int turnos);
int comparavector(int vector_random[], int vector_user[], int turnos);
void segmentos_off();
void segmentos_on(int number);
void receiveEvent(int howMany);
void requestEvent();
4.2. Modo 1 player

. . .
if(prueva==0)
{
player=seleccionaplayer();
}
if (player==1)
{
for(i=0;i<30;i++)
{
aleatorio[i]=random(8,12);
}
dificultad=seleccionadificultad();
for(turnos=1;turnos<10*dificultad;turnos++)
{
aux=hazturno(turnos*dificultad,aleatorio,aux);
if (aux==1)
turnos=0;
}
}
. . .
Fig. 12 Extracto de cdigo modo 1player.
Este extracto de cdigo es para el modo 1 jugador y pertenece a la parte void loop().
Primero llamamos a la funcin int seleccionplayer() que nos devuelve el resultado de
11
elegir player 1. Segundo generamos el vector int aleatorio*30+ y mediante la funcin

random(8,12). Recordemos que el ledAzul corresponde al pin 8, el ledVerde al pin 9,
el ledRojo al pin 10 y el ledAmarillo al pin11.
El tercer paso consiste en llamar a la funcin int seleccionadificultad() que nos
devuelve el nivel de dificultad elegido.
Una vez elegido el player 1 y el nivel de dificultad comienza el juego. El turno lo
controlamos mediante un bucle for(turnos=1;turnos<10*dificultad;turnos++), la
funcin int hazturno(int turnos, int aleatorio*+,int aux) es la que se encarga de
realizar el juego: muestra el vector aleatorio, recoge el botn pulsado, muestra la
secuencia pulsada por el player y comprueba si es correcto sino lo es devuelve un
auxiliar y parpadean los 4 leds tres veces consecutivas. Por supuesto el juego se
reinicia.
A continuacin mostramos el cdigo de la funcin hazturno(,,,) ya que es la principal:
int hazturno(int turnos, int aleatorio[],int error)
{
int n;
int vectoruser[30];
muestravector(aleatorio,turnos);
leeentrada(vectoruser,turnos);
muestravector(vectoruser,turnos);
error=comparavector(aleatorio,vectoruser,turnos);
if(error==1)
{
for(n=0;n<3;n++)
{
digitalWrite(ledAZUL,HIGH);
digitalWrite(ledVERDE,HIGH);
digitalWrite(ledROJO,HIGH);
digitalWrite(ledAMARILLO,HIGH);
delay(200);
digitalWrite(ledAZUL,LOW);
digitalWrite(ledVERDE,LOW);
digitalWrite(ledROJO,LOW);
digitalWrite(ledAMARILLO,LOW);
delay(200);
}
}
return(error);
}
Fig. 13 Extracto del cdigo de la funcin int hazturno(int turnos, in t aleatorio[],int error)
4.3. Modo 2 player

Esta ha sido la parte mas conflictiva del proyecto. Las placas wiring disponen de 2
puertos tipo serie para comunicarse con hardware externo (PC junto a processing),
estos puertos se configuran en la parte vodi setup() del siguiente modo (ver FIG. 14):
12
Void setup()
{
Serial.begin(9600); //puerto serie USB o pines 37 y 36
Serial1.begin(9600);// puerto serie pins 3 (Rx) y 4 (Tx)
. . .
}
Void loop()
{
. . .
Int val = Serial1.read();//para Rx
Serial1.print(val);//para Tx
. . .
}
Fig. 14 Cdigo puerto serie.
En un primera versin se intento el puerto serie descrito en la FIG. 14 pero no fue

posible enviar y recibir debido a una falta de sincronismo entre las dos placas. Este
mdo est ms indicado para enviar info al PC y mediante software Procesing capturar
estos datos para un procesado en PC.
Una vez descartada esta posibilidad, la otra librera que nos proporciona el entorno
Wiring para comunicacin entre placas es el interfaz llamado TWI (Two Wire Interface)
que usa el nombre Wire y los pines 0 (SCL) y 1 (SDA). Este interfaz es conocido por los
electrnicos como i2c. Se establece un dispositivo como master y los dems
dispositivos (pueden ser varios) como esclavos. Como contrapartida, hay que aclarar
que los cdigos de cada placa son diferentes (una para la placa maestra ver Fig. 16 y
otra esclava ver FIG. 15).
Void setup()
{
Wire.begin(2); //dispositivo esclavo con identificador 2
Wire.onRequest(requestEvent); // evento peticin tx esclavomaster
Wire.onReceive(receiveEvent); // evento comunicacin masteresclavo
. . .
}
Void loop()
{
. . .
if(player==2)
{
if(prueva==0)
{
prueva=1;
}
if(aviso==1)
{
int turnosaux=0;
turnos++;
turnosaux=turnos*dificultad;
error=hazturno(turnosaux,aleatorio,error);
delay(500);
turnos++;
aviso=0;
digitalWrite(pinslave,HIGH);//pin para indicar a master que has
terminado turno, y le toca a el.
}
}
}
void receiveEvent(int howMany)
{
int i=0;
int error=0;
if(primero==0)
{
13
while(1<Wire.available())
{
aleatorio[i] = Wire.receive();// recibe vector aleatorio de master.
i++;
}
}
}
void requestEvent()
{
aviso=1;
digitalWrite(pinslave,LOW); //pin para indicar a master que estas
haciendo el turno (esclavo).
Wire.send(error); // responde al master con el envio variable error.
}
Fig. 15 Exctracto cdigo TWI dispositivo esclavo.
Void setup()
{
Wire.begin();//dispositivo como maestro.
. . .
}
Void loop()
{
. . .
if(player==2)
{
int error=0;
Wire.beginTransmission(2);//comenzamos transmisin al dispositivo 2.
for(i=0;i<30;i++)
{
Wire.send(aleatorio[i]);//enviamos aleatorio al esclavo
}
Wire.endTransmission();//cerramos la conexin
while(turnos<10)
{
if(aviso==0)
{
error=hazturno(turnos*dificultad,aleatorio,error);
Wire.requestFrom(2,2);//solicitamos envio del esclavo.
error=Wire.receive();
aviso=1;
turnos=turnos+2;
}
else
{
if(digitalRead(pinslave)==HIGH)//si es cierto le toca turno a master
aviso=0;
}
}
}
}
FIG. 16 Extracto cdigo TWI dispositivo maestro.
Hemos tenido que utilizar la ayuda de un pin auxiliar llamado pinslave y conectado al
pin 7. En modo INPUT en cdigo maestro y OUTPUT en en cdigo esclavo. Con este pin
hemos establecido un sistema de turnos mediante la variable int aviso.
Cuando queremos enviar info desde el master al esclavo utilizamos la funcin
Wire.send(aleatorio*i+), se genera un evento en la placa esclavo con nombre void
receiveEvent(int howMany) que se encarga de rellenar el vector aleatorio generado
en placa master.
Para solictar info desde el esclavo al master utilizamos la funcin
Wire.requestFrom(2,2) donde el primer 2 indica el dispositivo al que pedimos la info
14
y el segundo 2 indica el tamao en bytes que esperamos recibir. En el cdigo esclavo

se atiende al evento con void requestEvent() activamos pinslave a valor HIGH cuando
finaliza el turno en esclavo.
Para dicha comunicacin vamos a utilizar tres pines, el pin 0, el pin 1 y el pin 7.
Los cdigos completos se pueden consultar en el anexo, al final de este documento.
5. Presupuesto
Componentes
2 Bolsas 36 Pins conexion
Pila Alcalina 9v
Clip portapilas 9v
Pulsador grande start
Resistencias, Leds, Condensadores,
Pulsadores,
Caja metraquilato con tapa 160x1
Placas metraquilato redondas o cuadradas
(4 unidades de 4)
Conectores alimentacin
1 Placa de baquelita
1 metro cable rectil
TOTAL:
Precio un simon
2.28
4.59
0.16
0.68
GRATIS
Precio dos simon

4.56
9.18
0.32
1.36
GRATIS
16
3.7
32
7.40
0.14
4.75
1.30
0.28
9.5
2.60
23.28
47.7
Tabla 1 Presupuesto proyecto.
El coste total para realizar un simon es de 23.28 y el doble 47.7 en el caso de

implementar los dos simon.
Lo ms caro del presupuesto es la caja de metraquilato donde vamos a alojar las placas
Wiring con un precio de 16 la unidad. Existen toda una serie de componentes que no
son necesarios comprar, ya que como estudiantes de Ing. Telecos disponemos de
resistencias, leds, condensadores, cables, pulsadores, de asignaturas anteriores.
Tienda consultada: Diotronic.
La caja de metraquilato es de color transparente y dispone de una tapa en la parte
superior facilitando la manipulacin del contenido. Tienda consultada: Servei Estaci.
6. Conclusiones
Es la primera vez que nos enfrentamos a un proyecto que incluya software y hardware.
El entorno Wiring nos ha proporcionado el conocimiento de un nuevo lenguaje
bastante intuitivo (poco complejo) y de muy alto nivel, ya que se basa en el uso de
libreras proporcionadas por Wiring.
El diseo analgico no ha sido nada trivial, ya que hemos tenido que realizar diversas
pruebas desde cero (variacin del esquema electrnico inicial).
Realizar el hardware en cajas de metraquilato con la ayuda de una dremel ha sido un
proceso muy laborioso y costos en trminos de horas.
15
Como conclusin destacar que es un proyecto para realizar en grupo de cuatro

personas, como mnimo. Y es necesario una cordinacin entre miembros P2P.
Eso s, nos hemos divertido, hemos disfrutado y hemos alcanzado la mitad de objetivos
propuestos: una caja de metraquilato y placa protoboard, modo un jugador y modo
dos jugadores. Nos ha faltado tiempo para aadirle el BCD 7 segmentos para indicar
turnos y sonido a cada botn.
7. Anexo cdigo placa esclavo

int prueva=0;
int aviso=0;
int error=0;
int player = 1;
int dificultad=1;
int turnos=1;//variable global para el numero de turnos (maximos 10 turnos)
int ledAZUL=8;//8
int ledVERDE=9;//9
int ledROJO=10;//10
int ledAMARILLO=11;//11
int botonAZUL=12;//12
int botonVERDE=13;//13
int botonROJO=14;//14
int botonAMARILLO=15;//15
int ledSTART=23;
int ledplayer1=20;
int ledplayer2=21;
//int vectoruser[30]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int aleatorio[30]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int ledDificultad1=16;
int botonDificultad=19;
int pinslave=7;
int primero=0;
//int ruido=0;
void receiveEvent(int howMany)
{
int i=0;
int error=0;
if(primero==0)
{
while(1<Wire.available())
{
aleatorio[i] = Wire.receive();
// receive byte as an integer
//Serial.print(aleatorio[i]);
i++;
}
}
}
void requestEvent()
{
aviso=1;
digitalWrite(pinslave,LOW);
Wire.send(error); // respond with message of 6 bytes
}
int seleccionaplayer()
{
int dif=0;//variable para leds dificultad
int aux=1;//variable para nivel dificultad.
int time1=(int)(millis());//variable milisegundos tiempo de la aplicacin
ejecutada
int time=time1;
digitalWrite(ledplayer1,HIGH);
16
while(time<time1+10000)//10 segundos para elegir modo de dificultad.

{
if(digitalRead(botonDificultad)==HIGH)
{
delay(500);
if(digitalRead(botonDificultad)==LOW)
{
dif++;
if(dif==1)//dificultad facil, se avanza de uno en uno.
{
digitalWrite(ledplayer2,LOW);
aux=1;
}
if(dif==2)//difultad dificil, se avanza de tres en tres.
{
dif=0;
aux=2;
}
}
}
time=(int)millis();
}
return(aux);
}
int seleccionadificultad()
{
ejecutada
int time=time1;
digitalWrite(ledDificultad1,HIGH);
{
{
delay(500);
{
dif++;
{
digitalWrite(ledDificultad2,LOW);
aux=1;
}
if(dif==2)//difucltad media, se avanza de dos en dos.
{
aux=2;
}
{
dif=0;
aux=3;
}
}
}
time=(int)millis();
}
17
return(aux);
}
{
int n;
int vectoruser[30];
Serial.println("ANTES");
Serial.println(aleatorio[0]);
if(error==1)
{
for(n=0;n<3;n++)
{
delay(200);
delay(200);
}
}
return(error);
}
void apagarLEDS()
{
digitalWrite(ledROJO,LOW),
}
void leeentrada(int vectoruser[],int turnos)
{
int i;
for ( i=0;i<turnos;i++)
{
if( digitalRead(botonAZUL)==HIGH )
{
delay(50);
if(digitalRead(botonAZUL)==LOW)
{
vectoruser[i]=8;
continue;
}
}
if( digitalRead(botonVERDE)==HIGH )
{
delay(50);
if(digitalRead(botonVERDE)==LOW)
{
vectoruser[i]=9;
continue;
}
}
if( digitalRead(botonROJO)==HIGH )
{
delay(50);
if(digitalRead(botonROJO)==LOW)
18
{
vectoruser[i]=10;
continue;
}
}
if( digitalRead(botonAMARILLO)==HIGH )
{
delay(50);
if(digitalRead(botonAMARILLO)==LOW)
{
vectoruser[i]=11;
continue;
}
}
i--;
}
}
void muestravector(int vector[],int turnos)
{
int i;
int t=(int)millis();
for(i=0;i<turnos;i++)
{
digitalWrite(vector[i],HIGH);
delay(500);
digitalWrite(vector[i],LOW);
delay(500);
}
}
int comparavector(int vector_random[], int vector_user[], int turnos)
{
int n;
int a=0;
for(n=0;n<turnos;n++)
{
if(vector_random[n]!=vector_user[n])
a=1;
}
return a;
}
void segmentos_off()//funcion q apaga el 7segmentos
{
for(int i=0; i<8; i++)
{
digitalWrite(i, HIGH);
}
}
void segmentos_on(int number)//funcion para el 7segmentos
{
if(number==0)
{
digitalWrite(5, HIGH);
}
if(number==1)
{
digitalWrite(5, LOW);
}
if(number==2)
19
{
digitalWrite(7,
digitalWrite(4,
digitalWrite(6,
digitalWrite(0,
digitalWrite(1,
HIGH);
HIGH);
HIGH);
HIGH);
HIGH);
}
if(number==3)
{
}
if(number==4)
{
}
if(number==5)
{
}
if(number==6)
{
}
if(number==7)
{
}
if(number==8)
{
}
if(number==9)
{
}
delay(1000); // waits for 1000 milli seconds
//number = number + 1; // increments the variable to show
if(number > 9) { // check for the range, if greater then 9 goes back to 0s
number = 0;
20
}
}
void setup()
{
Serial.begin(9600);
//Serial1.begin(9600);
Wire.begin(2);
Wire.onRequest(requestEvent);
Wire.onReceive(receiveEvent);
pinMode(ledAZUL,OUTPUT);
pinMode(ledVERDE,OUTPUT);
pinMode(ledROJO,OUTPUT);
pinMode(ledAMARILLO,OUTPUT);
pinMode(botonAZUL,INPUT);
pinMode(botonVERDE,INPUT);
pinMode(botonROJO,INPUT);
pinMode(botonAMARILLO,INPUT);
pinMode(ledDificultad1,OUTPUT);
pinMode(botonDificultad,INPUT);
pinMode(ledSTART,OUTPUT);
pinMode(ledplayer1,OUTPUT);
pinMode(pinslave,OUTPUT);
//pinMode(ruido,OUTPUT);
}
void loop()
{
int i=0;
int n=0;
int aux=0;
int a;
int sound;
digitalWrite(ledSTART,HIGH);
//int prueva[10]={8,9,10,11,8,9,10,11,8,8};
if(prueva==0)
{player=seleccionaplayer();
Serial.println(player);
}
if (player==1)
{
for(i=0;i<30;i++)
{
}
for(turnos=1;turnos<10*dificultad;turnos++)
{
if (aux==1)
turnos=0;
}
}
if(player==2)
{
if(prueva==0)
{
prueva=1;
21
}
if(aviso==1)
{
int turnosaux=0;
turnos++;
turnosaux=turnos*dificultad;
Serial.println(turnosaux);
error=hazturno(turnosaux,aleatorio,error);
delay(500);
turnos++;
aviso=0;
digitalWrite(pinslave,HIGH);
}
}
}
Fig. 17 Cdigo completo placa wiring esclavo.
8. Anexo cdigo placa maestro

int player = 1;
int aviso=0;
int dificultad=1;
int turnos=1;//variable global para el numero de turnos (maximos 10 turnos)
int ledAZUL=8;//8
int ledVERDE=9;//9
int ledROJO=10;//10
int ledAMARILLO=11;//11
int botonAZUL=12;//12
int botonVERDE=13;//13
int botonROJO=14;//14
int botonAMARILLO=15;//15
int ledSTART=23;
int ledplayer1=20;
int ledplayer2=21;
//int vectoruser[30]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int aleatorio[30]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int botonDificultad=19;
int pinslave=7;
//int ruido=0;
int seleccionaplayer()
{
ejecutada
int time=time1;
{
{
delay(500);
{
dif++;
{
digitalWrite(ledplayer2,LOW);
aux=1;
}
{
22
dif=0;
aux=2;
}
}
}
time=(int)millis();
}
return(aux);
}
int seleccionadificultad()
{
int time1=(int)(millis());//variable milisegundos tiempo de la aplicacin ejecutada
int time=time1;
{
{
delay(500);
{
dif++;
{
aux=1;
}
if(dif==2)//difucltad media, se avanza de dos en dos.
{
aux=2;
}
{
dif=0;
aux=3;
}
}
}
time=(int)millis();
}
return(aux);
}
{
int n;
int vectoruser[30];
if(error==1)
{
for(n=0;n<3;n++)
{
23
delay(200);
delay(200);
}
}
return(error);
}
void apagarLEDS()
{
digitalWrite(ledROJO,LOW),
}
void leeentrada(int vectoruser[],int turnos)
{
int i;
for ( i=0;i<turnos;i++)
{
if( digitalRead(botonAZUL)==HIGH )
{
delay(50);
if(digitalRead(botonAZUL)==LOW)
{
vectoruser[i]=8;
continue;
}
}
if( digitalRead(botonVERDE)==HIGH )
{
delay(50);
if(digitalRead(botonVERDE)==LOW)
{
vectoruser[i]=9;
continue;
}
}
if( digitalRead(botonROJO)==HIGH )
{
delay(50);
if(digitalRead(botonROJO)==LOW)
{
vectoruser[i]=10;
continue;
}
}
if( digitalRead(botonAMARILLO)==HIGH )
{
delay(50);
if(digitalRead(botonAMARILLO)==LOW)
{
vectoruser[i]=11;
continue;
}
}
i--;
}
}
void muestravector(int vector[],int turnos)
{
24
int i;
for(i=0;i<turnos;i++)
{
digitalWrite(vector[i],HIGH);
delay(500);
digitalWrite(vector[i],LOW);
delay(500);
}
}
int comparavector(int vector_random[], int vector_user[], int turnos)
{
int n;
int a=0;
for(n=0;n<turnos;n++)
{
if(vector_random[n]!=vector_user[n])
a=1;
}
return a;
}
void segmentos_off()//funcion q apaga el 7segmentos
{
for(int i=0; i<8; i++)
{
digitalWrite(i, HIGH);
}
}
void segmentos_on(int number)//funcion para el 7segmentos
{
if(number==0)
{
}
if(number==1)
{
}
if(number==2)
{
}
if(number==3)
{
}
if(number==4)
{
25
}
if(number==5)
{
}
if(number==6)
{
}
if(number==7)
{
}
if(number==8)
{
}
if(number==9)
{
}
delay(1000); // waits for 1000 milli seconds
//number = number + 1; // increments the variable to show
if(number > 9) { // check for the range, if greater then 9 goes back to 0s
number = 0;
}
}
void setup()
{
Serial.begin(9600);
Serial1.begin(9600);
pinMode(ledAZUL,OUTPUT);
pinMode(ledVERDE,OUTPUT);
pinMode(ledROJO,OUTPUT);
pinMode(ledAMARILLO,OUTPUT);
pinMode(botonAZUL,INPUT);
pinMode(botonVERDE,INPUT);
pinMode(botonROJO,INPUT);
pinMode(botonAMARILLO,INPUT);
pinMode(botonDificultad,INPUT);
pinMode(ledSTART,OUTPUT);
26
//pinMode(ruido,OUTPUT);
pinMode(pinslave,INPUT);
Wire.begin();
}
void loop()
{
int i=0;
int n=0;
int aux=0;
int a;
int sound;
digitalWrite(ledSTART,HIGH);
//int prueva[10]={8,9,10,11,8,9,10,11,8,8};
player=seleccionaplayer();
Serial.println(player);
for(i=0;i<30;i++)
{
}
if (player==1)
{
for(i=0;i<30;i++)
{
}
for(turnos=1;turnos<10;turnos++)
{
if (aux==1)
turnos=1;
}
}
if(player==2)
{
int error=0;
Wire.beginTransmission(2);
for(i=0;i<30;i++)
{
Wire.send(aleatorio[i]);
}
Wire.endTransmission();
while(turnos<10)
{
if(aviso==0)
{
error=hazturno(turnos*dificultad,aleatorio,error);
Wire.requestFrom(2,2);
error=Wire.receive();
aviso=1;
turnos=turnos+2;
}
else
{
if(digitalRead(pinslave)==HIGH)
aviso=0;
}
//delay(3000*turnos*dificultad);
}
}
}
Fig. 18 Codigo completo placa wiring maestro.
27

Simon Dice

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Simon Dice

Diunggah oleh

Hak Cipta:

Format Tersedia

Proyecto Simn:

DISEO SISTEMAS MVILES Y EMPOTRADOS

FIG. 1 Esquema pulsador

FIG. 2 Vista area del prototipo

Fig. 3 Vista area del prototipo versin 2.

Fig. 4 Esquema electrnico pulsador.

Fig. 5 Esquema electrnico pulsador individual.

Fig. 6 Esquema electrnico leds boton.

El resultado final se puede observar en la siguiente imagen (ver FIG. 7) :

Fig. 7 Fotografa pulsador final.

Fig. 8 Fotografa montage botones.

La placa Wiring esta adaptada a este microcontrolador mediante un esquema

Fig. 10 Placa Wiring.

43 Pines digitales I/O.

El entorno de programacin consiste en un software de libre descarga y diseado para

Fig. 11 Entorno de programacin wiring.

4.1. Funcionamiento del programa

4.2. Modo 1 player

elegir player 1. Segundo generamos el vector int aleatorio*30+ y mediante la funcin

4.3. Modo 2 player

En un primera versin se intento el puerto serie descrito en la FIG. 14 pero no fue

y el segundo 2 indica el tamao en bytes que esperamos recibir. En el cdigo esclavo

Precio dos simon

Tabla 1 Presupuesto proyecto.

El coste total para realizar un simon es de 23.28 y el doble 47.7 en el caso de

Como conclusin destacar que es un proyecto para realizar en grupo de cuatro

7. Anexo cdigo placa esclavo

while(time<time1+10000)//10 segundos para elegir modo de dificultad.

8. Anexo cdigo placa maestro

Anda mungkin juga menyukai