Codimor, Traductor código morse grupo 17
Introducción
Para la realización de este proyecto teníamos a nuestra disposición el uso de un Arduino 1 además de los materiales incluidos en el kit prestado por el profesor y alguno más que quisiéramos incluir por nuestra cuenta.
Teniendo en cuenta lo anteriormente mencionado hemos decidido realizar un traductor de lenguaje natural a código morse, al que decidimos llamar CODIMOR.
Para realizar este traductor hemos hecho uso de distintos componentes que se detallarán más adelante, además del Arduino ide para introducirle un código que también explicaremos a continuación.
Funcionamiento
Para iniciar Codimor, tendremos que presionar el botón de encendido, y una vez hecho, veremos las 3 opciones con las que cuenta, pudiendo ver debajo de cada una las opciones de ir a la siguiente presionando “>” o a la anterior presionando “<”, además obviamente la opción de seleccionar esa opción. Las 3 opciones disponibles son:
1- Traducir de lenguaje natural a código morse con luz: Esta opción nos dará la posibilidad de introducir a través del teclado matricial 4×4 personalizado el texto que queramos traducir en lenguaje natural, al presionar el botón “enter” podremos ver cómo se iluminan los leds de la parte posterior de CODIMOR mostrando el mensaje introducido en código morse.
2- Traducir de lenguaje natural a código morse con sonido: En esta opción todo funciona igual que en la opción anterior solo que esta vez el código morse se presenta a través del sonido del buzzer colocado en la parte posterior de nuestro artefacto.
3- Traducir de lenguaje natural a código morse con luz y sonido: Por útimo en esta última opción el mensaje introducido a través de lenguaje natural es presentado en código morse mediante la combinación de luz y sonido simultáneamente.
Material utilizado:
En cuanto al material utilizado tenemos los siguientes:
Pantalla lcd 20×4 + adaptador I2c: Hemos usado esta pantalla que venía soldada al adaptador I2c para que fuese más fácil la manipulación de los cables, además su tamaño superior a la 16×2 permite mostrar mayor número de caracteres, en ella se muestra todo lo que puede hacer CODIMOR.
Precio: 8.99 euros.
Teclado matricial 4×4: Es el teclado utilizado para introducir el texto y seleccionar las opciones, lo hemos personalizado para que tuviera los botones que necesitábamos además de plastificarlo.
Costo: 2 euros.
PowerBank: Hemos comprado una PowerBank que funciona como pila de nuestro proyecto, con una salida de 2.1 Amperios que garantiza la cantidad suficiente de energía que necesita nuestro proyecto para funcionar correctamente además de poder cargarla si se acaba la batería.
Coste: 13 euros.
Buzzer: Venía incluido en el kit y funciona como salida en forma de sonido para el código morse.
Leds: Venían incluidas en el kit y funcionan como salida en forma de luz para el código morse.
Cables: Los hemos comprado y pelado para realizar las conexiones
Coste: 6.20 euros
Pegamento: Los hemos usado para pegar los elementos que lo necesitaban.
Coste: 1.20 euros
Caja: La hemos cortado y lijado para poder usarla como recipiente de nuestros componentes.
Coste total: 31.40 euros
Pasos realizados:
Implementación de la pantalla lcd 20×4 y del adaptador i2c:
En esta parte tuvimos algunos problemas, debido a que la primera pantalla que compramos con el código i2c no funcionaba correctamente, yendo a las clases prácticas y después de probar varios métodos para comprobar el funcionamiento de la pantalla, nos dimos cuenta de que ninguno funcionaba, nuestra pantalla en lugar mostrar caracteres alfanuméricos mostraba cuadrados negros. Con la ayuda del profesor nos percatamos de que el problema estaba en los pines que unían el adaptador i2c a la pantalla, los cuales no hacían suficiente contacto en todas las superficies como para permitir que la pantalla funcionase correctamente, así que el camino a seguir estaba claro, había que soldar la pantalla. Con la ayuda de un familiar con los materiales necesarios para la soldadura con estaño, nos aventuramos a hacerlo con nuestra pantalla y el adaptador i2c; pensando que finalmente habíamos conseguido nuestro cometido, probamos nuevamente nuestra pantalla, encontrándonos con la sorpresa que el resultado no fue el esperado. Nuestra pantalla seguía viéndose igual, y el problema persistía.
Acabamos dando con la solución al pedir una pantalla igual solo que soldada.
Probamos la pantalla con este código básico:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Dirección I2C del LCD, columnas y filas
LiquidCrystal_I2C lcd(0x27, 20, 4); // Dirección, columnas, filas
void setup() {
lcd.init(); // Inicializa la pantalla
lcd.backlight(); // Enciende la luz de fondo
// Escribe en distintas líneas
lcd.setCursor(0, 0);
lcd.print(«LCD I2C 20×4»);
lcd.setCursor(0, 1);
lcd.print(«Linea 2 OK»);
lcd.setCursor(0, 2);
lcd.print(«Linea 3 OK»);
lcd.setCursor(0, 3);
lcd.print(«Linea 4 OK»);
}
void loop() {
// Nada aquí, solo muestra el texto
}
Con el problema de la pantalla resuelto, nos aventuramos al siguiente paso, implementar el teclado.
Implementación de teclado matricial 4×4:
En este paso decidimos personalizar nuestro teclado al ver que necesitábamos teclas especiales como “>” o “<” para cambiar de opciones, o moverse entre las letras y demás, así que lo personalizamos manualmente añadiéndole pegatinas a las letras poniendo lo que queramos que pongan y pintándolas por encima. También vale la pena decir que como es un teclado matricial 4×4 y hay botones que usamos para seleccionar encender apagar menú… no teníamos lógicamente espacio para poner en cada botón una letra del alfabeto, por lo que decidimos implementar un sistema que muchos recordarán, similar al de los primeros teléfonos móviles, en el cual cada botón está asociado a 3 letras diferentes dependiendo de cuántas veces es pulsado en corto lapso de tiempo, por ejemplo, nuestro primer botón corresponde a la letra A al ser pulsado una vez, B al ser pulsado 2 veces y C al ser pulsado 3 veces.
Después de tener el teclado solo teníamos que implementar el código que convirtiera los botones del teclado en los que nosotros queríamos, además de convertir las letras introducidas y otros caracteres del lenguaje como las comas y demás en código morse, lo cual hicimos a través de la siguiente función:
String obtenerMorse(char letra) {
switch (letra) {
case ‘A’: return «.-«; case ‘B’: return «-…»; case ‘C’: return «-.-.»;
case ‘D’: return «-..»; case ‘E’: return «.»; case ‘F’: return «..-.»;
case ‘G’: return «–.»; case ‘H’: return «….»; case ‘I’: return «..»;
case ‘J’: return «.—«; case ‘K’: return «-.-«; case ‘L’: return «.-..»;
case ‘M’: return «–«; case ‘N’: return «-.»; case ‘O’: return «—«;
case ‘P’: return «.–.»; case ‘Q’: return «–.-«; case ‘R’: return «.-.»;
case ‘S’: return «…»; case ‘T’: return «-«; case ‘U’: return «..-«;
case ‘V’: return «…-«; case ‘W’: return «.–«; case ‘X’: return «-..-«;
case ‘Y’: return «-.–«; case ‘Z’: return «–..»; case ‘1’: return «.—-«;
case ‘2’: return «..—«;case ‘3’: return «…–«;case ‘4’: return «….-«;
case ‘5’: return «…..»;case ‘6’: return «-….»;case ‘7’: return «–…»;
case ‘8’: return «—..»;case ‘9’: return «—-.»;case ‘0’: return «—–«;
case ‘.’: return «.-.-.-«;case ‘,’: return «–..–«;case ‘?’: return «..–..»;
case ‘ ‘: return » «;
default: return «»;
}
}
Que se combina con otras funciones que tenemos para lograr que la traducción salga mediante luz sonido o ambos.
Implementación de luces led y buzzer:
Después de tener listas la pantalla y el teclado, mnos faltaban implementar los últimos componentes necesarios para completar la parte más básica de nuestro proyecto, los últimos que nos faltaban para que fuese funcional.
Para lograr integrar en nuestro circuito los leds y el buzzer, hicimos uso de la breadboard que nos suministró el kit, de esta manera logramos integrar estos componentes usando el menor número posible de pines del arduino, el cual ya tenía ocupados algunos con las conexiones del teclado y la pantalla, de esta manera ya teníamos todo lo necesario para que funcionara nuestra práctica y solo había que realizar el código final, probar que funcionaba, y después crear el hardware del mismo.
El código final resultó ser este, el cual será explicado en profundidad en el siguiente apartado:
Implementación del Hardware
A nivel de implementación en hardware los mayores problemas era la posible falta de pines digitales ya que el teclado matricial necesita de ocho pines (cuatro para las columnas 4,5,6,7 y cuatro para las filas 8,9,10,11) digitales, por lo que se consideró que las señales fueran pines analógicos ya que la perdida de que la señal sea de onda es asumible ya que mostrar el morse nos valdría con luces y sonidos estático ya que no teníamos pensado hacer un variación de tono en los sonidos que representen un corto o un largo pero al final si pudimos mantenerlos como digitales por si acaso se implementaba una variación en estas señales. Esto se pudo hacer porque descubrimos que el Arduino tenía entradas específicas para la pantalla lcd siendo las entradas SCL y SDA además que pudimos los 16 pines de una pantalla LCD básica a 4 de una pantalla con el adaptador i2c ya soldado quitándonos definitivamente el problema de los pines dejando que sus pines sean el específico para SCL, el específico para SDA, la entrada de 5V y un GND.
Código:
Este es nuestro código explicado y separado en secciones:
Construcción física
Después de delimitar nuestra idea para el proyecto siendo un traductor a código morse pasamos a realizar varias ideas de prototipo.
De esta fase hubo dos vertientes para el diseño de los prototipos fijos que destacaban por poder una mayor capacidad de potencia lumínica y de sonido ya que el tamaño no era un problema. Mientras la segunda vertiente eran prototipos dirigidos a ser portátiles dando una mayor flexibilidad de uso, pero esto limitando grandemente el tamaño que debía tener el prototipo para ser portable limitando por consecuencia la potencia que pueden tener. Al final nos decidimos por este segundo ya que nos gustaría dirigir el uso de este proyecto para militares y rescatistas en situaciones donde el uso de otros tipos de comunicaciones ya sean por situaciones adversas o por problemas de señales otros dispositivos no se pueden usarse.
El siguiente paso fue determinar las señales necesarias para realizar el prototipo en el esquema que se puede ver a continuación:
Como podemos ver en esta primera interacción podemos ver nuestra visión muy simplista de como veíamos el proyecto. Al ir desarrollando proyecto el esquema de señales fue cambiando, convirtiéndose en una señal que iría al Arduino que sería de la powerbank que da potencia al prototipo el código ya estaría cargado con antelación, la siguiente señal será la del teclado que bidireccional ya que recibe y da información al teclado, la pantalla recibirá señal del Arduino y luego las señales ya vistas en el esquema de arriba pero que se ha reducido a solo una señal para las luces y otra para el buzzer.
Ya con las señales más claras pasamos a comprar los materiales necesarios nuestro planteamiento inicial fue comprar una pantalla lcd porque nuestro kit no la tenía y por suerte no vino con adaptador para no tener el problema de los pines y lo segundo que pedimos fue un shield de Arduino que contaba con una entrada donde poder poner un USB para asi usar un teclado inalámbrico que ya poseía uno de los participantes del grupo.
Con ya los materiales pedidos pasamos a probarlo, la pantalla lcd tenía el problema de que producía un falso contacto con el adaptador por lo que probamos a soldarlo al mantenerse el error procedimos a comprar una pantalla con ya el adaptador soldado de base y con esta al probarlo ya funcionaba como era debido. En cuanto al shield este si se conectaba bien, pero al transmitir datos estos mandaban datos sin sentido por lo que optamos por un teclado matricial que tiene una fácil implementación en Arduino y aun con las limitadas teclas para poder poner todas las letras basto con una implementación en código que funciona de forma similar a los móviles antiguos
Con los distintos componentes probados y ya la breadbpard con las led y el buzzer. Pasaremos a probar el conjunto de todos los componentes a la vez dando es siguiente circuito que podemos ver en la imagen de abajo.
Con el circuito operativo pasaremos a realizar el armazón para resguardarlo. Este estará conformado por una caja de cartón que se cortará para hacerla más maniobrable, debido de la dureza del cartón se necesitó de una amoladora para cortarlo correctamente. Luego se unió con pegamento y se reforzó con cinta. Luego se cortó relleno para dentro de la caja para encajarlos los distintos componentes dentro de la caja para que no se muevan ya que se moverá bastante debido a su naturaleza portable por lo que es importante esta fijación además de un poco de cinta en algunos cables para que no se salgan de su sitio.
Terminaremos con el video explicatorio de la practica:
