Comunicación serial segundo corte.

Dependencies:   mbed

SISTEMAS EMBEBIDOS

COMUNICACIÓN SERIAL

EDISON AHUMADA

NELSON YESID POSADA

ALVARO CORTES

CRISTIAN MONTERO

ECCI UNIVERSIDAD ECCI

INTRODUCCIÓN

En el siguiente documento se explica cómo función la comunicación serial, por medio de la aplicación CoolTerm (Terminal de puertos serial multiforma), el cual nos permite tener una conexión por puerto serial con la tarjeta Nucleo 446, donde guardaremos nuestro código ya modificado en la plataforma ARM MBED y que a su vez tendrá conexión con el Piccolo. Gracias a esta aplicación enviaremos datos en hexadecimal al puerto serial y a sus ves al núcleo, donde se convertirán estos caracteres en bytes, enviando datos digitales a los tres servos, generando movimiento en el Piccolo, en cualquier función deseada como por ejemplo realizar un circulo, un cuadrado, una recta etc.

MARCO TEORICO.

COMUNICAION SERIAL: La comunicación serial es un protocolo muy común (no hay que confundirlo con el Bus Serial de Comunicación, o USB) para comunicación entre dispositivos que se incluye de manera estándar en prácticamente cualquier computadora. La mayoría de las computadoras incluyen dos puertos seriales RS-232. La comunicación serial es también un protocolo común utilizado por varios dispositivos para instrumentación; existen varios dispositivos compatibles con GPIB que incluyen un puerto RS-232. Además, la comunicación serial puede ser utilizada para adquisición de datos si se usa en conjunto con un dispositivo remoto de muestreo.

/media/uploads/Edisonap/comunicacion_serial.png

Típicamente, la comunicación serial se utiliza para transmitir datos en formato ASCII. Para realizar la comunicación se utilizan 3 líneas de transmisión: (1) Tierra (o referencia), (2) Transmitir, (3) Recibir. Debido a que la transmisión es asincrónica, es posible enviar datos por una línea mientras se reciben datos por otra. Existen otras líneas disponibles para realizar handshaking, o intercambio de pulsos de sincronización, pero no son requeridas. Las características más importantes de la comunicación serial son la velocidad de transmisión, los bits de datos, los bits de parada, y la paridad. Para que dos puertos se puedan comunicar, es necesario que las características sean iguales.

Comunicación serial asíncrona: En esta comunicación uno de los hilos será para la transmisión de los datos de un dispositivo a otro y el otro hilo será para la recepción de datos entre un dispositivo a otro, la transmisión y la recepción pueden ocurrir en forma simultánea, lo que si se tiene que cumplir es que la frecuencia de trabajo de ambos dispositivos tiene que ser la misma. Comunicación serial asíncrona: En esta comunicación uno de los hilos será utilizado tanto para la transmisión y la recepción de datos por lo que la transmisión no puede ocurrir en forma simultánea, el otro hilo será utilizado para enviar la señal de reloj de sincronización entre ambos dispositivos, en este caso uno de los dispositivos es llamado maestro y el otro esclavo, el maestro es el que controla la señal de reloj y cuando se inicia o finaliza la comunicación. Velocidad de transmisión (baud rate): Indica el número de bits por segundo que se transfieren, y se mide en baudios (bauds). Por ejemplo, 300 baudios representan 300 bits por segundo. Cuando se hace referencia a los ciclos de reloj se está hablando de la velocidad de transmisión. Por ejemplo, si el protocolo hace una llamada a 4800 ciclos de reloj, entonces el reloj está corriendo a 4800 Hz, lo que significa que el puerto serial está muestreando las líneas de transmisión a 4800 Hz. Bits de datos: Se refiere a la cantidad de bits en la transmisión por ejemplo una computadora envía un paquete de información, el tamaño de ese paquete no necesariamente será de 8 bits. Las cantidades más comunes de bits por paquete son 5, 7 y 8 bits. El número de bits que se envía depende en el tipo de información que se transfiere. Por ejemplo, el ASCII estándar tiene un rango de 0 a 127, es decir, utiliza 7 bits; para ASCII extendido es de 0 a 255, lo que utiliza 8 bits. Un paquete se refiere a una transferencia de byte, incluyendo los bits de inicio/parada, bits de datos, y paridad. Debido a que el número actual de bits depende en el protocolo que se seleccione, el término paquete se usar para referirse a todos los casos.

Bits de parada: Es usado para indicar el fin de la comunicación de un solo paquete. Los valores típicos son 1, 1.5 o 2 bits. Debido a la manera como se transfiere la información a través de las líneas de comunicación y que cada dispositivo tiene su propio reloj, es posible que los dos dispositivos no estén sincronizados. Por lo tanto, los bits de parada no sólo indican el fin de la transmisión sino además dan un margen de tolerancia para esa diferencia de los relojes. Mientras más bits de parada se usen, mayor será la tolerancia a la sincronía de los relojes, sin embargo la transmisión será más lenta. Paridad: Es una forma sencilla de verificar si hay errores en la transmisión serial. Existen cuatro tipos de paridad: par, impar, marcada y espaciada. Por ejemplo, si la información a transmitir es 011 y la paridad es par, el bit de paridad sería 0 para mantener el número de bits en estado alto lógico como par. Si la paridad seleccionada fuera impar, entonces el bit de paridad sería 1, para tener 3 bits en estado alto lógico. La paridad marcada y espaciada en realidad no verifican el estado de los bits de datos; simplemente fija el bit de paridad en estado lógico alto para la marcada, y en estado lógico bajo para la espaciada. Esto permite al dispositivo receptor conocer de antemano el estado de un bit, lo que serviría para determinar si hay ruido que esté afectando de manera negativa la transmisión de los datos, o si los relojes de los dispositivos no están sincronizados.

Monitor serial: Es una herramienta muy importante para todos los desarrolladores de software y hardware que trabajan con puertos serie. Esta interfaz permite capturar, mostrar, analizar, grabar y reproducir todos los datos de puerto serie intercambiados entre la aplicación de Windows y el dispositivo serie. Nos representa una gran ayuda en cuando a la facilidad de enviar datos y orientar las diferentes variables que se ejecutan en función de las necesidades, podemos realizar pruebas fácilmente de nuestro programa sin intervenir el código directamente y volver a compilar.

DESCRIPCIÓN DEL CODIGO

1. int coord2pulse(float coord) 2. { 3. if(0 <= coord <= MAXPOS) 4. return int(coord*1000/150+750); 5. return 750; 6. }

Se introduce un valor menor a 255 en binario que es la máxima posición que puede tener los servos dentro de su rango de trabajo es decir 180°.

7. uint8_t buffer_command[BUFF_SIZE]={0,0,0,0}; Se establece un carácter que va guardar el inicio, fin del comando, los parámetros del comando y el comando o función que va realizar el piccolo.

8. void print_num(uint8_t val) 9. { 10. if (val <10) 11. command.putc(val+0x30); 12. else 13. command.putc(val-9+0x40); 14. } 15. void print_bin2hex (uint8_t val) 16. { 17. command.printf(" 0x"); 18. print_num(val>>4); 19. print_num(val&0x0f); 20. }

Se realiza una operación para convertir el carácter decimal porque nuestro monitor serial solo puede leer carácter en forma hexadecimal y ASQUI.

21. void Read_command() 22. { 23. for (uint8_t i=0; i<BUFF_SIZE;i++) 24. buffer_command[i]=command.getc(); 25. }

Atreves de un for recorre todas las posiciones, que se dejaron en el tamaño del buffer, obteniendo el comando que se desea realizar.

26. void echo_command() 27. { 28. for (uint8_t i=0; i<BUFF_SIZE;i++) 29. print_bin2hex(buffer_command[i]); 30. } La función de este void es recorrer las posiciones para identificar los parámetro asignados en (buffer_command[INITPARAMETER]); 31. uint8_t check_command() 32. { 33. if (buffer_command[BUFF_SIZE-1]== '>'){ 34. #if DEBUG 35. command.printf("\nComando:"); 36. print_bin2hex(buffer_command[COMM_N]); 37. command.printf(" -> "); 38. #endif 39. return 1; 40. } 41. #if DEBUG 42. command.printf("\n ERROR COMANDO -> "); 43. echo_command(); 44. #endif 45. return 0; 46. }

Esta función retorna de 0 a 1, imprimiendo el comando que se ingresa en hexadecimal, por medio de comunicación serial en nuestro caso es enviado por coolterm. Este if imprime el comando que decidimos ejecutar, con sus respectivos parámetros, en caso de que el código en hexadecimal se encuentre errado, dicho if arrojara un mensaje de error de comando.

47. void command_led(int tm) 48. { 49. led=1; 50. wait(tm); 51. led=0; 52. }

Este es un ejemplo de comando, en este caso es el led donde se declara la variable tm (tiempo) y a continuación indica la función de encendido del led, tiempo en el cual estará prendido el led. Este tiempo es definido por el usuario cuando se digita en el tercer parámetro en hexadecimal por el programa coolterm, después de haber trascurrido este tiempo el led se apaga.

53. int main() { 54. #if DEBUG 55. command.printf("inicio con debug\n"); 56. #else 57. command.printf("inicio sin debug\n"); 58. #endif

En el main se busca primero la comunicación serial con el coolterm al enviar como dato un 1 o un byte completo, ya que se envía por comunicación serial la tarjeta núcleo “responde “ si está en “Inicio con debug” o “inicio sin debug”

59. uint8_t val; 60. while(1){ 61. val=command.getc(); 62. if (val== '<'){Haya iniciado una trasmision de comando 63. Read_command(); 64. if (check_command()){ a. command_led(buffer_command[INITPARAMETER]); b. #if DEBUG c. echo_command(); d. #endif 65. } 66. } 67. else command.printf("error inicio trama: "); 68. command.putc(val); 69. }

En esta última parte del main declaramos un carácter entero llamada val, y realizamos la siguiente operación. Mientras el debug este en 1 esperamos un comando con la función getc, SI el valor ya inicio el comando de trasmisión por medio del carácter “<” ir a la función leer comando, después ejecuta otro IF con la función check_command, para verificar cada uno de los comandos establecidos y revisar en qué valor se encuentra la primera posición del BUFF_SIZE, al saber que parámetro es, comienza a ejecutarlo por medio de la función echo_command. En caso de no reconocer el comando ingresado, arrojara un mensaje “error inicio de trama”.

DISEÑO :

/media/uploads/Edisonap/20171020_191626.jpg /media/uploads/Edisonap/20171020_191614.jpg /media/uploads/Edisonap/20171020_191550.jpg

GLOSARIO

Buffer: Es un espacio de memoria, en el que se almacenan datos de manera temporal, normalmente para un único uso. Su principal uso es para evitar que el programa o recurso que los requiere, ya sea hardware o software, se quede sin datos durante una transferencia (entrada/salida) de datos irregular o por la velocidad del proceso.

  1. Define: Es una constante o valor que no puede ser alterado/modificado durante la ejecución de un programa, únicamente puede ser leído. Una constante corresponde a una longitud fija de un área reservada en la memoria principal del ordenador, donde el programa almacena valores fijos.

uint8_t: Número entero sin signo de 1 byte, es un alias para un tipo de dato usigned char que ocupa 1 byte de memoria codificando números de 0 a 255.

INITPARAMETER: Posición número de comando, esta constante se declara, para saber dónde inicia los parámetros, de ejecución. Void: Función que retorna un valor en 0, devolviendo un valor en nada “vacío”.

CONCLUSIONES

• Gracias a la comunicación serial podemos tener un intercambio de información con la tarjeta núcleo la cual está conectada con el Picccolo, generando una comunicación en línea, que nos facilita los cambios de funciones que va realizar nuestro Piccolo.

• Concluimos que, gracias a definir los comandos, como constantes podemos buscar cualquiera de ellos con un valor ya establecido, facilitando las funciones que va realizar el Piccolo, ya que con el simple hecho de digitar el comando en la posición 2, este realizara la función deseada.

Committer:
Edisonap
Date:
Fri Oct 20 23:31:36 2017 +0000
Revision:
0:d3a0eceae856
Comunicaci?n serial_ Segundo corte

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Edisonap 0:d3a0eceae856 1
Edisonap 0:d3a0eceae856 2
Edisonap 0:d3a0eceae856 3 //*****************************************************************************
Edisonap 0:d3a0eceae856 4 // COMANDO MOVER MOTOR
Edisonap 0:d3a0eceae856 5 // |POS 1|POS 2|POS 3|POS 4| POS 5|
Edisonap 0:d3a0eceae856 6 // | < | #C | a | b | > |
Edisonap 0:d3a0eceae856 7 //
Edisonap 0:d3a0eceae856 8 // #C -> indica el comando
Edisonap 0:d3a0eceae856 9 // a,b,c,d parametros del comando
Edisonap 0:d3a0eceae856 10 // <,> -> inicio, y fin de comando
Edisonap 0:d3a0eceae856 11 // el inicio de comando no se almacena en el buffer
Edisonap 0:d3a0eceae856 12 //*****************************************************************************
Edisonap 0:d3a0eceae856 13
Edisonap 0:d3a0eceae856 14 #include "mbed.h"
Edisonap 0:d3a0eceae856 15 #include "mbed.h"
Edisonap 0:d3a0eceae856 16 #include "mbed.h"
Edisonap 0:d3a0eceae856 17
Edisonap 0:d3a0eceae856 18 #define MAXPOS 255
Edisonap 0:d3a0eceae856 19 #define DEBUG 1
Edisonap 0:d3a0eceae856 20 #define BUFF_SIZE 6
Edisonap 0:d3a0eceae856 21 #define COMM_N 0
Edisonap 0:d3a0eceae856 22 #define INITPARAMETER 1
Edisonap 0:d3a0eceae856 23
Edisonap 0:d3a0eceae856 24 // COMANDOS
Edisonap 0:d3a0eceae856 25 #define LED_NC 0
Edisonap 0:d3a0eceae856 26 #define PUNTO 1
Edisonap 0:d3a0eceae856 27 #define LINEA 2
Edisonap 0:d3a0eceae856 28 #define CUADRADO 3
Edisonap 0:d3a0eceae856 29 #define CIRCULO 4
Edisonap 0:d3a0eceae856 30 #define HOME 5
Edisonap 0:d3a0eceae856 31 #define RESOLUCION 6
Edisonap 0:d3a0eceae856 32 #define TIEMPO_PASO 7
Edisonap 0:d3a0eceae856 33 #define STOP 8
Edisonap 0:d3a0eceae856 34 #define PAUSA 9
Edisonap 0:d3a0eceae856 35 #define REANUDAR 10
Edisonap 0:d3a0eceae856 36
Edisonap 0:d3a0eceae856 37 Serial command(USBTX, USBRX);
Edisonap 0:d3a0eceae856 38 DigitalOut led(LED1);
Edisonap 0:d3a0eceae856 39
Edisonap 0:d3a0eceae856 40 PwmOut servoX(PB_3);
Edisonap 0:d3a0eceae856 41 PwmOut servoY(PB_5);
Edisonap 0:d3a0eceae856 42 PwmOut servoZ(PB_4);
Edisonap 0:d3a0eceae856 43
Edisonap 0:d3a0eceae856 44
Edisonap 0:d3a0eceae856 45 InterruptIn detener(PA_9);
Edisonap 0:d3a0eceae856 46 InterruptIn pause(PC_7);
Edisonap 0:d3a0eceae856 47 InterruptIn reanudar(PB_6);
Edisonap 0:d3a0eceae856 48
Edisonap 0:d3a0eceae856 49 float xvalue, yvalue;
Edisonap 0:d3a0eceae856 50 int xisquare, yisquare,lenght,xlado,ylado,vel;
Edisonap 0:d3a0eceae856 51 double down=160;
Edisonap 0:d3a0eceae856 52 double up=240;
Edisonap 0:d3a0eceae856 53 double i,j,r,p=0,tim=60,yip;
Edisonap 0:d3a0eceae856 54
Edisonap 0:d3a0eceae856 55
Edisonap 0:d3a0eceae856 56 int coord2pulse(float coord)
Edisonap 0:d3a0eceae856 57 {
Edisonap 0:d3a0eceae856 58 if(0 <= coord <= MAXPOS)
Edisonap 0:d3a0eceae856 59 return int(coord*1000/150+750);
Edisonap 0:d3a0eceae856 60 return 750;
Edisonap 0:d3a0eceae856 61 }
Edisonap 0:d3a0eceae856 62
Edisonap 0:d3a0eceae856 63
Edisonap 0:d3a0eceae856 64 void vertex2d(float x, float y, float z)
Edisonap 0:d3a0eceae856 65 {
Edisonap 0:d3a0eceae856 66 int pulseX = coord2pulse(x);
Edisonap 0:d3a0eceae856 67 int pulseY = coord2pulse(y);
Edisonap 0:d3a0eceae856 68 int pulseZ = coord2pulse(z);
Edisonap 0:d3a0eceae856 69 servoX.pulsewidth_us(pulseX);
Edisonap 0:d3a0eceae856 70 servoY.pulsewidth_us(pulseY);
Edisonap 0:d3a0eceae856 71 servoZ.pulsewidth_us(pulseZ);
Edisonap 0:d3a0eceae856 72 }
Edisonap 0:d3a0eceae856 73
Edisonap 0:d3a0eceae856 74 uint8_t buffer_command[BUFF_SIZE]={0,0,0,0,0,0};
Edisonap 0:d3a0eceae856 75
Edisonap 0:d3a0eceae856 76 void print_num(uint8_t val)
Edisonap 0:d3a0eceae856 77 {
Edisonap 0:d3a0eceae856 78 if (val <10)
Edisonap 0:d3a0eceae856 79 command.putc(val+0x30);
Edisonap 0:d3a0eceae856 80 else
Edisonap 0:d3a0eceae856 81 command.putc(val-9+0x40);
Edisonap 0:d3a0eceae856 82 }
Edisonap 0:d3a0eceae856 83
Edisonap 0:d3a0eceae856 84 void print_bin2hex (uint8_t val)
Edisonap 0:d3a0eceae856 85 {
Edisonap 0:d3a0eceae856 86 command.printf(" 0x");
Edisonap 0:d3a0eceae856 87 print_num(val>>4);
Edisonap 0:d3a0eceae856 88 print_num(val&0x0f);
Edisonap 0:d3a0eceae856 89 }
Edisonap 0:d3a0eceae856 90
Edisonap 0:d3a0eceae856 91
Edisonap 0:d3a0eceae856 92 // TODO : TIMEOUT UART SERIAL
Edisonap 0:d3a0eceae856 93 void Read_command()
Edisonap 0:d3a0eceae856 94 {
Edisonap 0:d3a0eceae856 95 for (uint8_t i=0; i<BUFF_SIZE;i++)
Edisonap 0:d3a0eceae856 96 buffer_command[i]=command.getc();
Edisonap 0:d3a0eceae856 97 }
Edisonap 0:d3a0eceae856 98
Edisonap 0:d3a0eceae856 99
Edisonap 0:d3a0eceae856 100 void echo_command()
Edisonap 0:d3a0eceae856 101 {
Edisonap 0:d3a0eceae856 102 for (uint8_t i=0; i<BUFF_SIZE;i++)
Edisonap 0:d3a0eceae856 103 print_bin2hex(buffer_command[i]);
Edisonap 0:d3a0eceae856 104 }
Edisonap 0:d3a0eceae856 105
Edisonap 0:d3a0eceae856 106
Edisonap 0:d3a0eceae856 107 uint8_t check_command()
Edisonap 0:d3a0eceae856 108 {
Edisonap 0:d3a0eceae856 109 if (buffer_command[BUFF_SIZE-1]== '>')
Edisonap 0:d3a0eceae856 110 return 1;
Edisonap 0:d3a0eceae856 111 return 0;
Edisonap 0:d3a0eceae856 112 }
Edisonap 0:d3a0eceae856 113
Edisonap 0:d3a0eceae856 114
Edisonap 0:d3a0eceae856 115 void command_led(uint8_t tm)
Edisonap 0:d3a0eceae856 116 {
Edisonap 0:d3a0eceae856 117 //EJEMPLO DE COMANDO
Edisonap 0:d3a0eceae856 118 #if DEBUG
Edisonap 0:d3a0eceae856 119 command.printf("%i, segundos", tm);
Edisonap 0:d3a0eceae856 120 #endif
Edisonap 0:d3a0eceae856 121 led=1;
Edisonap 0:d3a0eceae856 122 wait(tm);
Edisonap 0:d3a0eceae856 123 led=0;
Edisonap 0:d3a0eceae856 124 }
Edisonap 0:d3a0eceae856 125
Edisonap 0:d3a0eceae856 126 void maxpos()
Edisonap 0:d3a0eceae856 127 {
Edisonap 0:d3a0eceae856 128 vertex2d(255 ,255,150);
Edisonap 0:d3a0eceae856 129 }
Edisonap 0:d3a0eceae856 130
Edisonap 0:d3a0eceae856 131 void home()
Edisonap 0:d3a0eceae856 132 { vertex2d(245,245,up);
Edisonap 0:d3a0eceae856 133 wait_ms(vel);
Edisonap 0:d3a0eceae856 134 }
Edisonap 0:d3a0eceae856 135
Edisonap 0:d3a0eceae856 136 void punto(uint8_t x, uint8_t y)
Edisonap 0:d3a0eceae856 137 {
Edisonap 0:d3a0eceae856 138 vertex2d(x,y,up);
Edisonap 0:d3a0eceae856 139 wait_ms(vel);
Edisonap 0:d3a0eceae856 140 vertex2d(x,y,down);
Edisonap 0:d3a0eceae856 141 wait_ms(vel);
Edisonap 0:d3a0eceae856 142 vertex2d(x,y,up);
Edisonap 0:d3a0eceae856 143 wait_ms(vel);
Edisonap 0:d3a0eceae856 144 }
Edisonap 0:d3a0eceae856 145
Edisonap 0:d3a0eceae856 146 void tiempo_paso(uint8_t tim)
Edisonap 0:d3a0eceae856 147 {
Edisonap 0:d3a0eceae856 148 vel = tim * 10;
Edisonap 0:d3a0eceae856 149 wait_ms(100);
Edisonap 0:d3a0eceae856 150 }
Edisonap 0:d3a0eceae856 151
Edisonap 0:d3a0eceae856 152
Edisonap 0:d3a0eceae856 153 void linea(uint8_t xi,uint8_t xf,uint8_t mi)
Edisonap 0:d3a0eceae856 154 {
Edisonap 0:d3a0eceae856 155 for(xi=xi;xi<=xf;xi++)
Edisonap 0:d3a0eceae856 156 {
Edisonap 0:d3a0eceae856 157 yip = mi*xi;
Edisonap 0:d3a0eceae856 158 vertex2d(xi,yip,down);
Edisonap 0:d3a0eceae856 159 wait_ms(30);
Edisonap 0:d3a0eceae856 160 }
Edisonap 0:d3a0eceae856 161 }
Edisonap 0:d3a0eceae856 162
Edisonap 0:d3a0eceae856 163 void cuadrado(uint8_t xi, uint8_t yi,uint8_t lenght)
Edisonap 0:d3a0eceae856 164 {
Edisonap 0:d3a0eceae856 165 xlado = lenght + xi;
Edisonap 0:d3a0eceae856 166 ylado = lenght + yi;
Edisonap 0:d3a0eceae856 167
Edisonap 0:d3a0eceae856 168 vertex2d(xi,yi,up);
Edisonap 0:d3a0eceae856 169 wait_ms(vel);
Edisonap 0:d3a0eceae856 170 vertex2d(xi,yi,down);
Edisonap 0:d3a0eceae856 171 wait_ms(vel);
Edisonap 0:d3a0eceae856 172 vertex2d(xlado,yi,down);
Edisonap 0:d3a0eceae856 173 wait_ms(vel);
Edisonap 0:d3a0eceae856 174 vertex2d(xlado,ylado,down);
Edisonap 0:d3a0eceae856 175 wait_ms(vel);
Edisonap 0:d3a0eceae856 176 vertex2d(xi,ylado,down);
Edisonap 0:d3a0eceae856 177 wait_ms(vel);
Edisonap 0:d3a0eceae856 178 vertex2d(xi,yi,down);
Edisonap 0:d3a0eceae856 179 wait_ms(vel);
Edisonap 0:d3a0eceae856 180 }
Edisonap 0:d3a0eceae856 181
Edisonap 0:d3a0eceae856 182 void resolucion(uint8_t xi)
Edisonap 0:d3a0eceae856 183 {
Edisonap 0:d3a0eceae856 184 p=xi;
Edisonap 0:d3a0eceae856 185 }
Edisonap 0:d3a0eceae856 186
Edisonap 0:d3a0eceae856 187
Edisonap 0:d3a0eceae856 188 void circulo(uint8_t x1, uint8_t y1,uint8_t r)
Edisonap 0:d3a0eceae856 189 {
Edisonap 0:d3a0eceae856 190 double x2,y2;
Edisonap 0:d3a0eceae856 191 vertex2d(x1 ,y1,up);
Edisonap 0:d3a0eceae856 192 wait(1);
Edisonap 0:d3a0eceae856 193 wait_ms(vel);
Edisonap 0:d3a0eceae856 194
Edisonap 0:d3a0eceae856 195 for ( x2=0;x2<=r;x2++){
Edisonap 0:d3a0eceae856 196 y2= pow(((r*r)-(x2*x2)),0.5);
Edisonap 0:d3a0eceae856 197 i= x2+x1;
Edisonap 0:d3a0eceae856 198 j=y1+y2;
Edisonap 0:d3a0eceae856 199 vertex2d(i ,j,down) ;
Edisonap 0:d3a0eceae856 200 wait_ms(30);
Edisonap 0:d3a0eceae856 201 }
Edisonap 0:d3a0eceae856 202
Edisonap 0:d3a0eceae856 203 for ( x2=r;x2>=0;x2--){
Edisonap 0:d3a0eceae856 204 y2= pow(((r*r)-(x2*x2)),0.5);
Edisonap 0:d3a0eceae856 205 i= x2+x1;
Edisonap 0:d3a0eceae856 206 j= y1 - y2;
Edisonap 0:d3a0eceae856 207 vertex2d(i ,j,down) ;
Edisonap 0:d3a0eceae856 208 wait_ms(30);
Edisonap 0:d3a0eceae856 209 }
Edisonap 0:d3a0eceae856 210
Edisonap 0:d3a0eceae856 211 for ( x2=0;x2<=r;x2++){
Edisonap 0:d3a0eceae856 212 y2= pow(((r*r)-(x2*x2)),0.5);
Edisonap 0:d3a0eceae856 213 i= x1- x2;
Edisonap 0:d3a0eceae856 214 j= y1 - y2;
Edisonap 0:d3a0eceae856 215 vertex2d(i ,j,down) ;
Edisonap 0:d3a0eceae856 216 wait_ms(30);
Edisonap 0:d3a0eceae856 217 }
Edisonap 0:d3a0eceae856 218 for ( x2=r;x2>=0;x2--){
Edisonap 0:d3a0eceae856 219 y2= pow(((r*r)-(x2*x2)),0.5);
Edisonap 0:d3a0eceae856 220 i= x1-x2;
Edisonap 0:d3a0eceae856 221 j=y1+y2;
Edisonap 0:d3a0eceae856 222 vertex2d(i ,j,down) ;
Edisonap 0:d3a0eceae856 223 wait_ms(30);
Edisonap 0:d3a0eceae856 224 }
Edisonap 0:d3a0eceae856 225 vertex2d(i ,j,up) ;
Edisonap 0:d3a0eceae856 226 wait_ms(vel);
Edisonap 0:d3a0eceae856 227
Edisonap 0:d3a0eceae856 228 if(x2==r)
Edisonap 0:d3a0eceae856 229 {
Edisonap 0:d3a0eceae856 230 wait(1);
Edisonap 0:d3a0eceae856 231 }
Edisonap 0:d3a0eceae856 232 }
Edisonap 0:d3a0eceae856 233
Edisonap 0:d3a0eceae856 234
Edisonap 0:d3a0eceae856 235 void command_exe()
Edisonap 0:d3a0eceae856 236 {
Edisonap 0:d3a0eceae856 237 #if DEBUG
Edisonap 0:d3a0eceae856 238 command.printf("Ejecutando comando: ");
Edisonap 0:d3a0eceae856 239 #endif
Edisonap 0:d3a0eceae856 240
Edisonap 0:d3a0eceae856 241 switch (buffer_command[COMM_N])
Edisonap 0:d3a0eceae856 242 {
Edisonap 0:d3a0eceae856 243
Edisonap 0:d3a0eceae856 244 case (LED_NC):
Edisonap 0:d3a0eceae856 245 #if DEBUG
Edisonap 0:d3a0eceae856 246 command.printf("LED on\n");
Edisonap 0:d3a0eceae856 247 #endif
Edisonap 0:d3a0eceae856 248 command_led(buffer_command[INITPARAMETER]);
Edisonap 0:d3a0eceae856 249 break;
Edisonap 0:d3a0eceae856 250
Edisonap 0:d3a0eceae856 251
Edisonap 0:d3a0eceae856 252 case (PUNTO):
Edisonap 0:d3a0eceae856 253 punto(buffer_command[INITPARAMETER],buffer_command[INITPARAMETER+1]);
Edisonap 0:d3a0eceae856 254 #if DEBUG
Edisonap 0:d3a0eceae856 255 command.printf("Dibujando punto");
Edisonap 0:d3a0eceae856 256 #endif
Edisonap 0:d3a0eceae856 257 break;
Edisonap 0:d3a0eceae856 258
Edisonap 0:d3a0eceae856 259
Edisonap 0:d3a0eceae856 260 case (LINEA):
Edisonap 0:d3a0eceae856 261 linea(buffer_command[INITPARAMETER],buffer_command[INITPARAMETER+1],buffer_command[INITPARAMETER+2]);
Edisonap 0:d3a0eceae856 262 #if DEBUG
Edisonap 0:d3a0eceae856 263 command.printf("Dibujando linea");
Edisonap 0:d3a0eceae856 264 #endif
Edisonap 0:d3a0eceae856 265 break;
Edisonap 0:d3a0eceae856 266
Edisonap 0:d3a0eceae856 267
Edisonap 0:d3a0eceae856 268 case (CUADRADO):
Edisonap 0:d3a0eceae856 269 cuadrado(buffer_command[INITPARAMETER],buffer_command[INITPARAMETER+1],buffer_command[INITPARAMETER+2]);
Edisonap 0:d3a0eceae856 270 #if DEBUG
Edisonap 0:d3a0eceae856 271 command.printf("Dibujando cuadrado");
Edisonap 0:d3a0eceae856 272 #endif
Edisonap 0:d3a0eceae856 273 break;
Edisonap 0:d3a0eceae856 274
Edisonap 0:d3a0eceae856 275
Edisonap 0:d3a0eceae856 276 case (CIRCULO):
Edisonap 0:d3a0eceae856 277 circulo(buffer_command[INITPARAMETER],buffer_command[INITPARAMETER+1],buffer_command[INITPARAMETER+2]);
Edisonap 0:d3a0eceae856 278 #if DEBUG
Edisonap 0:d3a0eceae856 279 command.printf("Dibujando circulo");
Edisonap 0:d3a0eceae856 280 #endif
Edisonap 0:d3a0eceae856 281 break;
Edisonap 0:d3a0eceae856 282
Edisonap 0:d3a0eceae856 283 case(HOME):
Edisonap 0:d3a0eceae856 284 home();
Edisonap 0:d3a0eceae856 285 #if DEBUG
Edisonap 0:d3a0eceae856 286 command.printf("Enviando a home");
Edisonap 0:d3a0eceae856 287 #endif
Edisonap 0:d3a0eceae856 288
Edisonap 0:d3a0eceae856 289 break;
Edisonap 0:d3a0eceae856 290
Edisonap 0:d3a0eceae856 291
Edisonap 0:d3a0eceae856 292 case (TIEMPO_PASO):
Edisonap 0:d3a0eceae856 293 tiempo_paso(buffer_command[INITPARAMETER]);
Edisonap 0:d3a0eceae856 294 #if DEBUG
Edisonap 0:d3a0eceae856 295 command.printf("cambio de tiempo realizado\vel");
Edisonap 0:d3a0eceae856 296 #endif
Edisonap 0:d3a0eceae856 297
Edisonap 0:d3a0eceae856 298 break;
Edisonap 0:d3a0eceae856 299
Edisonap 0:d3a0eceae856 300 default:
Edisonap 0:d3a0eceae856 301
Edisonap 0:d3a0eceae856 302 #if DEBUG
Edisonap 0:d3a0eceae856 303 command.printf("comando no encontrado\n");
Edisonap 0:d3a0eceae856 304 #endif
Edisonap 0:d3a0eceae856 305 }
Edisonap 0:d3a0eceae856 306 }
Edisonap 0:d3a0eceae856 307
Edisonap 0:d3a0eceae856 308
Edisonap 0:d3a0eceae856 309 int main()
Edisonap 0:d3a0eceae856 310 {
Edisonap 0:d3a0eceae856 311 #if DEBUG
Edisonap 0:d3a0eceae856 312 command.printf("inicio con debug\n");
Edisonap 0:d3a0eceae856 313 #else
Edisonap 0:d3a0eceae856 314 command.printf("inicio sin debug\n");
Edisonap 0:d3a0eceae856 315 #endif
Edisonap 0:d3a0eceae856 316 uint8_t val;
Edisonap 0:d3a0eceae856 317
Edisonap 0:d3a0eceae856 318
Edisonap 0:d3a0eceae856 319
Edisonap 0:d3a0eceae856 320
Edisonap 0:d3a0eceae856 321 while(1)
Edisonap 0:d3a0eceae856 322 {
Edisonap 0:d3a0eceae856 323 val=command.getc();
Edisonap 0:d3a0eceae856 324 if (val== '<'){
Edisonap 0:d3a0eceae856 325 Read_command();
Edisonap 0:d3a0eceae856 326 if (check_command())
Edisonap 0:d3a0eceae856 327 {
Edisonap 0:d3a0eceae856 328 command_exe();
Edisonap 0:d3a0eceae856 329 }
Edisonap 0:d3a0eceae856 330
Edisonap 0:d3a0eceae856 331 else
Edisonap 0:d3a0eceae856 332 {
Edisonap 0:d3a0eceae856 333 #if DEBUG
Edisonap 0:d3a0eceae856 334 command.printf("\n ERROR COMANDO -> ");
Edisonap 0:d3a0eceae856 335 echo_command();
Edisonap 0:d3a0eceae856 336 #endif
Edisonap 0:d3a0eceae856 337 }
Edisonap 0:d3a0eceae856 338 }
Edisonap 0:d3a0eceae856 339
Edisonap 0:d3a0eceae856 340 else
Edisonap 0:d3a0eceae856 341 {
Edisonap 0:d3a0eceae856 342 #if DEBUG
Edisonap 0:d3a0eceae856 343 command.printf("error de inicio de trama: ");
Edisonap 0:d3a0eceae856 344 command.putc(val);
Edisonap 0:d3a0eceae856 345 #endif
Edisonap 0:d3a0eceae856 346 }
Edisonap 0:d3a0eceae856 347 }
Edisonap 0:d3a0eceae856 348 }