Está en la página 1de 16

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.
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.

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.
55.

ledPin = pin;
}

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.
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.

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.

También podría gustarte