ESCUELA SUPERIOR DE INGENIERIA MECANICA Y ELECTRICA

UNIDAD ZACATENCO.

ICE

ASIGNATURA:

Microprocesadores.

PROFESOR:

Salvador Saucedo Flores

PROYECTO:

TRADUCTOR CODIGO MORSE

ALUMNO:

Ontiveros Gonzlez Alberto

BOLETA:

2012301578.

GRUPO:

6CM5

No.de lista:

16

Turno:

Vespertino

Horas de Proceso:

3
Introduccin:

PIC 18F4550

Principales caractersticas del Pic 18F4550

Microcontrolador con modulo USB 2.0. Soporta Low speed

1.5 Mb/s y full speeds 12Mb/s.
1kB de memoria de doble acceso va USB
35 pines I/O disponibles
Memoria de programa flash de 32 kB
RAM de 2048 Bytes
EEPROM de datos de 256 Bytes
Velocidad de la CPU 12 MIPS
Oscilador externo de dos modos hasta 48 MHz
Oscilador interno seleccionable entre 8 frecuencias desde
31kHz hasta 8MHz
Oscilador secundario con Timer 1 de hasta 32kHz
Opciones de oscilador dual permiten que la velocidad de la
CPU y del mdulo USB sean diferentes
ADC de 10 bits y 13 canales
Tecnologa nano Watt que brinda caractersticas y funciones
de bajo consumo y ahorro de energa
Voltaje de operacin 4.2V a 5.5V
4 Timer (desde Timer0 a Timer3). Uno de 8 bits y 3 de 16
bits
2 mdulos de captura/comparacin/PWM
EUSART, SPP, SPI, IC.
20 fuentes de interrupciones (3 externas)
Resistencias de pull-ups en el puerto B programables
 Funcin del pin MCLR opcional
Brown-out Reset de valor programable
Power-on Reset
Power-up Timer y Oscillator Start-up Timer
Soporta 100,000 ciclos de borrado/escritura en memoria
flash

El ATMEGA168P-20PU es un microcontrolador picoPower de 8 bits basado

en RISC de 16 bits, que combina memoria flash ISP de 16kB con
capacidades de lectura y escritura, EEPROM de 512bytes, SRAM de 1kB,
23 lneas de E / S de uso general, 32 registros de trabajo de uso
general , Tres temporizadores / contadores flexibles con modos de
comparacin, interrupciones internas y externas, USART programable en
serie, una interfaz serie de 2 hilos orientada por byte, puerto serie SPI,
convertidor A / D de 6 canales de 10 bits, temporizador de vigilancia
programable con oscilador interno Y cinco modos de ahorro de energa
seleccionables por software. El dispositivo funciona entre 2.7 a 5.5V. Al
ejecutar instrucciones potentes en un solo ciclo de reloj, el dispositivo
alcanza velocidades aproximadas de 1MIPS por MHz, balanceando el
consumo de energa y la velocidad de procesamiento. El dispositivo se
fabrica utilizando la tecnologa de memoria no voltil de alta densidad
de Atmel. El flash ISP integrado permite que la memoria del programa
sea reprogramada en el sistema a travs de una interfaz serie SPI.
El cdigo morse fue desarrollado por Alfred Vail mientras colaboraba en
1830 con Samuel Morse en la invencin del telgrafo elctrico.
Vail cre un mtodo segn el cual cada letra o nmero era transmitido
de forma individual con un cdigo consistente en rayas y puntos, es
decir, seales telegrficas que se diferencian en el tiempo de duracin
de la seal activa.
La duracin del punto es la mnima posible. Una raya tiene una duracin
de aproximadamente tres veces la del punto. Entre cada par de smbolos
de una misma letra existe una ausencia de seal con duracin
aproximada a la de un punto.
Entre las letras de una misma palabra, la ausencia es de
aproximadamente tres puntos.
Para la separacin de palabras transmitidas el tiempo es de
aproximadamente tres veces el de la raya. Morse reconoci la idoneidad
de este sistema y lo patent junto con el telgrafo elctrico. Fue
conocido como American Morse Code y fue utilizado en la primera
transmisin por telgrafo.

En sus comienzos, el alfabeto Morse se emple en las lneas telegrficas

mediante los tendidos de cable que se fueron instalando. Ms tarde, se
utiliz tambin en las transmisiones por radio, sobre todo en el mar y en
el aire, hasta que surgieron las emisoras y los receptores de
radiodifusin mediante voz.

En la actualidad, el alfabeto Morse tiene aplicacin casi exclusiva en el

mbito de los radioaficionados y Scouts, y aunque fue exigido
frecuentemente su conocimiento para la obtencin de la licencia de
radioperador aficionado hasta el ao 2005, posteriormente, los
organismos que conceden esa licencia en todos los pases estn
invitados a dispensar del examen de telegrafa a los candidatos.

Tambin se utiliza en la aviacin instrumental para sintonizar las

estaciones VOR, ILS y NDB. En las cartas de navegacin est indicada la
frecuencia junto con una seal Morse que sirve, mediante radio, para
confirmar que ha sido sintonizada correctamente.
Descripcin del proyecto

La idea bsica del proyecto era crear un traductor de caracteres a

cdigo morse. Con ayuda de un Atmega 168 a 16Hz se carga el
programa que en funcin de esos caracteres recibidos por el puerto de
serie, lo transcribe a cdigo morse.
Para enviar esos caracteres se utiliz un programa escrito en C/C++
(que hace uso de la API de Windows para acceder a los COM), en el cual
se introduce la cadena de caracteres que se desea reproducir.
Estos caracteres pueden decodificarse a travs de una bocina a
manera de sonido, a travs de un led a manera de seal o en su defecto
de ambas formas con la ayuda de un protoboard.

Principales problemas encontrados:

Al inicio tuvimos el problema de que al correr el programa de C++ no

haca la comunicacin con el puerto serial al que estaba conectado el
Microcontrolador, la manera en que resolvimos esto fue juntar los
cdigos (tanto el de C++ como el del micro) en un mismo fichero. Esto
resolvi nuestro problema y as lograr traducir los caracteres que
introducimos mediante teclado a cdigo morse.

Otro problemtica que se planteo fue que al intentar probar el circuito

con led y con speaker la cantidad de voltaje no era suficiente, la bocina
se escuchaba pero el encendido del led era muy tenue y no se alcanzaba
a apreciar bien las seales.

Posibles aplicaciones de este proyecto:

Entre las posibles aplicaciones en que podamos realizar un modelo a

ms grande escala utilizando algn tipo de lmpara de una buena
cantidad de watts as como a speaker de largo alcance y colocarlo en
algn barco o lancha a manera de poder realizar llamados de auxilio o
comunicarse con otros barcos cercanos a distancia.

Material:
1-Pic 18F4550
1 Atmega128
1 - Protoboard
3 - Resistencias (220 Ohm)
1 - 8-ohm Mini buzzer
2 - 5mm LED

Demostracion del circuito.

 Demostracion de Codigo C++ Mplab

1. #include <iostream>
2. #include <windows.h>
3.
4. using namespace std;
5.
6.
7. int main() {
8. /****************************
9. CONFIGURACION DEL PUERTO COM
10. ****************************/
11. HANDLE hSerial;
12. hSerial = CreateFile("COM3",
13. GENERIC_READ | GENERIC_WRITE,
14. 0,
15. 0,
16. OPEN_EXISTING,
17. FILE_ATTRIBUTE_NORMAL,
18. 0);
19. if(hSerial==INVALID_HANDLE_VALUE){
20. if(GetLastError()==ERROR_FILE_NOT_FOUND){
21. cout << "The COM port doesn't exist" << endl;
22. }
23. cout << "Error: Invalid Handle" << endl;
24. }
25.
26. DCB dcbSerialParams = {0};
27. dcbSerialParams.DCBlength=sizeof(dcbSerialParams); // Esta linea esta mal en el PDF
(aqui esta bien)
28. if (!GetCommState(hSerial, &dcbSerialParams)) {
29. cout << "Error getting state" << endl;
30. }
31. dcbSerialParams.BaudRate=CBR_9600;
32. dcbSerialParams.ByteSize=8;
33. dcbSerialParams.StopBits=ONESTOPBIT;
34. dcbSerialParams.Parity=NOPARITY;
35. if(!SetCommState(hSerial, &dcbSerialParams)){
36. cout << "Error setting serial port state" << endl;
37. }
38.
39. COMMTIMEOUTS timeouts={0};
40. timeouts.ReadIntervalTimeout=50;
41. timeouts.ReadTotalTimeoutConstant=50;
42. timeouts.ReadTotalTimeoutMultiplier=10;
43. timeouts.WriteTotalTimeoutConstant=50;
44. timeouts.WriteTotalTimeoutMultiplier=10;
45. if(!SetCommTimeouts(hSerial, &timeouts)){
46. cout << "Error Setting time out" << endl;
47. }
48.
49. /********************
50. TRANSMISION DE DATOS
51. ********************/
52. char szBuf[1] = {0};
53. DWORD dwBytesRead = 0;
54. char palabra[64]; // 8 * 8
55.
56. while (palabra[0] != '!') {
57. cout << "Palabra (! para salir): ";
58. cin >> palabra;
59. cout << endl;
60. unsigned short int i = 0;
61. while (palabra[i] != 0) {
62. szBuf[0] = palabra[i];
63. if(!WriteFile(hSerial, szBuf, 1, &dwBytesRead, NULL)){
64. cout << "No se pudo" << endl;
65. break;
66. }
67. i++;
68. }
69. }
70. }

Demostracion de Codigo en el ATmega

1. unsigned short int punto = 70; // Duracion del punto

2. unsigned short int raya = punto * 4; // Duracion de la raya
3. unsigned short int negro = punto * 3; // Duracion del apagado entre rayas y puntos
4. unsigned short int letrayletra = punto * 5; // Duracion del apagado entre letras
5.
6. void playTone(int tone, int duration, int speakerPin) {
7. // Sends the signal to the speakerPin
8. for (long i = 0; i < duration * 1000L; i += tone * 2) {
9. digitalWrite(speakerPin, HIGH);
10. delayMicroseconds(tone);
11. digitalWrite(speakerPin, LOW);
12. delayMicroseconds(tone);
13. }
14. }
15.
16. void playToneLed(int tone, int duration, int speakerPin, int ledPin) {
17. // Sends the signal to speakerPin and ledPin
18. for (long i = 0; i < duration * 1000L; i += tone * 2) {
19. digitalWrite(speakerPin, HIGH);
20. digitalWrite(ledPin, HIGH);
21. delayMicroseconds(tone);
22. digitalWrite(speakerPin, LOW);
23. digitalWrite(ledPin, LOW);
24. delayMicroseconds(tone);
25. }
26. }
27.
28. // ########## CLASE LETRA #########
29. class letra {
30. private:
31. char caracter;
32. char* codigo;
33. int ledPin;
34. public:
35. letra (char car, char* cad, unsigned short int pin);
36. void set (char car, char* cad, unsigned short int pin);
37. void mostrar ();
38. void sonar ();
39. void mostrarYsonar ();
40. };
41.
42. letra::letra (char car, char* cad, unsigned short int pin) {
43. // Constructor
44. caracter = car;
45. codigo = cad;
46. ledPin = pin;
47. pinMode(ledPin, OUTPUT);
48. }
49.
50. void letra::set (char car, char* cad, unsigned short int pin) {
51. // Setter
52. caracter = car;
53. codigo = cad;
54. ledPin = pin;
55. }
56.
57. void letra::mostrar () {
58. // Shows the code in in the ledPin
59. unsigned short int j = 0;
60. while (codigo[j] != 0) {
61. if (codigo[j] == '.') {
62. digitalWrite (ledPin, HIGH);
63. delay (punto);
64. digitalWrite (ledPin, LOW);
65. delay (negro);
66. } else if (codigo[j] == '-') {
67. digitalWrite (ledPin, HIGH);
68. delay (raya);
69. digitalWrite (ledPin, LOW);
70. delay (negro);
71. }
72. j++;
73. }
74. delay (letrayletra);
75. }
76.
77. void letra::sonar () {
78. // Sounds the code on the speakerPin
79. unsigned short int j = 0;
80. while (codigo[j] != 0) {
81. if (codigo[j] == '.') {
82. playTone (440, 100, 9);
83. delay (negro/3);
84. } else if (codigo[j] == '-') {
85. playTone (440, 100 * 4, 9);
86. delay (negro/3);
87. }
88. j++;
89. }
90. delay (letrayletra);
91. }
92.
93. void letra::mostrarYsonar () {
94. // Sounds and shows the code (ledPin + speakerPin)
95. unsigned short int j = 0;
96. while (codigo[j] != 0) {
97. if (codigo[j] == '.') {
98. playToneLed (440, 100, 9, ledPin);
99. delay (negro/4);
100. } else if (codigo[j] == '-') {
101. playToneLed (440, 100 * 4, 9, ledPin);
102. delay (negro/4);
103. }
104. j++;
105. }
106. delay (letrayletra/2);
107. }
108. // ##############################
109.
110. void setup() {
111. Serial.begin(9600);
112. pinMode(9, OUTPUT);
113. }
114.
115. int letraIN = 0;
116. unsigned short int ledPin = 13;
117. void loop() {
118. digitalWrite(ledPin, LOW);
119. letraIN = 0;
120. letraIN = Serial.read();
121. letra let (0, "", ledPin);
122. switch (letraIN) {
123. case 'a': let.set ('a', ".-", ledPin);
124. break;
125. case 'b': let.set ('b', "-...", ledPin);
126. break;
127. case 'c': let.set ('c', "-.-.", ledPin);
128. break;
129. case 'd': let.set ('d', "-..", ledPin);
130. break;
131. case 'e': let.set ('e', ".", ledPin);
132. break;
133. case 'f': let.set ('f', "..-.", ledPin);
134. break;
135. case 'g': let.set ('g', "--.", ledPin);
136. break;
137. case 'h': let.set ('h', "....", ledPin);
138. break;
139. case 'i': let.set ('i', "..", ledPin);
140. break;
141. case 'j': let.set ('j', ".---", ledPin);
142. break;
143. case 'k': let.set ('k', "-.-", ledPin);
144. break;
145. case 'l': let.set ('l', ".-..", ledPin);
146. break;
147. case 'm': let.set ('m', "--", ledPin);
148. break;
149. case 'n': let.set ('n', "-.", ledPin);
150. break;
151. case 'o': let.set ('o', "---", ledPin);
152. break;
153. case 'p': let.set ('p', ".--.", ledPin);
154. break;
155. case 'q': let.set ('q', "--.-", ledPin);
156. break;
157. case 'r': let.set ('r', ".-.", ledPin);
158. break;
159. case 's': let.set ('s', "...", ledPin);
160. break;
161. case 't': let.set ('t', "-", ledPin);
162. break;
163. case 'u': let.set ('u', "..-", ledPin);
164. break;
165. case 'v': let.set ('v', "...-", ledPin);
166. break;
167. case 'w': let.set ('w', ".--", ledPin);
168. break;
169. case 'x': let.set ('x', "-..-", ledPin);
170. break;
171. case 'y': let.set ('y', "-.--", ledPin);
172. break;
173. case 'z': let.set ('z', "--..", ledPin);
174. break;
175. case '0': let.set ('0', "-----", ledPin);
176. break;
177. case '1': let.set ('1', ".----", ledPin);
178. break;
179. case '2': let.set ('2', "..---", ledPin);
180. break;
181. case '3': let.set ('3', "...--", ledPin);
182. break;
183. case '4': let.set ('4', "....-", ledPin);
184. break;
185. case '5': let.set ('5', ".....", ledPin);
186. break;
187. case '6': let.set ('6', "-....", ledPin);
188. break;
189. case '7': let.set ('7', "--...", ledPin);
190. break;
191. case '8': let.set ('8', "---..", ledPin);
192. break;
193. case '9': let.set ('9', "----.", ledPin);
194. break;
195. case '.': let.set ('.', ".-.-.-", ledPin);
196. break;
197. case ',': let.set (',', "--..--", ledPin);
198. break;
199. case '?': let.set ('?', "..--..", ledPin);
200. break;
201. case '"': let.set ('"', ".-..-.", ledPin);
202. break;
203. }
204. //let.mostrar();
205. //let.sonar();
206. let.mostrarYsonar();
207. }
Conclusiones
Con el desarrollo de este proyecto concluimos en que fue un excelente
ejercicio para comenzar a conocer los componentes de los Atmega junto
con el conocimiento ya ocupado por los pics as como el vasto nmero
de aplicaciones que stos pueden llegar a tener y las soluciones que
pueden brindar, desde algo muy sencillo como prender una luz hasta
algo muy complejo como mover un motor.