ESCUELA SUPERIOR DE INGENIERIA MECANICA Y ELECTRICA UNIDAD ZACATENCO. ICE ASIGNATURA: Microprocesadores. PROFESOR: Salvador Saucedo Flores PROYECTO: TRADUCTOR CODIGO MORSE ALUMNO: Ontiveros González Alberto BOLETA: 2012301578. GRUPO: 6CM5 No.de lista: 16 Turno: Vespertino Horas de Proceso: 3
Introducción: PIC 18F4550 Principales características 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 vía 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 módulo USB sean diferentes ADC de 10 bits y 13 canales Tecnología nano Watt que brinda características y funciones de bajo consumo y ahorro de energía Voltaje de operación 4.2V a 5.5V 4 Timer (desde Timer0 a Timer3). Uno de 8 bits y 3 de 16 bits 2 módulos de captura/comparación/PWM EUSART, SPP, SPI, I²C. 20 fuentes de interrupciones (3 externas) Resistencias de pull-ups en el puerto B programables Función 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 líneas de E / S de uso general, 32 registros de trabajo de uso general , Tres temporizadores / contadores flexibles con modos de comparación, 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 energía 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 energía y la velocidad de procesamiento. El dispositivo se fabrica utilizando la tecnología de memoria no volátil de alta densidad de Atmel. El flash ISP integrado permite que la memoria del programa sea reprogramada en el sistema a través de una interfaz serie SPI.
El código morse fue desarrollado por Alfred Vail mientras colaboraba en 1830 con Samuel Morse en la invención del telégrafo eléctrico. Vail creó un método según el cual cada letra o número era transmitido de forma individual con un código consistente en rayas y puntos, es decir, señales telegráficas que se diferencian en el tiempo de duración de la señal activa. La duración del punto es la mínima posible. Una raya tiene una duración de aproximadamente tres veces la del punto. Entre cada par de símbolos de una misma letra existe una ausencia de señal con duración aproximada a la de un punto. Entre las letras de una misma palabra, la ausencia es de aproximadamente tres puntos. Para la separación 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 telégrafo eléctrico. Fue conocido como American Morse Code y fue utilizado en la primera transmisión por telégrafo. En sus comienzos, el alfabeto Morse se empleó en las líneas telegráficas mediante los tendidos de cable que se fueron instalando. Más tarde, se utilizó también en las transmisiones por radio, sobre todo en el mar y en el aire, hasta que surgieron las emisoras y los receptores de radiodifusión mediante voz. En la actualidad, el alfabeto Morse tiene aplicación casi exclusiva en el ámbito de los radioaficionados y Scouts, y aunque fue exigido frecuentemente su conocimiento para la obtención de la licencia de radioperador aficionado hasta el año 2005, posteriormente, los organismos que conceden esa licencia en todos los países están invitados a dispensar del examen de telegrafía a los candidatos. También se utiliza en la aviación instrumental para sintonizar las estaciones VOR, ILS y NDB. En las cartas de navegación está indicada la frecuencia junto con una señal Morse que sirve, mediante radio, para confirmar que ha sido sintonizada correctamente.
Descripción del proyecto •La idea básica del proyecto era crear un traductor de c aracteres a código morse. Con
ayuda de un Atmega 168 a 16Hz se carga el programa que en función de esos caracteres recibidos por el puerto de serie, lo transcribe a código 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 tr avés de una bocina a manera de sonido, a través de un led a manera de señal 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 hacía la comunicación con el puerto serial al que estaba conectado el Microcontrolador, la manera en que resolvimos esto fue juntar los códigos (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 código morse. Otro problemática 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 señales. Posibles aplicaciones de este proyecto: Entre las posibles aplicaciones en que podamos realizar un modelo a más grande escala utilizando algún tipo de lámpara de una buena cantidad de watts así como a speaker de largo alcance y colocarlo en algún 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
2.
#include
3. 4.
using namespace std;
5. 6. 7. 8.
int main() { /****************************
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. 37.
cout << "Error setting serial port state" << endl; }
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. 47.
cout << "Error Setting time out" << endl; }
48. 49.
/********************
50.
TRANSMISION DE DATOS
51.
********************/
52.
char szBuff[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.
szBuff[0] = palabra[i];
63.
if(!WriteFile(hSerial, szBuff, 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. 17. 18.
void playToneLed(int tone, int duration, int speakerPin, int ledPin) { // Sends the signal to speakerPin and ledPin
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. 58.
void letra::mostrar () { // 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. 94.
void letra::mostrarYsonar () { // 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. 124. 125. 126. 127. 128. 129. 130. 131. 132. 133. 134. 135. 136. 137. 138. 139. 140. 141. 142. 143.
case 'a': let.set ('a', ".-", ledPin); break;
case 'b': let.set ('b', "-...", ledPin); break;
case 'c': let.set ('c', "-.-.", ledPin); break;
case 'd': let.set ('d', "-..", ledPin); break;
case 'e': let.set ('e', ".", ledPin); break;
case 'f': let.set ('f', "..-.", ledPin); break;
case 'g': let.set ('g', "--.", ledPin); break;
case 'h': let.set ('h', "....", ledPin); break;
case 'i': let.set ('i', "..", ledPin); break;
case 'j': let.set ('j', ".---", ledPin); break;
case 'k': let.set ('k', "-.-", ledPin);
144. 145. 146. 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. 163. 164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175. 176. 177. 178. 179. 180. 181. 182. 183. 184.
break;
case 'l': let.set ('l', ".-..", ledPin); break;
case 'm': let.set ('m', "--", ledPin); break;
case 'n': let.set ('n', "-.", ledPin); break;
case 'o': let.set ('o', "---", ledPin); break;
case 'p': let.set ('p', ".--.", ledPin); break;
case 'q': let.set ('q', "--.-", ledPin); break;
case 'r': let.set ('r', ".-.", ledPin); break;
case 's': let.set ('s', "...", ledPin); break;
case 't': let.set ('t', "-", ledPin); break;
case 'u': let.set ('u', "..-", ledPin); break;
case 'v': let.set ('v', "...-", ledPin); break;
case 'w': let.set ('w', ".--", ledPin); break;
case 'x': let.set ('x', "-..-", ledPin); break;
case 'y': let.set ('y', "-.--", ledPin); break;
case 'z': let.set ('z', "--..", ledPin); break;
case '0': let.set ('0', "-----", ledPin); break ;
case '1': let.set ('1', ".----", ledPin); break ;
case '2': let.set ('2', "..---", ledPin); break ;
case '3': let.set ('3', "...--", ledPin); break ;
case '4': let.set ('4', "....-", ledPin); 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. 207.
let.mostrarYsonar(); }
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 número 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.
