Comunicación PC-PIC por USB con Visual Basic

Este proyecto es una versión más elaborada del artículo Comunicación PC-PIC por USB, al que remito para más detalle en la configuración de fuses, descripción de funciones USB, etc. En este caso se emplea una aplicación desarrollada bajo visual basic para poder interactuar con el PIC desde el PC. Esta aplicación permite la lectura del canal analógico del Puerto A de un PIC 18F4550, además de la lectura o escritura de los puertos B y D. Todo controlado desde el PC a través de una conexión USB.

La aplicación VB indica la orden al PIC mediante un código de 4 caracteres. El primero de esos caracteres le indica al PIC la actuación que debe realizar, ya sea la lectura de la entrada analógica, lectura del puerto D o puerto B, escrituras en los puertos,etc. 

if (usb_cdc_kbhit()){          //Si hay recepción de datos los lee

            recepcion_datos();

            switch(opcion[0]){ //Gestión según información recibida

            case '0': escritura_puertoD();

            break;        

            case '1': canal_analogico();

            break;

            case '2': lectura_puertoD();

            break;

            case '3': lectura_puertoB();

            break;

            case '4': escritura_puertoB();

            break;

            default: 

            break;

            }

         }    

recepcion_datos() {

  

   char c;                //Caracteres individuales de la cadena

   

   i=0;                   //Reinicio del puntero para 1º caracter

   for (i=0;i<4;i++){     //Recepción máxima de 4 caracteres

        //Hasta que buffer se quede vacío

        if (usb_cdc_kbhit())  c=usb_cdc_getc();

   opcion[i]=c;           //Guarda el caracter recibido

   }

}

El resto de caracteres del código será la información a mostrar en el puerto del PIC en el caso de la escritura en los puertos.

   i=3;                  //ultimo caracter recibido...

   decodificacion(i);    //lo transforma en los 4 bits bajos Puerto B

   PuertoB_bajo = numero;       //guarda valor

   i=2;                         //penultimo caracter recibido...

   decodificacion(i);    //lo transforma en los 4 bits altos Puerto B

   PuertoB_alto = numero;       //guarda el valor

   //Salida de los dos caracteres leidos como un byte

   PORTB=(PuertoB_alto<<4)|(PuertoB_bajo);   

Por su lado, el PIC envía la información solicitada al PC mediante cadenas de caracteres acotadas por un primer carácter que indica de que información se trata y un carácter final (#) para separarla de las posteriores cadenas. La aplicación Visual Basic se encarga de identificarlos. Los caracteres contenidos entre ambos será la información "útil".

lectura_puertoD() {

   TRISD=0xff;           //Puerto D como entrada

   PuertoD= PORTD;

   //Envío por USB a la aplicación visual basic

   printf(usb_cdc_putc, "\fD%x#", PuertoD);   

}

[+/-] Ver / Ocultar programa completo

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                  COMUNICACIÓN PC - PIC POR USB                             //
//       Clase de dispositivo CDC USB emulando dispositivo RS232              //
//              Interfase con aplicación Visual basic                         //
//                                                                            //
//                         RobotyPic (c)                                      //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

#include <18F4550.h>             //PIC a emplear

#device adc=10;                  //Conversor A/D de 10 bits

#fuses HSPLL,NOWDT,NOLVP,USBDIV,PLL5,CPUDIV1,VREGEN

#use delay(clock=20000000)       //Frecuencia del cristal oscilador externo

#define USB_CON_SENSE_PIN PIN_B0 //Pin de detección conexión-desconexión dispositivo USB

#include <usb_cdc.h>             //Librería de control USB

#byte TRISD = 0xf95
#byte PORTD = 0xf83
#byte TRISB = 0xf93
#byte PORTB = 0xf81

/******************************************************************************/

   int16 valor_digital;          //Valor digital obtenido del conversor A/D
   float valor_analogico;        //Valor analógico medido en el conversor A/D
   int PuertoB;                  //Valor del puerto B
   int PuertoD;                  //Valor del Puerto D
   char opcion[4]="";            //Recepción información del PC
   int i;                        //Puntero
   int PuertoD_bajo;             //4 bits bajos del Puerto D
   int PuertoD_alto;             //4 bits altos del Puerto D
   int PuertoB_bajo;             //4 bits bajos del Puerto B
   int PuertoB_alto;             //4 bits altos del Puerto B 
   int numero;                   //Valor numérico de los puertos

/******************************************************************************/
/******************** LECTURA Y ENVIO CANAL ANALOGICO *************************/

canal_analogico() {
   valor_digital=read_adc();                 //Lectura conversor AD
   valor_analogico=5.0*valor_digital/1024.0; //Transformación a valor analógico
   printf(usb_cdc_putc, "\fA%01.2fV#", valor_analogico);  //Envío por USB
}

/******************************************************************************/
/************************** RECEPCION CADENA ***********************************/

recepcion_datos() {
  
   char c;                                //Caracteres individuales de la cadena
   
   i=0;                                   //Reinicio del puntero para 1º caracter
   for (i=0;i<4;i++){                     //Recepción máxima de 4 caracteres
   if (usb_cdc_kbhit())  c=usb_cdc_getc();//Hasta que buffer se quede vacío
   opcion[i]=c;                           //Guarda el ultimo caracter recibido
   }
}

/******************************************************************************/
/************************** DECODIFICACIÓN ************************************/

decodificacion(i) {

   if (opcion[i]=='0') numero=0;
   else if (opcion[i]=='1') numero=1;
   else if (opcion[i]=='2') numero=2;
   else if (opcion[i]=='3') numero=3;
   else if (opcion[i]=='4') numero=4;
   else if (opcion[i]=='5') numero=5;
   else if (opcion[i]=='6') numero=6;
   else if (opcion[i]=='7') numero=7;
   else if (opcion[i]=='8') numero=8;
   else if (opcion[i]=='9') numero=9;
   else if (opcion[i]=='A') numero=10;
   else if (opcion[i]=='B') numero=11;
   else if (opcion[i]=='C') numero=12;
   else if (opcion[i]=='D') numero=13;
   else if (opcion[i]=='E') numero=14;
   else if (opcion[i]=='F') numero=15;
}

/******************************************************************************/
/************************* ESCRITURA PUERTO B *********************************/

escritura_puertoB() {

   TRISB=0b00000100;                //Puerto B como salida excepto Bit 2
   
   i=3;                             //ultimo caracter recibido...
   decodificacion(i);               //lo transforma en los 4 bits bajos Puerto B
   PuertoB_bajo = numero;           //guarda valor
   i=2;                             //penultimo caracter recibido...
   decodificacion(i);               //lo transforma en los 4 bits altos Puerto B
   PuertoB_alto = numero;           //guarda el valor
   
   //Salida de los dos caracteres leidos como un byte
   PORTB=(PuertoB_alto<<4)|(PuertoB_bajo);   
}

/******************************************************************************/
/************************* ESCRITURA PUERTO D *********************************/

escritura_puertoD() {

   TRISD=0x00;                      //Puerto D como salida
   
   i=3;                             //ultimo caracter recibido...
   decodificacion(i);               //lo transforma en los 4 bits bajos Puerto D
   PuertoD_bajo = numero;           //guarda valor
   i=2;                             //penultimo caracter recibido...
   decodificacion(i);               //lo transforma en los 4 bits altos Puerto D
   PuertoD_alto = numero;           //guarda el valor
   
   //Salida de los dos caracteres leidos como un byte
   PORTD=(PuertoD_alto<<4)|(PuertoD_bajo);   
}

/******************************************************************************/
/*************************** LECTURA PUERTO B *********************************/

lectura_puertoB() {

   TRISB=0xff;                               //Puerto B como entrada
   
   PuertoB= PORTB;
   PuertoB= PuertoB & 0b11111110;            //Ignora Bit RB0
   printf(usb_cdc_putc,"\fB%x#", PuertoB);   //Envío a aplicación visual basic
}

/******************************************************************************/
/*************************** LECTURA PUERTO D *********************************/

lectura_puertoD() {
   TRISD=0xff;                                //Puerto D como entrada
   
   PuertoD= PORTD;
   printf(usb_cdc_putc, "\fD%x#", PuertoD);   //Envío a aplicación visual basic
}

/******************************************************************************/
/*************************  FUNCIÓN PRINCIPAL  ********************************/

void main() {

   TRISD=0xff;                   //Puerto D como entrada
   
   setup_adc_ports(AN0);       //Definición pin a utilizar como entrada analógica
   setup_adc(ADC_CLOCK_INTERNAL);//Definición de la fuente de reloj para el A/D
   set_adc_channel(0);           //Selección del canal analógico
   
   usb_cdc_init();               //Inicialización del modo CDC
   usb_init();                   //Inicialización del control del USB
   
   do  {
      usb_task();                //Detección de la conexión de dispositivo USB
      if (usb_enumerated()) {    //Devuelve TRUE si dispositivo ha sido enumerado por el PC
         
         if (usb_cdc_kbhit()){   //Si hay recepción de datos los lee
            recepcion_datos();
            switch(opcion[0]){   //Gestión según la información recibida
            case '0': escritura_puertoD();
            break;        
            case '1': canal_analogico();
            break;
            case '2': lectura_puertoD();
            break;
            case '3': lectura_puertoB();
            break;
            case '4': escritura_puertoB();
            break;
            default: 
            break;
            }
         }                
     }
     delay_ms(10);
   } while (TRUE);
}

Bajo proteus se ha desarrollado un esquema para poder comprobar los puertos como entradas y salidas mediante interruptores y leds. 

Aquí podemos ver el resultado:

En el archivo de descarga se incluye el archivo "usb_desc_cdc.h" ya modificado junto al resto de librerías C USB utilizadas.

Descargar Comunicación PC-PIC por USB con VB

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

PINES CONECTOR USB