Programacion PICCOLO. Primer Corte, Sistemas Embebidos

Dependencies:   mbed

Homepage

/media/uploads/pablolopez89/m.jpg
PRIMER CORTE - SISTEMAS EMBEBIDOS. Universidad ECCI

INTRODUCCION: En la siguiente WIKI se presentara información acerca del desarrollo en su primera parte de un robot que tenga la capacidad de cumplir funciones de dibujo, todo esto a través de un entorno de programación llamado “MBED”, usando una tarjeta de programación llamada “STM32F446”.

WIKI PICCOLO

/media/uploads/pablolopez89/piccolo.jpg
Piccolo es un CNC portable que nos sirve para dibujar en 2D, formas o figuras que le pidamos, trabaja en base a movimientos de 3 servo motores que nos permiten realizar el dibujo por medio de una herramienta de dibujo, esta puede ser un lápiz, marcador, bolígrafo, etc.

OBJETIVOS
1. El ensamble en físico de un robot PICCOLO, con el chasis adecuado para que tenga la capacidad de tener movimiento en ejes x,y,z , programado desde una tarjeta stm , en lenguaje mbed.

OBJETIVOS ESPECIFICOS

1. El robot este en la capacidad de realizar movimientos por cuadrantes
2. Comunicación desde un mando de control
3. Las funciones del robot deben estar designadas dentro del código de programación tales como (Draw, no Draw, Vertex 2d, etc).
4. El almacenamiento de las funciones e información de utilidad del código debe estar almacenada en la memoria interna de la tarjeta STM de 32 BITS.
5. La comunicación debe serial asíncrona “UART”, para ello se debe lograr una sincronización de parametrizacion.

MATERIALES:

  • 3 servomotores
  • Acrílico cortado a medida (diseño del piccolo)
  • 1 tarjeta STM32F446
  • Tornillos cabeza estrella pala 1/8 + tuercas+ arandelas
  • Fuente de alimentación de 12 V DC
  • 1 cable v3

    MARCO TEORICO

    ARM mbed es una plataforma de IOT (internet of things), es una multiple colaboración entre personas a nivel mundial, tiene una gran comunidad de desarrolladores, un ecosistema de código abierto de IOT, una red de socios de hardware, productos y servicios que sirve al mercado relacionado de las “intertnet of things”, cuando se hablan de los elementos de mbed juntos, se habla acerca de la plataforma de dispositivos ARM, mbed OS, mbed DEVICE CONNECTOR SERVICE, mbed TLS y mbed CLIENT

    MARCO PROCEDIMENTAL

    1. Definir aquellas funciones dentro del código tales como “vertex2d” , “draw”, “no draw” , “ejecutar”, “guardar”, “fin”; las cuales cumplen con aquellas tareas que requiere la programación del robot, para su funcionamiento.
    2. Definir aquellos pines de comunicación entre la tarjeta y los servomotores
    3. Antes de almacenar dichas funciones mencionadas anteriormente dentro de una memoria es necesario asignarle un código hexadecimal a cada una de ellas de la siguiente forma: 0XFD, 0XFC, 0XFB, 0XFF, 0XFE, 0XFA.
    4. Hay que crear una memoria con la función “ARRAY”, de aproximadamente 19,2 KB, almacena 5000 instrucciones*32 B.
    5. Es necesario entablar una comunicación serial entre el ordenador y la tarjeta de programación, dicha comunicación es de tipo ASINCRONA “UART” (Es de ese tipo por que tanto el ordenador como la tarjeta poseen diferentes “CLK” o ciclos de reloj); configuraciones tales como el BAUD RATE (taza de transferencia), Bit de sincronización (par o impar), Bit de datos, Bit de paridad.

PROGRAMACION PICCOLO

main.cpp

#include "mbed.h"

#define POSMAX 50       // en milimetros
#define POSDRAW 30      // en milimetros
#define BAUD 9600      // Configuracion de baudios

#define CM_EJECUTAR 0xff    //FF Ejecutar
#define CM_GUARDAR 0xfe     //FE Guardar
#define CM_VERTEX2D 0xfd    //FD Vertex
#define CM_DRAW 0xfc        //FC Dibujo
#define CM_NODRAW 0xfb      //FB No Dibujo
#define CM_STOP 0xfa        //FA Parada
#define CM_END 0xf0         //F0 Fin de Linea

#define MEM_SIZE 10
#define MEM_TYPE uint32_t

int mem_head=0;
int mem_tail=0;
uint8_t full=0;

Serial pc(USBTX,USBRX); // Comunicación Serial
MEM_TYPE buffer[MEM_SIZE];

PwmOut ServoX(PB_3); //D3
PwmOut ServoY(PB_4); //D5
PwmOut ServoZ(PB_10); //D6

uint8_t  posx_old=0;     // posición anterior del eje X
uint8_t  posy_old=0;     // posición anterior del eje Y
uint8_t  ss_time=100;     // tiempo  de espera para moverse 1 mm en microsegundos

uint8_t mem_put(MEM_TYPE data)
{
    if (full)
        return 1;
    buffer[mem_head] = data;
    mem_head += 1;
    if (mem_head == MEM_SIZE)
        full =1;

    return 0;
}
uint8_t mem_get(MEM_TYPE* data)
{
    if (mem_head == 0)
        return 1; 
    if (mem_head == mem_tail)
        return 1; 
 
    *data = buffer[mem_tail];
    mem_tail += 1;

    return 0;
}
uint32_t mem_free()
{
 mem_head=0;
 full=0;
} 
void sstime(uint8_t x, uint8_t y)
{
    double dx=abs(x-posx_old);
    double dy=abs(y-posy_old);
    double dist= sqrt(dx*dx+dy*dy);
    wait_ms((int)(ss_time*dist));
    posx_old = x;
    posy_old= y;
   
}
int coord2pulse(float coord)      // conversión de coordenadas en Y
{
    if(0 <= coord <= POSMAX)
        return int(700+coord*1900/50);
    return 700;
}
void vertex2d(uint8_t x, uint8_t y)     // Funcion de llamado de conversiones  X y Y
{                                   
    int pulseX = coord2pulse(x);
    int pulseY = coord2pulse(y);
    ServoX.pulsewidth_us(pulseX);
    ServoY.pulsewidth_us(pulseY);
    sstime(x,y);
    //wait_ms(ss_time);
}
void draw() // Función para enviarle la posicion  de dibujo a Z, lo mueve hacia abajo. 
    {
    ServoZ.pulsewidth_us(2500);
    pc.printf(" Dibujando...");
    wait_ms(ss_time*2);
    }
void nodraw() // Función para enviarle la posicion de no dibujar a  Z, lo mueve hacia arriba. 
    {     
    ServoZ.pulsewidth_us(700);
    pc.printf(" Dibujo Terminado...");
    wait_ms(ss_time*2);
    }
void ejecutar()
{
    pc.printf("se esta ejecutando el dibujo...");    
    
    uint32_t mem_free();
     
     while  (pc.getc() != CM_END)
        {
            void initdraw();    // posicion inicio de dibujo
            void memory();      //revisar memoria
            void dinamic ();    //memoria dinamica
            uint8_t mem_get (); //leer
                        
            switch (pc.getc())
            {
                 case CM_VERTEX2D:
                      
                      for (int i=0; i<4; i++){
                          void vertex2d(uint8_t x, uint8_t y);
                          }
                      break;
                 case CM_DRAW:
                      void draw ();
                      break;
                 case CM_NODRAW:
                      void nodraw ();
                      break;
                 default:
                      pc.printf("error de comando");
                      break ;     
            }
        }
}
void guardar()
{
    pc.printf("se inicia el comado de guardar..");    

    uint32_t mem_free();  
       while  (pc.getc() != CM_END)
        {
            void initdraw();  //posicion incial de dibujo
            void memory();
            void dinamic ();
            uint8_t mem_put(); //escribir
                        
         }   
}
void init_serial()      // configuracion de  baudios a pc
{
    pc.baud(BAUD);    
}
void init_servos()      // configuracion de  periodo
{
    ServoX.period_ms(20);
    ServoY.period_ms(20);
    ServoZ.period_ms(20);  
}
void init_draw(float x, float y)
{
    vertex2d (x,y);
    wait_ms(ss_time);
    draw();
}
void home()
{
    nodraw();
    vertex2d(0,0);
    pc.printf("Posicion Home");
    wait_ms(ss_time);
}
void put_sstime(uint8_t vtime)
{
    ss_time=vtime;
   
}
void parada ()
{   //subprograma de parada
    pc.printf("finalizando programa..");  
    uint32_t mem_free(); 
    void nodraw();
    void home();
}
void dinamic ()  // memoria dinamica de 32 bits
{
        int temp = pc.getc();
            
            temp = temp<<8 + pc.getc();
            temp = temp<<8 + pc.getc();
            temp = temp<<8 + pc.getc();
            temp = temp<<8 + pc.getc();
} 
void memory ()  // memoria  para obtener el dato
{     
        mem_put(pc.getc());
        mem_put(pc.getc());
        mem_put(pc.getc());
        mem_put(pc.getc());
        MEM_TYPE val;
        mem_get(&val);
        pc.putc(val);
}

int main() 
{       // programa para reconocer efecutar o guardar
    init_servos();
    init_serial();
    home();
    pc.printf ("inicializacion");
    char read_cc;
    while(1)
    {
        read_cc = pc.getc();
        switch (read_cc) {
            case  CM_EJECUTAR: ejecutar(); break;
            case  CM_GUARDAR: guardar(); break;
            case  CM_STOP: parada (); break;
            default: pc.printf("error de comando");break ;      
        }
    }
}

Pablo Lopez - Felipe Gomez - Steev Blanco


All wikipages