DESPLAZAMIENTO PICCOLO

Dependencies:   mbed

Fork of 01-04EntregaPrimerCorte by ferney alberto beltran molina

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 
00003 #include "main.h"
00004 
00005 
00006 
00007 /*
00008 El sitema tiene tres estados:
00009 1. Standby: estado que indica que esta en espera de un telecomando (Ejecutar 0 guardar)
00010 2. Drawing: estado en donde el piccolo eejecuta las ordenes giardadas en el array 
00011             de memora hasta encontrar el comando CM_STOP 
00012 3. Saving:  estado donde el sistema recibe lso datos y lso almacena en memoria acorde 
00013             a los comandos de 0xfd, oxfc, 0xfb,0cfa, se sake de este modo cuado se recibe
00014             el comando CM_STOP
00015             
00016 todo telecomando debe finalizar con el dato CM_END
00017 */
00018 
00019 
00020 Serial command(USBTX, USBRX);
00021 
00022 
00023 
00024 int main() {
00025     init_servo();
00026     init_serial();
00027     draw();
00028     nodraw();
00029     home();
00030     debug_m("inicio \n");
00031     uint32_t read_cc;
00032     while(1)
00033     {
00034         read_cc=read_command();
00035         switch (read_cc) {
00036             case  CM_DRAWING: drawing(); break;
00037             case  CM_SAVING: saving(); break;
00038             default: debug_m("error de comando. \nSe espera  0xFEF0 o 0xFFF0 \n");break ;      
00039         }
00040     }
00041 }
00042 
00043 
00044 
00045 uint32_t read_command()
00046 {
00047    // retorna los byte recibidos concatenados en un entero, se reciben maximo 4 bytes,
00048    // recibe hasta que encuetra  un fin de comando "CM_END".
00049    // Ejemplo: para el comando drawing se 
00050    // espera un byte,  por lo que al recibir 0xFF y 0xF0 la funcióm  retorna el 0xff
00051    // siempre y cuando se reciba el fin de dato  F0 de lo contrario retorna un cero
00052    // para el caso del comando vertex2d se espera  recibir 3 bytes, 1 del comando 
00053    // y dos bytes para x y y, se retorna la concatenación de los tres bytes  siempre y
00054    // cuando el cuarto byte sea CM_END de lo contrario retorna un cero 
00055    
00056     uint32_t val=0;
00057     uint8_t  cnt=0;
00058     
00059     char endc=command.getc();
00060     
00061     while(endc != CM_END && cnt <4) {
00062     if(endc!=CM_END)   
00063         val=((val<<8) +endc);
00064      endc=command.getc();
00065      cnt++;
00066     }   
00067     if(endc==CM_END)   
00068         return val;
00069     return 0;   //al retornar 0 indica que  no se recibe el comando  
00070 }
00071 void init_serial()
00072 {
00073     command.baud(9600);    
00074 }
00075 
00076 
00077 void drawing()
00078 {
00079     // la funcion se ejecuta siemrpe y cuando exista datos validos para leer de 
00080     // memoria 
00081     debug_m("se esta ejecutando el dibujo... \n");       
00082      
00083     uint8_t error=0;
00084     MEM_TYPE dato;
00085 
00086     tail_reset();
00087 
00088     while(error==0){
00089         error = mem_get(&dato);
00090         if (error==0) {
00091             switch (dato) {
00092             case  CM_DRAW: 
00093                     debug_m("-> Baja Z\n");
00094                     draw();
00095                     break ;     
00096             case  CM_NODRAW: 
00097                     debug_m("-> Sube Z\n");
00098                     nodraw();
00099                     break ;     
00100             default: 
00101                 int y      = (uint8_t)(dato);
00102                 int x      = (uint8_t)(dato>>8);
00103                 char ncomm  = (uint8_t)(dato>>16);
00104                 
00105                 if (ncomm == CM_VERTEX2D) {
00106                     debug_m("-> Mover piccolo x a %d y y a %d \n",x,x, y);
00107                     vertex2d(x,y);
00108                                            }
00109                 else
00110                     debug_m("-> ERROR DE COMMANDO: %d %d %d \n " ,ncomm,x,y,y);
00111                 break;   
00112                            }
00113                        }        
00114                     }  
00115     
00116     debug_m("fin del comando dibujar..\n");    
00117     
00118 }
00119 
00120 
00121 void saving(){
00122     debug_m("se inicia el comado guardar..\n");    
00123     
00124     MEM_TYPE dato=0;
00125     mem_free();
00126     while(dato !=CM_STOP){
00127         dato = read_command();
00128         if (dato !=CM_STOP)
00129                mem_put(dato);
00130     }  
00131     debug_m("fin del comado guardar..\n");    
00132     
00133 }
00134 
00135 void debug_m(char *s , ... ){
00136     #if DEBUG
00137     command.printf(s);
00138     #endif  
00139 }