« anterior próximo »
Páginas: [1]   Ir Abajo

Autor Tema: Problema con comunicacion USB  (Leído 2147 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado lemp9002

  • PIC10
  • *
  • Mensajes: 8
Problema con comunicacion USB
« en: 19 de Septiembre de 2012, 14:22:43 »
Hola a todos
Estoy trabajando en un programa implementando la comunicacion USB entre el PIC18F4550 y la PC, la idea que hice fue que la PC controle dicha comunicacion, es decir la PC configura la trama de datos y la envia, el PIC la recibe realiza la accion y una vez que termina la accion confirma hacia la PC, lo que me esta pasando es que el PIC se queda confirmando siempre, al principio pense que era problema en la logica que aplique en el programa, pero ahora pongo el PIC a que confirme una sola vez y nada se queda confirmando siempre, es decir el PIC siempre me esta mandando la trama de confirmacion hacia la PC, mi pregunta es existe alguna forma de controlar dicho proceso, estuve leyendo en el datasheet del PIC y vi algunos bit de bandera que a lo mejor tengo que limpiar una vez que envie la trama pero no se cual usar.
Por favor si alguien me pudiera explicar como darle solucion al problema se lo agradeceria mucho.
de antemano disculpen la explicacion extensa, saludos y muchas gracias
En línea

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Problema con comunicacion USB
« Respuesta #1 en: 19 de Septiembre de 2012, 14:24:12 »
En que compilador? Como sería el código que utilizas?
En línea
No contesto mensajes privados, las consultas en el foro

Desconectado lemp9002

  • PIC10
  • *
  • Mensajes: 8
Re: Problema con comunicacion USB
« Respuesta #2 en: 19 de Septiembre de 2012, 14:37:33 »
hola Suky
el compilador que uso es el CCS, utilizo la funcion usb_put_packet() ya que la trama es pequeña, el codigo es muy largo ya que esa idea la estoy implementando dentro del programa de un CNC, para la aplicacion en la PC estoy utilizando C++Builder 6...
En línea

Desconectado lemp9002

  • PIC10
  • *
  • Mensajes: 8
Re: Problema con comunicacion USB
« Respuesta #3 en: 19 de Septiembre de 2012, 14:42:00 »
#include "ploter.h"
#include <LCD.C>
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// CCS Library dynamic defines.  For dynamic configuration of the CCS Library
// for your application several defines need to be made.  See the comments
// at usb.h for more information
//
///////////////////////////////////////////////////////////////////////////////////////////////////
#define USB_HID_DEVICE     FALSE             // deshabilitamos el uso de las directivas HID
#define USB_EP1_TX_ENABLE  USB_ENABLE_BULK   // turn on EP1(EndPoint1) for IN bulk/interrupt transfers
#define USB_EP1_RX_ENABLE  USB_ENABLE_BULK   // turn on EP1(EndPoint1) for OUT bulk/interrupt transfers
#define USB_EP1_TX_SIZE    32                // size to allocate for the tx endpoint 1 buffer
#define USB_EP1_RX_SIZE    32                // size to allocate for the rx endpoint 1 buffer

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Include the CCS USB Libraries.  See the comments at the top of these
// files for more information
//
///////////////////////////////////////////////////////////////////////////////////////////////////
#include <pic18_usb.h>                      // Microchip PIC18Fxx5x Hardware layer for CCS's PIC USB driver
#include ".\include\rr2_USB_Monitor.h"      // Configuración del USB y los descriptores para este dispositivo
#include <usb.c>                           // handles usb setup tokens and get descriptor reports

#define RecCommand   recbuf[0]
#define COMMAND_LED          1
#define COMMAND_FIRMWARE     2
#define COMMAND_STRING_RS232 3

const int8 Lenbuf = 32;
char Version[] = "v.1.2";
char ConfOrg = '*';
int  i;
int k;

int8 recbuf[Lenbuf];
int8 sndbuf[Lenbuf];

//...Variables
short flag_cambiar_sentidoZ;
short flag_cambiar_sentidoY;
short flag_cambiar_sentidoX;
short flag_Z;
short flag_Y;
short flag_X;
short flag_inicio;
short flag_alarma_X;
short flag_alarma_Y;
short flag_alarma_Z;
short flag_fin_mov_X;
short flag_fin_mov_Y;
short flag_fin_mov_Z;

unsigned int pasoZ;
unsigned int pasoY;
unsigned int pasoX;
unsigned int velocidad;
unsigned int relX;
unsigned int relY;
unsigned int difX;
unsigned int difY;

unsigned int unidadesX;
unsigned int decenasX;
unsigned long centenasX;
unsigned long millaresX;
unsigned long millonX;

unsigned int unidadesY;
unsigned int decenasY;
unsigned long centenasY;
unsigned long millaresY;
unsigned long millonY;

long movX;
long movY;
long movZ;


//prototipos de funciones
void Inicio(void);

void main()
{
   Inicio();

   printf(lcd_putc,"\fV: %s",Version);
   delay_ms(1000);
   
   printf(lcd_putc,"\fusb_init()");
   usb_init();
   delay_ms(1000);
   
   printf(lcd_putc,"\fusb_task()");
   usb_task();
   delay_ms(1000);
   
   printf(lcd_putc,"\fusb_enumeration()");
   usb_wait_for_enumeration();
   delay_ms(1000);

   while(1)
   {
      if(usb_enumerated())
         {
            if (usb_kbhit(1))
            {
               for(i = 0; i<Lenbuf; i++)
               {
                  recbuf = '\0';      
               }
               
               // Recibe Packet
               usb_get_packet(1, recbuf, Lenbuf);
                              

            //Analizo la trama recivida
            if(recbuf[0] == 'i')
            {
               Inicio();
            }

            if(recbuf[0] == 'z')
            {
               flag_cambiar_sentidoZ = recbuf[1];
            }
            
            //conformo la X
            if(recbuf[0] == 'x')
            {
               flag_cambiar_sentidoX = (recbuf[1]-48);      
               relX = 0;
               difX = (recbuf[2]-48);
               k = 3;
otro:            if(recbuf[k] != 'f')
               {
                  k++;
                  goto otro;
               }
               k--;
               if(k == 7)
               {
                  unidadesX = (recbuf[7]-48);
                  decenasX = ((recbuf[6]-48)*10);
                  centenasX = ((recbuf[5]-48)*100);
                  millaresX = ((recbuf[4]-48)*1000);
                  millonX = ((recbuf[3]-48)*10000);
               }
               if(k == 6)
               {
                  unidadesX = (recbuf[6]-48);
                  decenasX = ((recbuf[5]-48)*10);
                  centenasX = ((recbuf[4]-48)*100);
                  millaresX = ((recbuf[3]-48)*1000);
               }
               if(k == 5)
               {
                  unidadesX = (recbuf[5]-48);
                  decenasX = ((recbuf[4]-48)*10);
                  centenasX = ((recbuf[3]-48)*100);
               }
               if(k == 4)
               {
                  unidadesX = (recbuf[4]-48);
                  decenasX = ((recbuf[3]-48)*10);
               }
               if(k == 3)
               {
                  unidadesX = (recbuf[3]-48);
               }
               
               movX = millonX + millaresX + centenasX + decenasX + unidadesX;   
            }

            //conformo la Y
            if(recbuf[0] == 'y')
            {
               flag_cambiar_sentidoY = (recbuf[1]-48);
               relY = (recbuf[2]-48);
               difY = (recbuf[2]-48);
               k = 3;
next:            if(recbuf[k] != 'f')
               {
                  k++;
                  goto next;
               }
               k--;
               if(k == 7)
               {
                  unidadesY = (recbuf[7]-48);
                  decenasY = ((recbuf[6]-48)*10);
                  centenasY = ((recbuf[5]-48)*100);
                  millaresY = ((recbuf[4]-48)*1000);
                  millonY = ((recbuf[3]-48)*10000);
               }
               if(k == 6)
               {
                  unidadesY = (recbuf[6]-48);
                  decenasY = ((recbuf[5]-48)*10);
                  centenasY = ((recbuf[4]-48)*100);
                  millaresY = ((recbuf[3]-48)*1000);
               }
               if(k == 5)
               {
                  unidadesY = (recbuf[5]-48);
                  decenasY = ((recbuf[4]-48)*10);
                  centenasY = ((recbuf[3]-48)*100);
               }
               if(k == 4)
               {
                  unidadesY = (recbuf[4]-48);
                  decenasY = ((recbuf[3]-48)*10);
               }
               if(k == 3)
               {
                  unidadesY = (recbuf[3]-48);
               }
               
               movY = millonY + millaresY + centenasY + decenasY + unidadesY;   
            }
            
            if(recbuf[0] == 'e')
            {
               flag_inicio = 1;
               for(i = 0; i<Lenbuf; i++)
                  {
                     recbuf = '\0';      
                  }
            }
            }
         }
     
      if(flag_inicio == 1)
      {
            //...Movimiento del motor Z
            if(flag_cambiar_sentidoZ == 0)
            {
               switch(pasoZ)    //sentido hacia el origen
               {
                  case 0x01:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x90);
                                 pasoZ = 2;
                              }
                           break;   
                  case 0x02:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x80);
                                 pasoZ = 3;
                              }
                           break;
                  case 0x03:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0xA0);
                                 pasoZ = 4;
                              }
                           break;
                  case 0x04:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x20);
                                 pasoZ = 5;
                              }
                           break;
                  case 0x05:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x60);
                                 pasoZ = 6;
                              }
                           break;
                  case 0x06:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x40);
                                 pasoZ = 7;
                              }
                           break;
                  case 0x07:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x50);
                                 pasoZ = 8;
                              }
                           break;
                  case 0x08:   delay_ms(velocidad);
                           if(finZ1 == 0)
                           {
                              flag_Z = 1;
                           }
                           else
                              {
                                 PORTD = ((PORTD & 0x0F)|0x10);
                                 pasoZ = 1;
                              }
                           break;
                  case 0x09:   pasoZ = 1;
                           break;
               }
            }
            else
                  {
                     switch(pasoZ)    //sentido hacia la alarma
                     {
                        case 0x00:   pasoZ = 8;
                                 break;
                        case 0x01:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x90);
                                       pasoZ = 8;
                                    }
                                 }
                                 break;   
                        case 0x02:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x80);
                                       pasoZ = 1;
                                    }
                                 }
                                 break;
                        case 0x03:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0xA0);
                                       pasoZ = 2;
                                    }
                                 }
                                 break;
                        case 0x04:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x20);
                                       pasoZ = 3;
                                    }
                                 }
                                 break;
                        case 0x05:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x60);
                                       pasoZ = 4;
                                    }
                                 }
                                 break;
                        case 0x06:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x40);
                                       pasoZ = 5;
                                    }
                                 }
                                 break;
                        case 0x07:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x50);
                                       pasoZ = 6;
                                    }
                                 }
                                 break;
                        case 0x08:   delay_ms(velocidad);
                                 if(finZ2 == 0)
                                 {
                                    flag_alarma_Z = 1;
                                 }
                                 else
                                 {
                                    if(movZ != 0)
                                    {
                                       movZ--;
                                       PORTD = ((PORTD & 0x0F)|0x10);
                                       pasoZ = 7;
                                    }
                                 }
                                 break;
                     }
                  }//end del else Z      

            //...Movimiento del motor Y
            if(flag_cambiar_sentidoY == 0)
            {
               switch(pasoY)    //sentido hacia la alarma
               {
                  case 0x01:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                    relY--;
                                    movY--;
                                    PORTD = ((PORTD & 0xF0)|0x09);
                                    pasoY = 2;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;   
                  case 0x02:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x08);
                                       pasoY = 3;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x03:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x0A);
                                       pasoY = 4;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x04:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x02);
                                       pasoY = 5;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x05:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x06);
                                       pasoY = 6;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x06:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x04);
                                       pasoY = 7;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x07:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x05);
                                       pasoY = 8;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x08:   delay_ms(velocidad);
                           if(finY1 == 0)
                           {
                              flag_alarma_Y = 1;
                           }
                           else
                              {
                                 if(relX == 0)
                                 {
                                 if(movY != 0)
                                 {
                                       relY--;
                                       movY--;
                                       PORTD = ((PORTD & 0xF0)|0x01);
                                       pasoY = 1;
                                    if(relY == 0)
                                    {
                                       relX = difX;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_Y = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x09:   pasoY = 1;
                           break;
               }
            }
            else
                  {
                     switch(pasoY)    //sentido hacia el origen
                     {
                        case 0x00:   pasoY = 8;
                                 break;
                        case 0x01:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x09);
                                          pasoY = 8;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;   
                        case 0x02:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x08);
                                          pasoY = 1;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x03:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x0A);
                                          pasoY = 2;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x04:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x02);
                                          pasoY = 3;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x05:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x06);
                                          pasoY = 4;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x06:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x04);
                                          pasoY = 5;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x07:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x05);
                                          pasoY = 6;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x08:   delay_ms(velocidad);
                                 if(finY2 == 0)
                                 {
                                    flag_Y = 1;
                                    relY = 0;
                                 }
                                 else
                                    {
                                       if(relX == 0)
                                       {
                                       if(movY != 0)
                                       {
                                          relY--;
                                          movY--;
                                          PORTD = ((PORTD & 0xF0)|0x01);
                                          pasoY = 7;
                                          if(relY == 0)
                                          {
                                             relX = difX;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_Y = 1;
                                          }
                                       }
                                    }
                                 break;
                     }
                  }//end del else Y

            //...Movimiento del motor X
            if(flag_cambiar_sentidoX == 0)
            {
               switch(pasoX)    //sentido hacia la alarma
               {
                  case 0x01:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x09);
                                       pasoX = 2;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;   
                  case 0x02:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x08);
                                       pasoX = 3;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x03:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x0A);
                                       pasoX = 4;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x04:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x02);
                                       pasoX = 5;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x05:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x06);
                                       pasoX = 6;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x06:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x04);
                                       pasoX = 7;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x07:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x05);
                                       pasoX = 8;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x08:   delay_ms(velocidad);
                           if(finX1 == 0)
                           {
                              flag_alarma_X = 1;
                           }
                           else
                              {
                                 if(relY == 0)
                                 {
                                 if(movX != 0)
                                 {
                                       relX--;
                                       movX--;
                                       PORTA = ((PORTA & 0xF0)|0x01);
                                       pasoX = 1;
                                    if(relX == 0)
                                    {
                                       relY = difY;
                                    }
                                 }
                                 else
                                    {
                                       flag_fin_mov_X = 1;
                                    }
                                 }
                              }
                           break;
                  case 0x09:   pasoX = 1;
                           break;
               }
            }
            else
                  {
                     switch(pasoX)   //Sentido hacia el origen
                     {
                        case 0x00:   pasoX = 8;
                                 break;
                        case 0x01:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x09);
                                          pasoX = 8;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;   
                        case 0x02:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {   
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x08);
                                          pasoX = 1;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x03:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {   
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x0A);
                                          pasoX = 2;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x04:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x02);
                                          pasoX = 3;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x05:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x06);
                                          pasoX = 4;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x06:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x04);
                                          pasoX = 5;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x07:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x05);
                                          pasoX = 6;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                        case 0x08:   delay_ms(velocidad);
                                 if(finX2 == 0)
                                 {
                                    flag_X = 1;
                                    relX = 0;
                                 }
                                 else
                                    {
                                       if(relY == 0)
                                       {
                                       if(movX != 0)
                                       {
                                          relX--;
                                          movX--;
                                          PORTA = ((PORTA & 0xF0)|0x01);
                                          pasoX = 7;
                                          if(relX == 0)
                                          {
                                             relY = difY;
                                          }
                                       }
                                       else
                                          {
                                             flag_fin_mov_X = 1;
                                          }
                                       }
                                    }
                                 break;
                     }
                  }//end del else X
      }//end flag_inicio

      if((flag_X == 1) && (flag_Y == 1) && (flag_Z == 1))
      {
         printf(lcd_putc,"\fPunto de Origen");
         printf(lcd_putc,"\nEsperando datos");
         usb_put_packet(1,ConfOrg,6,USB_DTS_TOGGLE);
      }
      
      if((flag_alarma_X == 1) || (flag_alarma_Y == 1))
      {
         printf(lcd_putc,"\f Alarma");
      }
      else
         {
            //printf(lcd_putc,"\f%s %d %d%d%d", recbuf, flag_cambiar_sentidoX, flag_cambiar_sentidoY, flag_cambiar_sentidoZ, flag_inicio);
            //printf(lcd_putc,"\n%Ld %Ld %d%d %d%d", movY, movX, difX, difY, relX, relY);
         }

      if(flag_fin_mov_X == 1)
      {
         relX = 0;
         printf(lcd_putc,"\fFin mov X");
      }

      if(flag_fin_mov_Y == 1)
      {
         relY = 0;
         printf(lcd_putc,"\nFin mov Y");
      }

      if((flag_fin_mov_X == 1) && (flag_fin_mov_Y == 1))
      {
         flag_inicio = 0;
         flag_fin_mov_Y = 0;
         flag_fin_mov_X = 0;
         printf(lcd_putc,"\fEsperando dato");
      }

      if(tecla1 == 0)   //tecla inicio
      {
         delay_ms(20);
         if(tecla1 == 0)
         {
            pasoZ = 1;
            pasoY = 1;
            pasoX = 1;
            flag_cambiar_sentidoY = 0;
            flag_cambiar_sentidoZ = 1;
            flag_cambiar_sentidoX = 0;
            flag_inicio = 1;
            movX = 2000;
            movY = 1000;
         }
      }
   

      if(tecla2 == 0)
      {
         delay_ms(20);
         if(tecla2 == 0)
         {
            if(flag_cambiar_sentidoZ == 1)
            {
               flag_cambiar_sentidoZ = 0;
               pasoZ += 2;
            }
         }
      }
   

      if(tecla3 == 0)
      {
         delay_ms(20);
         if(tecla3 == 0)
         {
            if(velocidad <= 100)
            {
               if(velocidad == 101)
               {
                  velocidad = 4;
               }
               velocidad++;
            }
         }
      }
   }
}


void Inicio(void)
{
      setup_adc_ports(NO_ANALOGS);
      setup_adc(ADC_OFF);
      setup_psp(PSP_DISABLED);
      setup_spi(FALSE);
      setup_wdt(WDT_OFF);
      setup_timer_0(RTCC_INTERNAL);
      setup_timer_1(T1_DISABLED);
      setup_timer_2(T2_DISABLED,0,1);
      setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
      setup_comparator(NC_NC_NC_NC);
      setup_low_volt_detect(FALSE);   
      setup_oscillator(OSC_NORMAL);

   //...revisar esto en caso de no funcionar el programa.
      set_tris_a(0x00);   
      set_tris_b(0x03);
      set_tris_d(0x00);
      set_tris_e(0xFF);
   TRISC7 = 1;   
   enable_interrupts(global);
   lcd_init();

   flag_inicio = 0;
   flag_X = 0;
   flag_Y = 0;
   flag_Z = 0;
   flag_alarma_X = 0;
   flag_alarma_Y = 0;
   flag_alarma_Z = 0;
   flag_cambiar_sentidoX = 1;
   flag_cambiar_sentidoY = 1;
   flag_cambiar_sentidoZ = 0;
   flag_fin_mov_X = 0;
   flag_fin_mov_Y = 0;
   flag_fin_mov_Z = 0;

   PORTD = 0x00;
   TR = 0;
   velocidad = 4;
   pasoZ = 1;
   pasoY = 1;
   pasoX = 1;
   relX = 0;
   relY = 1;
   difX = 1;
   difY = 1;
   movX = 65000;
   movY = 65000;
   movZ = 65000;

   unidadesX = 0;
   decenasX = 0;
   centenasX = 0;
   millaresX = 0;
   millonX = 0;

   unidadesY = 0;
   decenasY = 0;
   centenasY = 0;
   millaresY = 0;
   millonY = 0;
}
En línea

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Problema con comunicacion USB
« Respuesta #4 en: 19 de Septiembre de 2012, 15:14:22 »
 :? No uso CCS.. Igualmente veo que testeas si hay dato o no, y que además dependiendo de los datos seteas banderas para enviar respuesta  :tongue: Cuando termines de usar las banderas es bueno borrarlas.

No comenzaste por algo más sencillo para probar tu comunicación USB primero? Así con menos cosas es más fácil determinar que puede ser lo que este pasando.

Saludos!
En línea
No contesto mensajes privados, las consultas en el foro

Desconectado fantaxmax

  • PIC16
  • ***
  • Mensajes: 107
    • Libertycraft - Minecraft
Re: Problema con comunicacion USB
« Respuesta #5 en: 19 de Septiembre de 2012, 15:26:20 »
tengo entendido que la funcion "usb_task()" no debe ser llamada por el usuario, yo estube probando comunicacion usb con pics, y al momento de llamar la funcion usb_task() el pic se desconecta y se vuelve loco, pero puede ser que yo halla implementado mal la funcion xD!
En línea
"El presente es suyo, El futuro es mio" N.T.
El conocimiento es gratuito e ilimitado, solo debes saber donde buscarlo.

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Problema con comunicacion USB
« Respuesta #6 en: 19 de Septiembre de 2012, 15:27:50 »
Cita de: fantaxmax en 19 de Septiembre de 2012, 15:26:20
tengo entendido que la funcion "usb_task()" no debe ser llamada por el usuario, yo estube probando comunicacion usb con pics, y al momento de llamar la funcion usb_task() el pic se desconecta y se vuelve loco, pero puede ser que yo halla implementado mal la funcion xD!

En el ejemplo que trae CCS tiene usb_task() en el bucle principal...  Y en la ayuda dice:

Citar
If you use connection sense, and the usb_init_cs() for initialization, then you must periodically call this function to keep an eye on the connection sense pin. When the PIC is connected to the BUS, this function will then perpare the USB peripheral. When the PIC is disconnected from the BUS, it will reset the USB stack and peripheral. Will enable and use the USB interrupt.

Entonces solo debe estar cuando se usa el pin sense, no es cierto?
« Última modificación: 19 de Septiembre de 2012, 15:30:23 por Suky »
En línea
No contesto mensajes privados, las consultas en el foro

Desconectado fantaxmax

  • PIC16
  • ***
  • Mensajes: 107
    • Libertycraft - Minecraft
Re: Problema con comunicacion USB
« Respuesta #7 en: 19 de Septiembre de 2012, 19:27:38 »
Cita de: Suky en 19 de Septiembre de 2012, 15:27:50
Cita de: fantaxmax en 19 de Septiembre de 2012, 15:26:20
tengo entendido que la funcion "usb_task()" no debe ser llamada por el usuario, yo estube probando comunicacion usb con pics, y al momento de llamar la funcion usb_task() el pic se desconecta y se vuelve loco, pero puede ser que yo halla implementado mal la funcion xD!

En el ejemplo que trae CCS tiene usb_task() en el bucle principal...  Y en la ayuda dice:

Citar
If you use connection sense, and the usb_init_cs() for initialization, then you must periodically call this function to keep an eye on the connection sense pin. When the PIC is connected to the BUS, this function will then perpare the USB peripheral. When the PIC is disconnected from the BUS, it will reset the USB stack and peripheral. Will enable and use the USB interrupt.

Entonces solo debe estar cuando se usa el pin sense, no es cierto?

sorry, hace tanto tiempo que no programa algo con usb que me confundi con funciones, el usb_task si va, este o no el pin sense (cuando esta definido debe llamarse en el bucle principal del programa), le recomiendo a lemp9002 que escriba un programa mas pequeño, para que vaya viendo como trabaja el usb, ejemplo partir con lo mas simple un led por usb, luego un display de 7 segmentos, luego un puerto completo del pic, luego varios puertos, luego un LCD, luego mezclar todo, y cuando ya entienda como funciona el usb tanto en el pic como en la computadora va a poder hacer la al parecer impresora que esta creando, sin embargo el programa que posteo aqui debido a la extencion del mismo, me cuesta entenderlo y me pierdo bueno eso, Sorry otra vez si confundi a alguien  :mrgreen:

Saludos a todos!
En línea
"El presente es suyo, El futuro es mio" N.T.
El conocimiento es gratuito e ilimitado, solo debes saber donde buscarlo.
Páginas: [1]   Ir Arriba
« anterior próximo »