{"id":6483,"date":"2023-05-05T14:08:11","date_gmt":"2023-05-05T12:08:11","guid":{"rendered":"https:\/\/blogs.etsii.urjc.es\/dseytr\/?p=6483"},"modified":"2023-05-05T17:51:47","modified_gmt":"2023-05-05T15:51:47","slug":"snake-io","status":"publish","type":"post","link":"https:\/\/blogs.etsii.urjc.es\/dseytr\/snake-io\/","title":{"rendered":"Snake.io"},"content":{"rendered":"\n

Autores<\/strong>: Juan Carlos Moreno Garc\u00eda, Jhostin Davis Ortiz Moreno y Alessandro Nuzzi Herrero<\/p>\n\n\n\n

Grupo 7 \/ 2022-2023<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Introducci\u00f3n<\/strong><\/h2>\n\n\n\n

El juego de la serpiente, o mejor conocido como Snake Game<\/em>, es considerado un cl\u00e1sico desde su lanzamiento a mediados de la \u00e9poca de los 70s.<\/p>\n\n\n\n

Si bien es cierto que a d\u00eda de hoy es un juego muy simple y para algunos un poco m\u00e1s de lo que gustar\u00eda, muchos juegos interesantes han surgido a ra\u00edz de \u00e9l, entre ellos el conocido slither.io<\/em>.<\/p>\n\n\n\n

Originalmente, pensamos en recrear el juego original y llevarlo a un sistema empotrado, pero en vista de que se convert\u00eda en un proyecto un tanto simple, decidimos a\u00f1adir nuevas funcionalidades. Nuestro proyecto se basa fuertemente en estas ideas y trata de llevar a una m\u00e1quina f\u00edsica lo que vemos como mero software en dispositivos m\u00f3viles y de sobremesa.<\/p>\n\n\n\n

Es por eso \u00faltimo que nuestra m\u00e1quina ofrece una experiencia \u00fanica, fruto de una idea que lleva con nosotros mucho tiempo pero con un toque m\u00e1s moderno y competitivo, el juego snake.io<\/em> para dos jugadores.<\/p>\n\n\n\n

Para poder crear este juego, hemos necesitado componentes variados: matriz de LED RGB, joysticks anal\u00f3gicos, lector de tarjetas SD y altavoces, entre los componentes m\u00e1s destacados.<\/p>\n\n\n\n

A continuaci\u00f3n, se explicar\u00e1n m\u00e1s detenidamente las diferentes partes que juntas componen la totalidad del proyecto, pasando por los componentes hardware utilizados, el software que controla toda la l\u00f3gica del juego y todos los problemas que hemos afrontado, con nuestra forma de solucionarlos. A\u00f1adiremos tambi\u00e9n un apartado explicando las ideas a mejorar que nos han ido surgiendo por el camino y que finalmente no se han implementado, pero que en un futuro podr\u00edan ser factibles.<\/p>\n\n\n\n

Desarrollo e Implementaci\u00f3n<\/strong><\/h2>\n\n\n\n

Para desarrollar la totalidad del proyecto, decidimos abordarlo de manera incremental, realizando peque\u00f1os avances, a\u00f1adiendo funcionalidades, probando y estudiando el comportamiento de cada uno de los diferentes componentes por separado\u2026hasta conseguir una versi\u00f3n final completamente funcional. <\/p>\n\n\n\n

Los pasos seguidos para implementar el juego han sido los siguientes::<\/p>\n\n\n\n

    \n
  • Selecci\u00f3n del hardware<\/strong>: Lo primero de todo fue decidir qu\u00e9 componentes \u00edbamos a utilizar para implementar el juego. En un principio pensamos en utilizar 4 pantallas led 8×8, pero la gesti\u00f3n de estas era muy complicada, adem\u00e1s de que ocupar\u00edan la mayor\u00eda de salidas de la placa de Arduino y solo ten\u00edan un color, por lo que no se distinguir\u00edan f\u00e1cilmente las serpientes. Por ello, finalmente optamos por utilizar una matriz led rgb de 16×16, que facilitaba mucho su uso y pod\u00edamos emplear varios colores.<\/li>\n\n\n\n
  • Detectar el movimiento del joystick<\/strong>: Una vez elegidos los componentes, el primer paso fue conectar un joystick a la placa y estudiar su funcionamiento y los valores que le\u00eda en funci\u00f3n del movimiento, para poder as\u00ed crear una funci\u00f3n que determinara la direcci\u00f3n (arriba, abajo, izquierda o derecha).<\/li>\n\n\n\n
  • Encender un led concreto<\/strong>: A continuaci\u00f3n, procedimos a estudiar el funcionamiento de la matriz led con el uso de la librer\u00eda recomendada. Fue en este punto donde nos dimos cuenta que la matriz era en realidad una tira de leds colocada de manera serpenteante, por lo que tuvimos que crear una funci\u00f3n que transformara la posici\u00f3n del led que quer\u00edamos encender dada en fila y columna, a la posici\u00f3n real del led.<\/li>\n\n\n\n
  • Mover el led encendido por la pantalla<\/strong>: Una vez sab\u00edamos c\u00f3mo encender un led concreto en la pantalla, lo siguiente fue simular que ese led se moviera por la pantalla, encendiendo el siguiente led y apagando el anterior.<\/li>\n\n\n\n
  • Mover el led en funci\u00f3n de la direcci\u00f3n del joystick<\/strong>: Acto seguido, conseguimos que el movimiento del led fuera en funci\u00f3n de la direcci\u00f3n marcada por el joystick.<\/li>\n\n\n\n
  • Mover 2 leds de manera independiente con los joystick<\/strong>: Posteriormente, a\u00f1adimos un segundo joystick y encendimos otro led, consiguiendo que estos se movieran de manera independiente por la pantalla<\/li>\n\n\n\n
  • A\u00f1adir el cuerpo de las serpientes<\/strong>: Con esto conseguido, el siguiente paso fue crear el struct<\/em> que contiene la informaci\u00f3n de las serpientes y poder almacenar as\u00ed todas las posiciones que corresponden al cuerpo de cada serpiente. Para simular su movimiento, simplemente eliminamos la \u00faltima posici\u00f3n del cuerpo de la serpiente y a\u00f1adimos la nueva en funci\u00f3n de su direcci\u00f3n. Al inicio del juego, las serpientes tendr\u00e1n un tama\u00f1o de 5 posiciones.<\/li>\n\n\n\n
  • Implementar la l\u00f3gica de ganador<\/strong>: En este punto el juego estaba casi terminado, por lo que procedimos a implementar la l\u00f3gica que indica cu\u00e1ndo un jugador ha ganado. Esto suceder\u00e1 \u00fanicamente cuando la cabeza de una de las serpientes se choque contra el cuerpo de la otra, siendo esta \u00faltima la ganadora. Mencionar que, en caso de que ambas serpientes choquen de frente, se establecer\u00e1 de manera aleatoria qui\u00e9n ha sido el ganador.<\/li>\n\n\n\n
  • A\u00f1adir la l\u00f3gica de las manzanas<\/strong>: Para finalizar la l\u00f3gica del juego, simplemente faltaba a\u00f1adir las manzanas de manera aleatoria por la pantalla y, en caso de que una serpiente pase por esa posici\u00f3n, la serpiente aumentar\u00e1 de tama\u00f1o en una unidad. Para ello, simplemente no borramos la \u00faltima posici\u00f3n de la serpiente en esa iteraci\u00f3n.<\/li>\n\n\n\n
  • A\u00f1adir m\u00fasica y sonidos<\/strong>: Una vez implementada toda la l\u00f3gica del juego, pasamos a a\u00f1adir la m\u00fasica de fondo y los sonidos de inicio, comer una manzana y fin del juego.<\/li>\n\n\n\n
  • Empaquetar todo en una caja<\/strong>: Por \u00faltimo, dise\u00f1amos una caja con dos orificios para empaquetar todo, simulando una consola port\u00e1til con dos mandos.<\/li>\n<\/ul>\n\n\n\n

    Parte Hardware<\/strong><\/h2>\n\n\n\n

    Para el desarrollo de este proyecto, hemos necesitado dos microcontroladores Arduino UNO, una matriz LED RGB de 16×16, dos altavoces compatibles con Arduino, dos joysticks, un lector de tarjetas SD y cables para realizar las conexiones.<\/p>\n\n\n\n

    Uno de los Arduino se ha utilizado para conectar los joysticks, la matriz LED y un altavoz. La funci\u00f3n de este microcontrolador era principalmente gestionar todo aquello relacionado con el juego, as\u00ed como los sonidos asociados a este.<\/p>\n\n\n\n

    \"\"
    Dise\u00f1o hardware microcontrolador principal simulado en TinkerCad<\/em><\/figcaption><\/figure>\n\n\n\n

    Por otro lado, el otro microcontrolador Arduino se ha utilizado para gestionar la m\u00fasica de fondo del juego. Se ha conectado el lector de tarjetas SD y uno de los dos altavoces. De esta manera, reproduce el archivo de m\u00fasica que tenga almacenado la tarjeta SD en el altavoz.<\/p>\n\n\n\n

    \"\"
    Dise\u00f1o hardware microcontrolador de m\u00fasica simulado en TinkerCad<\/em><\/figcaption><\/figure>\n\n\n\n

    Idealmente, se podr\u00eda haber hecho el mismo proyecto con un \u00fanico microcontrolador que incluyese cierto grado de concurrencia y permitiese la reproducci\u00f3n de m\u00fasica en paralelo al control del juego.<\/p>\n\n\n\n

    Por \u00faltimo, mencionar que ambos microcontroladores son alimentados con pilas de 9V.<\/p>\n\n\n\n

    \"\"
    Implementaci\u00f3n final<\/em><\/figcaption><\/figure>\n\n\n\n

    Materiales, costes y precios<\/strong><\/h2>\n\n\n\n

    A continuaci\u00f3n se muestra una tabla con los materiales y componentes utilizados para la realizaci\u00f3n del proyecto, as\u00ed como su precio y el coste real que ha tenido sobre nosotros:<\/p>\n\n\n\n

    Nombre<\/strong><\/td>Coste<\/strong><\/td>Precio<\/strong><\/td><\/tr>
    M\u00f3dulo Lector SD<\/td>5,49 \u20ac<\/td>5,49 \u20ac<\/td><\/tr>
    2 Altavoces 3W<\/td>9,99 \u20ac<\/td>9,99 \u20ac<\/td><\/tr>
    2 Pilas 9V<\/td>3,18 \u20ac<\/td>3,18 \u20ac<\/td><\/tr>
    Matriz LED RGB 16×16<\/td>20,00 \u20ac<\/td>28,99 \u20ac<\/td><\/tr>
    2 Arduino Uno<\/td>–<\/td>20-30 \u20ac<\/td><\/tr>
    1 Protoboard<\/td>–<\/td>4,79 \u20ac<\/td><\/tr>
    1 Mini-Protoboard<\/td>–<\/td>2,33 \u20ac<\/td><\/tr>
    2 Joystick<\/td>–<\/td>10 \u20ac<\/td><\/tr>
    Cables<\/td>–<\/td>5 \u20ac<\/td><\/tr>
    Pegamento<\/td>–<\/td>6,29 \u20ac<\/td><\/tr>
    Pintura madera<\/td>–<\/td>4 \u20ac<\/td><\/tr>
    Madera<\/td>–<\/td>10 \u20ac<\/td><\/tr>
    Imanes<\/td>–<\/td>7,32 \u20ac<\/td><\/tr>
    Total<\/strong><\/td>38,66 \u20ac<\/td>147,38 \u20ac<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

    Parte Software<\/strong><\/h2>\n\n\n\n

    En cuanto al software del proyecto, mencionar que el c\u00f3digo est\u00e1 modularizado en peque\u00f1as funciones, evitando el c\u00f3digo repetido y favoreciendo la reutilizaci\u00f3n de c\u00f3digo, y est\u00e1 dise\u00f1ado para poder ser escalable. Esto es posible gracias a la creaci\u00f3n de un struct<\/em> llamado snake_t <\/em>que contiene toda la informaci\u00f3n necesaria de cada serpiente, como son su identificador, la posici\u00f3n de la cabeza, las posiciones del cuerpo, su color, el joystick asociado, la direcci\u00f3n, etc. Adem\u00e1s, contamos un con array de snakes, una por cada jugador (en este caso 2) y las funciones se encargan de recorrer este array, por lo que, en caso de aumentar el n\u00famero de jugadores, no ser\u00eda necesario modificar el c\u00f3digo.<\/p>\n\n\n\n

    C\u00f3digo principal<\/strong><\/h3>\n\n\n\n
    #include <Adafruit_NeoPixel.h>\n#include <LinkedList.h>\n\n#ifdef __AVR__\n  #include <avr\/power.h>\n#endif\n\n\/\/ Struct that contains snake data\nstruct snake_t {\n  int id;\n  int read[2] = {512, 512}; \/\/ Joystick read value\n  int joystick[2]; \/\/ Joystick pins for X and Y axis\n  int head[2]; \/\/ Snake head position (X, Y)\n  LinkedList<int> tail = LinkedList<int>(); \/\/ Snake tail positions, including head\n  uint32_t color;\n  uint32_t headColor;\n  char direction; \/\/ Snake direction\n};\n\nconst int SIDE = 16; \/\/ Matrix side\nconst int PLAYERS = 2; \/\/ Number of players\n\n\/\/ Dictionary used to calculate the real direction of the snake, taking into account that the movement of one snake is opposite to the other\nconst char DICT[2][4] = {{'d', 'u', 'r', 'l'}, {'u', 'd', 'l', 'r'}};\n\nconst int LED_PIN = 3; \/\/ Output pin to LED matrix\nconst int SPEAKER_PIN = 9; \/\/ Output pin to speaker\n\nAdafruit_NeoPixel strip = Adafruit_NeoPixel(256, LED_PIN, NEO_GRB + NEO_KHZ800); \/\/ LED matrix object\n\n\/\/ Initial values for snakes\nconst int JOYSTICK_PINS_0[2] = {A0, A1};\nconst int JOYSTICK_PINS_1[2] = {A2, A3};\nconst int INITIAL_HEAD_POS_0[2] = {0, 0};\nconst int INITIAL_HEAD_POS_1[2] = {15, 15};\nconst int INITIAL_TAIL_0[5] = {0, 1, 2, 3, 4};\nconst int INITIAL_TAIL_1[5] = {240, 241, 242, 243, 244};\nconst uint32_t SNAKE_COLOR_0 = strip.Color(255, 0, 0);\nconst uint32_t SNAKE_COLOR_1 = strip.Color(0, 0, 255);\n\n\/\/ Numbers\nconst int RED_THREE[13] = {89, 88, 87, 86, 73, 54, 56, 55, 41, 22, 25, 24, 23};\nconst int BLUE_THREE[13] = {230, 231, 232, 233, 217, 198, 199, 200, 185, 166, 167, 168, 169};\nconst int RED_TWO[14] = {89, 88, 87, 86, 73, 57, 56, 55, 54, 38, 25, 24, 23, 22};\nconst int BLUE_TWO[14] = {230, 231, 232, 233, 214, 201, 198, 199, 200, 185, 166, 167, 168, 169};\nconst int RED_ONE[10] = {23, 40, 55, 72, 87, 24, 39, 56, 71, 88};\nconst int BLUE_ONE[10] = {168, 183, 200, 215, 232, 167, 184, 199, 216, 231};\n\n\/\/ WIN letters\nconst int RED_WIN[23] = {\n  125, 130, 157, 99, 123, 101, 121, 134, 153,      \/\/ W\n  104, 119, 136, 151,                              \/\/ I\n  106, 117, 138, 149, 139, 115, 109, 114, 141, 146 \/\/ N\n};\nconst int BLUE_WIN[23] = {\n  109, 114, 141, 147, 139, 149, 137, 118, 105,    \/\/ W\n  103, 120, 135, 152,                             \/\/ I\n  98, 125, 130, 157, 131, 123, 101, 122, 133, 154 \/\/ N\n};\n\n\/\/ Musical notes in 5 scales\nconst int C[5] = {131, 262, 523, 1046, 2093};  \/\/ Do\nconst int CS[5] = {139, 277, 554, 1108, 2217}; \/\/ Do#\nconst int D[5] = {147, 294, 587, 1175, 2349};  \/\/ Re\nconst int DS[5] = {156, 311, 622, 1244, 2489}; \/\/ Re#\nconst int E[5] = {165, 330, 659, 1319, 2637};  \/\/ Mi\nconst int F[5] = {175, 349, 698, 1397, 2794};  \/\/ Fa\nconst int FS[5] = {185, 370, 740, 1480, 2960}; \/\/ Fa#\nconst int G[5] = {196, 392, 784, 1568, 3136};  \/\/ Sol\nconst int GS[5] = {208, 415, 831, 1661, 3322}; \/\/ Sol#\nconst int A[5] = {220, 440, 880, 1760, 3520};  \/\/ La\nconst int AS[5] = {233, 466, 932, 1866, 3729}; \/\/ La#\nconst int B[5] = {247, 494, 988, 1976, 3951};  \/\/ Si\n\nsnake_t snakes[PLAYERS];\nint winner;\nint apple;\nint delayValue;\n\nvoid setup() {\n  #if defined (__AVR_ATtiny85__)\n    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);\n  #endif\n\n  randomSeed(analogRead(1));\n  strip.begin();\n  strip.setBrightness(100);\n  strip.show(); \n\n  setupInitialValues();\n}\n\nvoid setupInitialValues() {\n  setupSnake(&snakes[0], 0, JOYSTICK_PINS_0, INITIAL_HEAD_POS_0, INITIAL_TAIL_0, strip.Color(255, 0, 0), strip.Color(255, 0, 255), 'l');\n  setupSnake(&snakes[1], 1, JOYSTICK_PINS_1, INITIAL_HEAD_POS_1, INITIAL_TAIL_1, strip.Color(0, 0, 255), strip.Color(255, 0, 255), 'r');\n  delayValue = 200;\n  initialAnimation();\n  setApplePosition();\n  printApple();\n}\n\nvoid setupSnake(snake_t *snake, int id, int joystick[2], int head[2], int tail[4], uint32_t color, uint32_t headColor, char direction) {\n  snake->id = id;\n  snake->joystick[0] = joystick[0];\n  snake->joystick[1] = joystick[1];\n  snake->head[0] = head[0];\n  snake->head[1] = head[1];\n\n  for (int i = 0; i < 5; i++) {\n    snake->tail.add(tail[i]);\n  }\n\n  snake->color = color;\n  snake->headColor = headColor;\n  snake->direction = direction;\n}\n\nvoid initialAnimation() {\n  \/\/ Red 3\n  for (int i = 0; i < 13; i++) {\n    strip.setPixelColor(RED_THREE[i], SNAKE_COLOR_0);\n  }\n  \/\/ Blue 3\n  for (int i = 0; i < 13; i++) {\n    strip.setPixelColor(BLUE_THREE[i], SNAKE_COLOR_1);\n  }\n  strip.show();\n  emitSound(E[3], 100);\n  noTone(SPEAKER_PIN);\n  delay(900);\n  turnOffLeds();  \n\n  \/\/ Red 2\n  for (int i = 0; i < 14; i++) {\n    strip.setPixelColor(RED_TWO[i], SNAKE_COLOR_0);\n  }\n  \/\/ Blue 2\n  for (int i = 0; i < 14; i++) {\n    strip.setPixelColor(BLUE_TWO[i], SNAKE_COLOR_1);\n  }\n  strip.show();\n  emitSound(E[3], 100);\n  noTone(SPEAKER_PIN);\n  delay(900);\n  turnOffLeds(); \n\n  \/\/ Red 1\n  for (int i = 0; i < 10; i++) {\n    strip.setPixelColor(RED_ONE[i], SNAKE_COLOR_0);\n  }\n  \/\/ Blue 1\n  for (int i = 0; i < 10; i++) {\n    strip.setPixelColor(BLUE_ONE[i], SNAKE_COLOR_1);\n  }\n  strip.show();\n  emitSound(E[3], 100);\n  noTone(SPEAKER_PIN);\n  delay(900);\n  turnOffLeds(); \n\n  emitSound(C[4], 500);\n  noTone(SPEAKER_PIN);\n}\n\nvoid loop() {\n  winner = isEndGame();\n\n  if (winner == -1)\n    mainGame();\n  else {\n    endGameScreen();\n  }\n}\n\nvoid mainGame() {\n  for (int i = 0; i < PLAYERS; i++) {\n    getMovement(&snakes[i]);\n    moveSnake(&snakes[i]);\n  }\n  \n  \/\/ As time passes, snakes move faster\n  if (delayValue > 0)\n    delay(delayValue--);\n}\n\nvoid getMovement(snake_t *snake) {\n  snake->read[0] = analogRead(snake->joystick[0]);\n  delay(100);                 \n  snake->read[1] = analogRead(snake->joystick[1]);\n\n  if (snake->read[0] >= 900) {\n    snake->direction = DICT[snake->id][0];\n  } else if (snake->read[0] < 200) {\n    snake->direction = DICT[snake->id][1];\n  } else if (snake->read[1] < 200) {\n    snake->direction = DICT[snake->id][2];\n  } else if (snake->read[1] >= 900) {\n    snake->direction = DICT[snake->id][3];\n  } \n}\n\nvoid moveSnake(snake_t *snake) {\n  if (!eatenApple(snake)) {\n    int pos = snake->tail.pop();\n    strip.setPixelColor(pos, strip.Color(0, 0, 0));\n    strip.show();\n  } else {\n    emitSound(E[3], delayValue \/ 10);\n    noTone(SPEAKER_PIN);\n    setApplePosition();\n    printApple();\n  }\n\n  nextRow(snake);\n  nextColumn(snake);\n  snake->tail.add(0, transform(snake->head[0], snake->head[1]));\n\n  for (int i = 1; i < snake->tail.size(); i++) {\n    strip.setPixelColor(snake->tail.get(i), snake->color);\n  }\n\n  strip.setPixelColor(snake->tail.get(0), snake->headColor);\n  strip.show();\n}\n\nvoid nextRow(snake_t *snake) {\n  switch (snake->direction) {\n    case 'u':\n      snake->head[0] += 1;\n      break;\n    case 'd':\n      snake->head[0] -= 1;\n      break;\n  }\n\n  if (snake->head[0] < 0)  \n    snake->head[0] = SIDE - 1;\n  \n  snake->head[0] = snake->head[0] % SIDE;\n}\n\nvoid nextColumn(snake_t *snake) {\n  switch (snake->direction) {\n    case 'r': \n      snake->head[1] += 1;\n      break;\n    case 'l':\n      snake->head[1] -= 1;\n      break;\n  }\n\n  if (snake->head[1] < 0)  \n    snake->head[1] = SIDE - 1;\n  \n  snake->head[1] = snake->head[1] % SIDE;\n}\n\n\/\/ Transform matrix position given in row and column to the actual matrix position\nint transform(int row, int column) {\n  if (row % 2 == 1)\n    return row * SIDE + SIDE - (column + 1);\n  \n  return row*SIDE + column;\n}\n\nvoid setApplePosition() {\n  apple = transform(random(SIDE), random(SIDE));\n\n  for (int i = 0; i < PLAYERS; i++) {\n    for (int j = 0; j < snakes[i].tail.size(); j++) {\n      if (apple == snakes[i].tail.get(j))\n        setApplePosition();\n    }\n  }\n}\n\nvoid printApple() {\n  strip.setPixelColor(apple, strip.Color(255, 255, 0));\n}\n\nbool eatenApple(snake_t *snake) {\n  return snake->tail.get(0) == apple;\n}\n\nint isEndGame() {\n  int randValue = random(2);\n\n  if (randValue == 0) {\n    if (checkWinner(&snakes[0], &snakes[1]))\n      return 0;\n    if (checkWinner(&snakes[1], &snakes[0]))\n      return 1;\n  } else {\n    if (checkWinner(&snakes[1], &snakes[0]))\n      return 1;\n    if (checkWinner(&snakes[0], &snakes[1]))\n      return 0;\n  }\n\n  return -1;\n}\n\n\/\/ Check if snake_l head (looser) is in snake_w tail (winner)  \nbool checkWinner(snake_t *snake_w, snake_t *snake_l) {\n  for (int i = 0; i < snake_w->tail.size(); i++) {\n    if (snake_l->tail.get(0) == snake_w->tail.get(i)){\n      return true;\n    }\n  }\n\n  return false;\n}\n\nvoid endGameScreen() {\n  playEndSong();\n  winnerScreen(snakes[winner].color);\n  resetGame();\n}\n\nvoid playEndSong() {\n  emitSound(G[2], 500); noTone(SPEAKER_PIN); delay(100);\n  emitSound(G[2], 500); noTone(SPEAKER_PIN); delay(100);\n  emitSound(G[2], 500); noTone(SPEAKER_PIN); delay(100);\n  emitSound(DS[2], 500); noTone(SPEAKER_PIN); delay(1);\n  emitSound(AS[2], 125); noTone(SPEAKER_PIN); delay(25);\n  emitSound(G[2], 500); noTone(SPEAKER_PIN); delay(100);\n  emitSound(DS[2], 500); noTone(SPEAKER_PIN); delay(1);\n  emitSound(AS[2], 125); noTone(SPEAKER_PIN); delay(25);\n  emitSound(G[2], 500); noTone(SPEAKER_PIN);\n}\n\nvoid emitSound(int frec, int t) {\n  tone(SPEAKER_PIN, frec);      \n  delay(t);                \n}\n\nvoid winnerScreen(uint32_t color) {\n  winnerAnimation(color);\n  turnOffLeds();\n\n  for (int i = 0; i < 5; i++) {\n    writeWin(color);\n    delay(500);\n    turnOffLeds();\n    delay(500);\n  }\n}\n\n\/\/ Color the full LED matrix the winner snake color\nvoid winnerAnimation(uint32_t color) {\n  for (int i = 0; i < 512; i++) {\n    strip.setPixelColor(random(256), color);\n    strip.show();\n  }\n}\n\nvoid writeWin(uint32_t color) {\n  for (int i = 0; i < 23; i++) {\n    if ((winner % 2) == 0)\n      strip.setPixelColor(RED_WIN[i], color);\n    else\n      strip.setPixelColor(BLUE_WIN[i], color);\n  }\n\n  strip.show();\n}\n\nvoid turnOffLeds() {\n  for (int i = 0; i < strip.numPixels(); i++) {\n    strip.setPixelColor(i, strip.Color(0, 0, 0));   \n  }\n\n  strip.show();\n}\n\nvoid resetGame() {\n  for (int i = 0; i < PLAYERS; i++) {\n    snakes[i].tail.clear();\n  }\n\n  setupInitialValues();\n}<\/code><\/pre>\n\n\n\n
    C\u00f3digo de control de la m\u00fasica<\/strong><\/h3>\n\n\n\n
    #include <SimpleSDAudio.h>\n\nconst int SD_PIN = 10 \/\/ SD card cs pin\n\nvoid setup() {\n  SdPlay.setSDCSPin(SD_PIN); \n\n  if (!SdPlay.init(SSDA_MODE_FULLRATE | SSDA_MODE_MONO | SSDA_MODE_AUTOWORKER)) {\n    while (1); \n  }\n  \n  if (!SdPlay.setFile(\"ms.wav\")) { \n    while (1);\n  }\n}\n\nvoid loop(void){\n  SdPlay.play(); \/\/ Play music\n\n  while (!SdPlay.isStopped())  {\n    delay(100);\n  }\n}<\/code><\/pre>\n\n\n\n
    Casos de uso<\/strong><\/h2>\n\n\n\n
    Hablaremos ahora sobre los diferentes casos de uso que tiene el juego:<\/p>\n\n\n\n
      \n
    • Jugar partida<\/strong>: El jugador podr\u00e1 conectar las dos placas a una fuente de alimentaci\u00f3n, como pueden ser pilas de 9V, para empezar una partida y usar cualquiera de los dos joysticks disponibles para controlar a la serpiente roja o a la azul mediante movimientos horizontales y verticales. Al principio aparecer\u00e1 una cuenta atr\u00e1s de 3 segundos y, acto seguido, las serpientes empezar\u00e1n a moverse. La trayectoria original de ambas serpientes est\u00e1 establecida de tal manera que no sea posible chocar una con la otra hasta que alguno de los jugadores realice un movimiento, para evitar as\u00ed una muerte indeseada. Tambi\u00e9n cabe mencionar que existen l\u00edmites de pantalla, es decir, en caso de sobrepasar un borde de la pantalla, la serpiente aparecer\u00e1 por el lado contrario. Adem\u00e1s, a diferencia del juego original, las serpientes s\u00ed pueden pasar sobre su propio cuerpo sin morir.<\/li>\n\n\n\n
    • Comer manzana<\/strong>: El jugador podr\u00e1 moverse hasta el LED iluminado de color amarillo para comerse la manzana y que el cuerpo de su serpiente aumente en una unidad.<\/li>\n\n\n\n
    • Incremento de la velocidad<\/strong>: Las serpientes empiezan movi\u00e9ndose a una velocidad normal. Sin embargo, conforme va pasando el tiempo, estas van a empezar a moverse cada vez m\u00e1s r\u00e1pido, hasta alcanzar la m\u00e1xima velocidad.<\/li>\n\n\n\n
    • Chocar con oponente<\/strong>: Si el jugador es lo suficientemente habilidoso, podr\u00e1 conseguir que el oponente choque con su cuerpo y as\u00ed ganar la partida, mostrando la animaci\u00f3n de victoria con el color de la serpiente del ganador y  empezar despu\u00e9s una nueva partida.<\/li>\n\n\n\n
    • Reiniciar partida<\/strong>: Los jugadores podr\u00e1n reiniciar en cualquier momento la partida pulsando el bot\u00f3n de reinicio de la propia placa de Arduino.<\/li>\n<\/ul>\n\n\n\n
      Problemas y soluciones encontradas<\/strong><\/h2>\n\n\n\n
      De cara a los problemas que nos hemos encontrado a lo largo del desarrollo del proyecto, citamos a continuaci\u00f3n los m\u00e1s significativos y la forma de lidiar que hemos tenido con ellos:<\/p>\n\n\n\n
        \n
      • Encontrar una matriz 16×16 LED<\/strong>: Al principio del proyecto nos fue sumamente complicado dar con una matriz que cumpliera todos los requisitos necesarios. Empezamos a buscar por grandes distribuidoras como pueden ser Amazon o AliExpress, llegando a desistir de este camino por superar el presupuesto o por el hecho de que el componente no llegar\u00eda a tiempo. Finalmente, conseguimos un buen componente a un precio asequible en el mercado de segunda mano online a trav\u00e9s de un vendedor de Wallapop.<\/li>\n\n\n\n
      • Cable de la matriz LED<\/strong>: A la hora de integrar de manera aislada la matriz LED a la placa Arduino, la matriz no dio ning\u00fan tipo de problema. Sin embargo, al integrar la pantalla con el resto de componentes y pegarla a la l\u00e1mina de contrachapado, esta empez\u00f3 a dar problemas debido a que los contactos de voltaje y tierra se ensuciaban e imped\u00edan el correcto uso de la placa. Esto nos provoc\u00f3 retrasos en el desarrollo e incluso nos llev\u00f3 a pensar en la rotura de una de las placas Arduino Uno.<\/li>\n\n\n\n
      • Ejecuci\u00f3n en paralelo de la m\u00fasica<\/strong>: Una vez hecha la l\u00f3gica del juego y probada de manera que se mostraba robusta, tratamos de integrar la m\u00fasica le\u00edda desde una tarjeta SD conectada a la placa Arduino mediante un m\u00f3dulo lector de SD. El problema llegaba en que la m\u00fasica ten\u00eda que reproducirse continuamente y sin interferir en la experiencia de juego. Al no existir la ejecuci\u00f3n en paralelo en Arduino Uno, acabamos desarrollando finalmente dos c\u00f3digos, uno encargado de la l\u00f3gica de juego general y otro dedicado al propio m\u00f3dulo lector de tarjetas SD, cada uno de estos cargado a una placa Arduino, siendo este el principal motivo por el cual necesitamos de una placa Arduino adicional.<\/li>\n\n\n\n
      • Uso de librer\u00edas<\/strong>: Al principio nos fue dif\u00edcil recurrir a una implementaci\u00f3n de la l\u00f3gica de juego y del control de componentes sin el uso de librer\u00edas, siendo esta la raz\u00f3n por la que hemos importado una serie de librer\u00edas que nos ayudan a gestionar de forma m\u00e1s sencilla, r\u00e1pida y eficiente el uso de los componentes en el propio c\u00f3digo.<\/li>\n<\/ul>\n\n\n\n
        Mejoras a futuro del proyecto<\/strong><\/h2>\n\n\n\n
        Mencionaremos ahora las mejoras a incluir en un futuro que hemos pensado que mejorar\u00edan la experiencia general de nuestro proyecto y que finalmente por diversos motivos, entre los que se encuentra la falta de tiempo, no han sido implementadas:<\/p>\n\n\n\n
          \n
        • A\u00f1adir m\u00e1s jugadores<\/strong>: Nuestro c\u00f3digo est\u00e1 pensado para ser f\u00e1cilmente escalable de tal forma que ser\u00eda posible que m\u00e1s jugadores se unieran a la misma partida sin problemas. Bastar\u00eda simplemente con a\u00f1adir el hardware necesario (un joystick por cada nuevo jugador), teniendo en cuenta el l\u00edmite de entradas anal\u00f3gicas de Arduino, que en el caso de alcanzarse, ser\u00eda necesario incluir un multiplexor para permitir a\u00f1adir m\u00e1s entradas. Con respecto al software, solo har\u00eda falta incluir una nueva serpiente al inicializar el juego y modificar la funci\u00f3n de condici\u00f3n de final de juego.<\/li>\n\n\n\n
        • Interruptor<\/strong>: Podr\u00eda ser interesante utilizar un interruptor que controle las pilas de ambas placas Arduino, dado que actualmente el juego se inicia nada m\u00e1s recibir voltaje.<\/li>\n\n\n\n
        • Mejorar la estructura del artefacto<\/strong>: Si bien es verdad que la m\u00e1quina es compacta, ser\u00eda conveniente reforzar la estructura de contrachapado de la que est\u00e1 fabricada y los cables que la componen internamente para evitar cualquier comportamiento no deseado.<\/li>\n\n\n\n
        • Mejorar conexiones<\/strong>: A pesar de que la gesti\u00f3n del cableado es correcta, convendr\u00eda un refuerzo de estos para evitar que no se desconecte ninguno y el proyecto no funcione como debiera.<\/li>\n\n\n\n
        • Mandos m\u00e1s c\u00f3modos<\/strong>: A pesar de que los mandos que ofrecemos en el modelo actual se prestan a ser c\u00f3modos y no desconcentrar de la propia partida, podr\u00edan haberse fabricado con un dise\u00f1o m\u00e1s amigable al usuario.<\/li>\n\n\n\n
        • Mejor sonido<\/strong>: Aunque la calidad de sonido actualmente es decente, convendr\u00eda mejorarla de cara al futuro, debido a que, por limitaciones de la librer\u00eda usada, el control de volumen transmitido por los altavoces es fijo y no se puede subir ni bajar. Adem\u00e1s, la calidad de sonido queda condicionada por los 8 bits de la propia placa Arduino y el formato .WAV soportado por ambas librer\u00edas y la placa.<\/li>\n\n\n\n
        • Microcontrolador m\u00e1s apropiado para ejecuci\u00f3n de tareas en paralelo<\/strong>: Ser\u00eda posible tratar de conseguir un microcontrolador m\u00e1s potente que reemplazase las dos placas Arduino actualmente utilizadas por el dispositivo, al poder este soportar operaciones ejecutadas en paralelo a trav\u00e9s del propio hardware, dado que es tediosa e ineficiente la propia implementaci\u00f3n de esto en Arduino (simulado por software). <\/li>\n\n\n\n
        • A\u00f1adir sonidos y mejorar la reproducci\u00f3n de los actuales<\/strong>: En relaci\u00f3n con el punto anterior, al conseguir la ejecuci\u00f3n de tareas en paralelo, se podr\u00eda conseguir un mejor comportamiento del sonido y la m\u00fasica del juego, pudiendo controlar cu\u00e1ndo reproducir y parar la melod\u00eda principal del juego, adem\u00e1s de a\u00f1adir m\u00e1s sonidos.<\/li>\n\n\n\n
        • Mando inal\u00e1mbrico con tel\u00e9fono m\u00f3vil<\/strong>: De cara a futuras iteraciones del proyecto, ser\u00eda posible utilizar un m\u00f3dulo de conexi\u00f3n inal\u00e1mbrica a la placa Arduino que permitiera el uso de un tel\u00e9fono m\u00f3vil como mando para jugar a snake.io<\/em>.<\/li>\n<\/ul>\n\n\n\n
          V\u00eddeo explicativo del proyecto<\/strong><\/h2>\n\n\n\n
          \n