04_main.cpp

00001 #include "mbed.h"
00002 #include "draw.h"
00003 #include "stepmotor.h"
00004 //#include<string>
00005 
00006 #define CM_ENTER 0xF0
00007 #define CM_PLAY 0xF6
00008 #define CM_PAUSE 0xF7
00009 #define CM_GIRO 0xF8
00010 #define CM_TRASLADAR 0xF9
00011 #define CM_STOP 0xFA
00012 #define CM_NODRAW 0xFB
00013 #define CM_DRAW 0XFC
00014 #define CM_VERTEX2D 0xFD
00015 #define CM_GUARDAR 0xFE
00016 #define CM_EJECUTAR 0xFF
00017 
00018 #define MEM_SIZE 100
00019 #define MEM_TYPE uint32_t   //significa que de ahora en más donde diga MEM_TYPE será tipo uint32_t
00020 #define PASOSxCUADRANTE 1000 //4096
00021 uint8_t mem_head = 0;
00022 uint8_t mem_tail = 0;
00023 char temp;
00024 bool full = 0;
00025 int valor=1;
00026 uint32_t cuadrantes = 0;
00027 bool direccion = 0;
00028 
00029 MEM_TYPE buffer[MEM_SIZE];
00030 stepmotor smotor1(D9, D10, D11, D12);
00031 stepmotor smotor2(D2, D6, D7, D8);
00032 Serial command(PC_10, PC_11, 9600);
00033 Serial letrero(PC_12, PD_2, 9600);
00034 
00035 Thread hilo1;
00036 
00037 void giroIzq()
00038 {
00039     smotor1.step(1000, 1);
00040 }
00041 
00042 void stepforward()
00043 {
00044     smotor1.step(cuadrantes * PASOSxCUADRANTE, !direccion);
00045     hilo1.join();
00046 }
00047 
00048 int dec2hex(char data)
00049 {
00050     int dividendo = (int)data;
00051     int cociente = dividendo / 16;
00052     int residuo = dividendo % 16;
00053     dividendo = cociente * 10 + residuo;
00054     //cociente=dividendo/16;
00055     //residuo=dividendo%16;
00056     //letrero.printf("%X = %d\n",data,dividendo);
00057     return dividendo;
00058 }
00059 
00060 void giroDer()
00061 {
00062     smotor1.step(1000, 0);
00063 }
00064 
00065 void girar(uint8_t sentido)
00066 {
00067     letrero.printf(">>>> %d \n", sentido);
00068     uint32_t speed = 1500;
00069     smotor1.set_speed(speed);
00070     smotor2.set_speed(speed);
00071     if (sentido == 1)
00072     {
00073         letrero.printf("pa la derecha!!\n");
00074         hilo1.start(giroIzq);
00075         smotor2.step(1000, 1);
00076     }
00077     else
00078     {
00079         letrero.printf("pa la izquierda!\n");
00080         hilo1.start(giroDer);
00081         smotor2.step(1000, 0);
00082     }
00083     wait(2);
00084 }
00085 
00086 void mem_free()
00087 { //Estaba como uint32_t no como void
00088     mem_head = 0;
00089     full = 0;
00090 }
00091 
00092 bool mem_put(MEM_TYPE data)
00093 { //Escribir
00094     if (full)
00095         return 1;
00096     buffer[mem_head] = data; //carga en dato en el buffer
00097     mem_head += 1;
00098     if (mem_head == MEM_SIZE)
00099         full = 1;
00100     return 0;
00101 }
00102 
00103 bool mem_get(MEM_TYPE *data)
00104 { //Leer
00105     if (mem_head == 0)
00106         return 1;
00107     if (mem_head == mem_tail)
00108         return 1;
00109     *data = buffer[mem_tail];
00110     mem_tail += 1;
00111     return 0;
00112 }
00113 
00114 void Rx_interrupt()
00115 {
00116     char raw_data;
00117     raw_data = command.getc();
00118     letrero.printf(">>>>");
00119     switch (raw_data)
00120     {
00121         case CM_PAUSE:
00122             valor=0;
00123             break;
00124         case CM_PLAY:
00125             valor=1;
00126             break;      
00127         default:
00128             break;
00129     }
00130     return;
00131 }
00132 
00133 //quitar el for y poner un do,while
00134 //crear una variable global que sea la que le aumenta o no al j
00135 //así en la función de interrupción se cambia esa variable de 0 a 1 dependiendo si se quiere sumar o no
00136 
00137 void ejecutar()
00138 {
00139     letrero.printf("inicio de ejecutar...\n");
00140     int j=0;
00141     do
00142     {
00143         letrero.attach(&Rx_interrupt, Serial::RxIrq);
00144         if (buffer[j] == CM_NODRAW)
00145         {
00146             nodraw();
00147         }
00148         if (buffer[j] == CM_DRAW)
00149         {
00150             draw();
00151         }
00152         if (buffer[j] == CM_STOP)
00153         {
00154             mem_free();
00155             return;
00156         }
00157         temp = buffer[j] >> 24 & 0xFF;
00158         if (temp == CM_VERTEX2D)
00159         {
00160             uint8_t datoX = buffer[j] >> 16 & 0xFF;
00161             uint8_t datoY = buffer[j] >> 8 & 0xFF;
00162             vertex2d(datoX, datoY);
00163         }
00164         if (temp == CM_TRASLADAR) //no mover si draw se encuentra activo
00165         {
00166             uint32_t speed = 1500;
00167             smotor1.set_speed(speed);
00168             smotor2.set_speed(speed);
00169             cuadrantes = buffer[j] >> 16 & 0xFF;
00170             direccion = buffer[j] >> 8 & 0xFF;
00171             hilo1.start(stepforward);
00172             smotor2.step(cuadrantes * PASOSxCUADRANTE, direccion);
00173             wait(1);
00174         }
00175     j+=valor;
00176     }while(j <= mem_head);
00177     letrero.printf("fin de ejecutar...\n");
00178     mem_free();
00179 }
00180 
00181 void guardar()
00182 {
00183     letrero.printf("inicio de guardar...\n");
00184     MEM_TYPE val; //significa que la variable "val" es del tipo uint32_t
00185     char dato1, dato2;
00186     do
00187     {
00188         dato1 = command.getc();
00189         letrero.printf("%X\n",dato1);
00190         if (dato1 == CM_STOP)
00191         {
00192             dato2 = command.getc();
00193             if (dato2 == CM_ENTER)
00194             {
00195                 val = dato1;
00196                 mem_put(val);
00197                 full = 1;
00198             }
00199         }
00200         if (dato1 == CM_NODRAW | dato1 == CM_DRAW)
00201         {
00202             dato2 = command.getc();
00203             if (dato2 == CM_ENTER)
00204             {
00205                 val = dato1;
00206                 mem_put(val);
00207             }
00208         }
00209         if (dato1 == CM_VERTEX2D)
00210         {
00211             dato2 = command.getc();
00212             if (dec2hex(dato2) <= 50)
00213             {
00214                 val = CM_VERTEX2D;
00215                 val = val << 8;
00216                 val = val | dato2;
00217                 dato2 = command.getc();
00218                 if (dec2hex(dato2) <= 50)
00219                 {
00220                     val = val << 8;
00221                     val = val | dato2;
00222                     dato2 = command.getc();
00223                     if (dato2 == CM_ENTER)
00224                     {
00225                         val = val << 8;
00226                         val = val | CM_ENTER;
00227                         mem_put(val);
00228                     }
00229                 }
00230             }
00231         }
00232         if (dato1 == CM_TRASLADAR)
00233         {
00234             dato2 = command.getc();
00235             if (dato2 <= 0xEF)
00236             {
00237                 val = CM_TRASLADAR;
00238                 val = val << 8;
00239                 val = val | dato2;
00240                 dato2 = command.getc();
00241                 if (dato2 <= 1)
00242                 {
00243                     val = val << 8;
00244                     val = val | dato2;
00245                     dato2 = command.getc();
00246                     if (dato2 == CM_ENTER)
00247                     {
00248                         val = val << 8;
00249                         val = val | CM_ENTER;
00250                         mem_put(val);
00251                     }
00252                 }
00253             }
00254         }
00255     } while (!full);
00256     letrero.printf("fin de guardar...\n");
00257 }
00258 
00259 int main()
00260 {
00261     //command.baud(9600);
00262     init_servo();
00263     //home(); //llama a no_draw y va a 0,0
00264 
00265     char read_cc;
00266     while (1)
00267     {
00268         read_cc = command.getc();
00269         switch (read_cc)
00270         {
00271         case CM_GUARDAR:
00272             if (read_cc = command.getc() == CM_ENTER)
00273             {
00274                 guardar();
00275             }
00276             break; //FE
00277         case CM_EJECUTAR:
00278             if (read_cc = command.getc() == CM_ENTER)
00279             {
00280                 ejecutar();
00281             }
00282             break; //FF
00283         case CM_GIRO:
00284             uint8_t sentido = command.getc();
00285             if (sentido <= 1)
00286             {
00287                 read_cc = command.getc();
00288                 if (read_cc = command.getc() == CM_ENTER)
00289                 {
00290                     girar(sentido);
00291                 }
00292             }
00293             break; //F8
00294         default:
00295             letrero.printf("Paila \n");
00296             break;
00297         }
00298     }
00299 }
00300 /*
00301 FE F0 FD 12 34 F0 FB F0 FD 0A 0A F0 FD 28 0A F0 FD 28 28 F0 FD 0A 28 F0 F9 27 00 F0 FC F0 FA F0 FF F0
00302 FE F0 FD 12 34 F0 FC F0 FD 10 10 F0 FD 40 10 F0 FD 40 40 F0 FD 10 40 F0 FB F0 F9 05 00 F0 FA F0 FF F0
00303 FE F0 FD 10 10 F0 FC F0 FD 40 10 F0 FD 40 40 F0 FD 10 40 F0 FD 10 10 F0 FB F0 FA F0 FF F0 //cuadrado
00304 FE F0 FD 10 10 F0 FC F0 FD 40 10 F0 FD 25 40 F0 FD 10 10 F0 FB F0 FA F0 FF F0 //triángulo
00305 FE F0 F9 02 00 F0 F9 02 01 F0 F9 01 01 F0 F9 01 00 F0 FA F0 FF F0 //prueba trasladar
00306     https://os.mbed.com/users/fabeltranm/
00307 */
00308 /*
00309 #include "mbed.h"
00310 
00311 void print_char(char c = '*')
00312 {
00313     printf("%c", c);
00314     fflush(stdout);
00315 }
00316 
00317 Thread thread;
00318 
00319 DigitalOut led1(LED1);
00320 
00321 void print_thread()
00322 {
00323     while (true) {
00324         wait(1);
00325         print_char();
00326     }
00327 }
00328 
00329 int main()
00330 {
00331     printf("\n\n*** RTOS basic example ***\n");
00332 
00333     thread.start(print_thread);
00334 
00335     while (true) {
00336         led1 = !led1;
00337         wait(0.5);
00338     }
00339 }
00340 */