edson antonio vargas villarreal / Mbed 2 deprecated primercorte

final nnnn

Dependencies:   mbed

Este proyecto es un Piccolo en el cual se envía comandos para la realización de un dibujo en especifico. El programa va a controlar servos y motores paso a paso teniendo libertad de movimiento en los ejes X,Y,Z; En el programa se utiliza Comunicacion Serial (TX,RX) y para leer el dato fue necesario concatenarlo debido a que recibe 8 Bits pero tenemos que recibir 4 paquetes de 8 Bits para llegar a 32 Bits y poder asi leerlo.

Se estan implementando algunas librerias para su ejecucion como la #include "memory.h" que es de memoria, #include memory_array_h, tambien definimos la memoria #define mm_size 10 de tipo Type Uint32_t, la libreria de operaciones #include "math.h" y la libreria para los motores #include "stepmotor.h".

Para su ejecucion se crearon variables de ejecucion:

CM_DRAWING 0XFF: Se ejecuta siempre y cuando exista datos validos para leer de memoria y nos muestra por medio de un mensaje que se esta ejecutando el dibujo

CM_SAVING 0XFE: Inicia el comando de guardar

CM_VERTEX2D 0XFD: Se encarga de dar las coordenadas a los servomotores en X,Y.

CM_DRAW 0XFC: Se encarga de mover nuestro motor en Z

CM_NODRAW 0XFB: Su funcion es volver a la posicion inicial el motor en el eje Z

CM_MOTOR 0XF9: Se encarga de mover los motores paso a paso para llegar a la ubicacion asignada ingresando el Numero de cuadrantes y su sentido de giro.

main.cpp

Committer:
ANTONIO_VARGAS
Date:
2018-04-26
Revision:
2:14fcd29abee0
Parent:
1:6ed951d975cc

File content as of revision 2:14fcd29abee0:

#include "mbed.h" 
#include "main.h" 
#include "stepmotor.h" 
  
Serial command(USBTX, USBRX);
stepmotor smotor1(D9,D10,D11,D12);

 
 
 
int main() {
    init_servo();
    init_serial();
    draw();
    nodraw();
    home();
    debug_m("inicio \n");// inicia 
    uint32_t read_cc;    //lee puerto serial lo que va a transmitir o recibir
    
    while(1)
    {
        read_cc=read_command();
        switch (read_cc) {
            case  CM_DRAWING: drawing(); break; 
            case  CM_SAVING: saving(); break;
            default: debug_m("error de comando. \nSe espera  0xFEF0 o 0xFFF0 \n");break ;      
        }
    }
}
 
 
 
uint32_t read_command()
{
   // retorna los byte recibidos concatenados en un entero, se reciben maximo 4 bytes,
   // recibe hasta que encuetra  un fin de comando "CM_END".
   // Ejemplo: para el comando drawing se 
   // espera un byte,  por lo que al recibir 0xFF y 0xF0 la funcióm  retorna el 0xff
   // siempre y cuando se reciba el fin de dato  F0 de lo contrario retorna un cero
   // para el caso del comando vertex2d se espera  recibir 3 bytes, 1 del comando 
   // y dos bytes para x y y, se retorna la concatenación de los tres bytes  siempre y
   // cuando el cuarto byte sea CM_END de lo contrario retorna un cero 
   //Se tienen 2 estados
   //uno espera datos y el otro ejecuta apenas recibe el puerto serial un comando
      
    uint32_t val=0;
    uint8_t  cnt=0;
      
    char endc=command.getc();
    
    while(endc != CM_END && cnt <4) {
    if(endc!=CM_END)   
        val=((val<<8) +endc);
     endc=command.getc();
     cnt++;
    }   
    if(endc==CM_END)   
        return val;
    return 0;   //al retornar 0 indica que  no se recibe el comando  
}
void init_serial()
{
    command.baud(9600);    
}
 
 
void drawing(){
    // la funcion se ejecuta siemrpe y cuando exista datos validos para leer de 
    // memoria 
    debug_m("se esta ejecutando el dibujo... \n");       
     
    uint8_t error=0;
    MEM_TYPE dato;
 
    tail_reset();
 
    while(error==0){
        error = mem_get(&dato);
        if (error==0) {
            
            switch (dato) {
            case  CM_DRAW: 
                    debug_m("-> Baja Z\n");
                    draw();
                    break ;     
            case  CM_NODRAW: 
                    debug_m("-> Sube Z\n");
                    nodraw();
                    break ;     
            
              
                
             default:  
                int y  = (uint8_t)(dato);
                int x  = (uint8_t)(dato>>8);
                char ncomm  = (uint8_t)(dato>>16);
                               
                if (ncomm == CM_VERTEX2D) {
                    debug_m("-> Mover piccolo x a %d y y a %d \n",x,x, y);
                    vertex2d(x,y);
                    
                }else if (ncomm == CM_MOTOR){
                    debug_m("-> mover motor paso a paso en x \n");
                    
                    smotor1.step(x*4096,(bool) y);
                    }
                    
                    debug_m("-> ERROR DE COMMANDO: %d %d %d \n " ,ncomm,x,y,y);
                break;   
             }
         }        
    }  
    
    debug_m("fin del comando dibujar..\n");    
    
}
 
 
void saving(){
    debug_m("se inicia el comando guardar..\n");    
    
    MEM_TYPE dato=0;
    mem_free();
    while(dato !=CM_STOP){
        dato = read_command();
        if (dato !=CM_STOP)
               mem_put(dato);
    }  
    debug_m("fin del comado guardar..\n");    
    
}
 
void debug_m(char *s , ... ){
    #if DEBUG
    command.printf(s);
    #endif  
}