Inicios con el 18F2550 y 18F4550 en C

[ccencho]

Bueno amigos
hoy inicio este tema para poder sumergirnos a el mundo de los pic de gama alta  (ríe)....y bueno empezando con el 18F4550 y posteriormente el 18F2550 que es mas pequeño y barato, bueno.... recién inicio en esto oficialmente pues aun que ya hecho algunos programitas... pero oficialmente iniciamos ahora.....

Empezare definiendo el uso de los PLL que tienen los 18F, bueno..para esto primeramente debemos descargarnos el datasheet del 18F el cual adjunto en este post.

http://www.megaupload.com/?d=156HZM5H

Una ves descargado el data vamos a dirigirnos a la pag 24 el cual nos muestra la siguiente figura.

Empiezo diciendo que en  los pic16 podíamos usar cristales como por ejemplo desde 1MHz hasta 20MHz por decirlo así,en cambio en los 18F podemos manejar frecuencias de hasta 48MHz.... , la pregunta es como?
Bueno los 18F poseen un PLL el cual como vemos en la figura el modulo PLL PRESCALER divide la frecuencia del oscilador que ingresa por OS1 y OS2 en 1,2,3,4,5,6,10,12 ,esto mediante a configuración de PLLDIV el cual funciona como un multiplexor, ejemplo si ponemos un cristal de 20MHz y configuramos PLLDIV 101 estaremos dividiendo FOSC entre 5 por lo que tendremos 4MHz a la salida del MUX.

Bien una vez elegido esto de la división de frecuencia del cristal ,a la salida del MUX aparece un bloque que dice  96MHZ PLL ,esto modulo necesita de 4MHz como entrada para poder así dar 96MHZ como salida( esto es algo que puedo entender del diagrama y de otras redes de info acerca de esto) una vez que tengamos los 96MHZ esta frecuencia no es ideal si queremos utilizar el modulo USB que contiene el PIC18F4550, por lo que sera dividido entre 2 ,obteniendo hacia los 48MHZ que se necesitan para los USB.
Ahora que ya tenemos 48MHz nos topamos con otro modulo que dice USBDIV el cual si vemos bien si es "1" deja pasar nuestros 48MHZ de lo contrario si es "0" deja pasar la frecuencia directa que viene de el OS1 y OS2, quiere decir que podemos entregar 48MHz al modulo USB del pic con un cristal real puesto en OS1 y OS2 o podemos obtener 48MHz del PLL y su prescaler.  Finalmente solo  nos queda FSEN sea 1 y listo logramos asignar los 48MHz a nuestro modulo USB 2.0.
Sea cual fuera el caso ya sabemos como poder inyectar 48MHz a nuestro modulo USB del PIC18F4550.

Ahora y que pasa con la frecuencia del PIC es decir la pregunta seria ¿ Cual es el clock de trabajo  de nuestro PIC18? bueno amigos nuestro PIC puede trabajar tanto a la misma frecuencia del USB 48MHz o de lo contrario a 20MHz por ejemplo....quiere decir que el modulo USB y el clock del PIC son independientes y pueden trabajar en distintas frecuencias.

¿Cómo configuro el clock de mi PIC18?
Bueno primero debemos poner un cristal entre OS1 y OS2 en nuestro caso elegimos uno de 20MHz ahora si somos mirones en el diagrama  que coloque arriba podemos ver que despues del tigger que proviene del PRIMARY OSCILLATOR salen 3 cables,buses, rutas o como quieran llamarlos, la cual uno va al USBDIV( que ya hablamos de el) y los otros 2 van a 2 módulos CPUDIV los cuales se diferencias en que uno divide entre 2,3,4,6 y solo es usado para cristales tipo HSPLL,ECPLL,XTPLL,ECPIO los cuales obtienen la frecuencia directo del PLL es decir obtienen la frecuencia de 48MHz y mediante este MUX puede obtener frecuencias de 24MHz,16MHz,6MHz y 4MHz que van ir directo al clock ,previa configuración y asignación respectiva.

Mientras que el otro modulo CPUDIV maneja cristales del tipo XT,HS,EC,ECIO los cuales son obtenidos directamente del mismo cristal real, este mux también puede dividir la frecuencia que tiene a su entrada en factores de 1,2,3 y 4 ejemplo si asignamos 011 a CPUDIV este dividirá la frecuencia de nuestro cristal de 20MHz entre 5 y obtendremos 4MHz. Bien como vemos tenemos dos módulos CPUDIV los cuales uno puede obtener la frecuencia directamente del PLL y el otro directo del cristal bien ahora la pregunta es como elegimos cual , bueno esto lo hacemos mediante el registro FOSC3:FOSC0 y elegimos que modulo CPUDIV usar y con esto podemos asignar finalmente el clock de procesos para nuestro PIC si antes también si notamos podemos entregar esta frecuencia a nuestro modulo USB pues vemos un modulo que divide entre 4 y lo manda a FSEN el cual si fuera 0 asigna nuestra frecuencia de lo contraria la que viene del USBDIV.

Ufff bueno como verán es algo sencillo y ponemos atención al diagrama y a la explicación...bueno ahora tanto como ustedes y yo ya sabemos como funciona esto de los cristales en los 18F y los PLL.
Bueno esta primera parte finitico y próximamente la segunda apenas tenga listo la explicación a dar...suertes a losq empiezan como yo con este pic y cualquier duda haganlo...bytes..... icon_biggrin icon_biggrin icon_biggrin icon_biggrin icon_biggrin icon_biggrin

[ccencho]

En esta oportunidad pondré unos ejemplos para poder masticar mejor la info que publique anteriormente sobre el PLL y el clok del CPU del Pic, agregando a ello la declaración de los fuses como inicio de nuestro futuro código.

Antes de todo esto cabe recalcar que podemos trabajar a una frecuencia determinada para nuestro modulo USB y otra para el clock del cpu del pic, es decir frecuencias separadas( esto es lo maravilloso de este PIC).

Ejemplo si tenemos un cristal real de 20Mhz podemos empezar declarando los fuses de nuestros PIC de la siguiente manera incluyendo el crystal:

#fusesHSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,NOPBADEN

En donde :

HSPLL: Utilizamos un crystal de alta velocidad >= a 4MHZ en conjunto con el PLL de nuestro pic.
NOWDT:No vamos utilizar el perro guardián
NOPROTECT: Desactivamos la protección del código
NOLVP: Desactivamos la programación a bajo voltaje.
NODEBUG: Modo debug desactivado.
USBDIV: signfica que el clock del usb se tomará del PLL/2 = 96Mhz/2 = 48Mhz.
PLL5: significa que el PLL prescaler dividirá en 5 la frecuencia del cristal. para HS = 20Mhz/5 = 4Mhz( los 4Mhz son necesarios para que el PLL puesta trabajar con 48MHZ, por eso la division del cristal real de 20Mhz entre 4).
CPUDIV1: El PLL postscaler  divide en 2  la frecuencia de salida del PLL de 96MHZ, si queremos 48MHZ, lo dejamos como está( esto quiere decir que el clock de nuestro pic trabajara con 48Mhz)
VREGEN: habilita el regulador de 3.3 volts que usa el módulo USB

Código:

#include <18f2550.h>  //archivo de cabecera
#fuses HSPLL,MCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,NOVREGEN,NOPBADEN // Fuses a declarar

#use delay(clock=48000000) // clock obtenido de 96/2=48Mhz, se debe declarar el cristal de clok a utilizar

Cabe decir que con esta parte de código y resaltando los puntos mas importantes para este caso de dominar los tiempos con cristales...entonces nuestro código dice que estamos asignado 48 Mhz a nuestro modulo USB del pic18f2550 y que estamos usando  48Mhz para nuestro PIC gracias a los PLL....continuara...xq tengo sueño bytes amigos...

[ccencho]

Ahora vamos con nuestro primer ejemplo llamado To blink portb (Parpadear el portb)

#include <18f2550.h>  //archivo de cabecera
#fuses HSPLL,MCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,NOVREGEN,NOPBADEN // fuses  configurados
// el fuse que configuramos anteriormente
#use delay(clock=48000000)     // el clock que tendremos a la entrada del CPU

void main() {

// configurando registros

    disable_interrupts(global);   // desactivando interrupciones globales
    setup_adc_ports(NO_ANALOGS);  // desactivando puertos analogicos   
    set_tris_b(0x0);              // configurando los puertos como salidas
   
// Programa de parpadeo

    output_b (0);                 // saca un nivel bajo de salida en los puertos

while(1){
      output_b (0);       // saca un nivel bajo en el portb
      delay_ms(1000);     // pause  de 1 Seg
      output_b (255);    // saca un nivel alto en el portb
      delay_ms(1000);     // pause de 1 Seg
   }
}

Para este caso estamos utilizando un cristal real de 20Mhz  y con ayuda del PLL interno nuestro pic esta  trabajando a 48Mhz y el modulo usb también a 48Mhz.

NOTA:

Debo decir que no se vayan a confundir cuando declara en el CCS esto:

#use delay(clock=48000000) 

Ya que mucho pueden pensar que deberia ir 20Mhz ( por el cristal real que estamos usando) pero no es asi, aca estamos declarando el clock de trabajo del pic, yaque con esto el CCS hara los calculos para poder manejar correctamente los tiempos y retardos y poder asi usar bien los delay y como nuestro clock resultante gracias al PLL es 48Mhz estamos poniendo eso .

[ccencho]

Ahora tenia algunas curiosidades sobre usar un cristal de 4Mhz y hacer trabajar el modulo usb a 48Mhz y el clock a 4Mhz usando directamente estos 4Mhz reales.
El codigo es el siguiente

#include <18f2550.h>  //archivo de cabecera

#fuses XT,MCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,NOVREGEN,NOPBADEN // fuse con cristal 4Mhz
#use delay(clock=4000000)     // el clock que tendremos a la entrada del CPU

void main() {

// configurando registros

    disable_interrupts(global);   // desactivando interrupciones globales
    setup_adc_ports(NO_ANALOGS);  // desactivando puertos analogicos   
    set_tris_b(0x0);              // configurando los puertos como salidas
   
// Programa de parpadeo

    output_b (0);                 // saca un nivel bajo de salida en los puertos

while(1){
      output_b (0);       // saca un nivel bajo en el portb
      delay_ms(1000);     // pause  de 1 Seg
      output_b (255);    // saca un nivel alto en el portb
      delay_ms(1000);     // pause de 1 Seg
   }
}

 

Resulto bien almenos el clok del pic...el USB jeee icon_biggrin se supone debe funcionar bien..buenoe sto lo confirmare mas adelante pero debe ser asi..segun datashhet y lo explicado anteriormente en los post.

Bueno amigos nos vemos en otro post....y un segundo ejemplo....bytesss

[ccencho]

Bueno chicos aca les traigo el segundo ejemplo algo mas avanzadito , se trata de usar el modulo  analogo /digital del PIC18 para mostrar en un lcd de 2x16 el valor del voltaje leido por el chanel0 y ademas el valor de la conversion en decimal antes de pasarlo a voltaje.
Estoy usando un cristal real de 20Mhz y configurando los fuses para poder trabajar con un clock de 48Mhz.

#include <18F2550.h>
#fuses hspll,mclr,nowdt,noprotect,nolvp,nodebug,usbdiv,pll5,cpudiv1,novregen,nopbaden
#DEVICE ADC=8                                              // resolucion a 8 bits
#use delay(clock=48000000)                            // clock de trabajo del pic a  48Mhz
#define LCD_DATA_PORT getenv("SFR:PORTB")   // declaro usar el portb para el control del lcd
#include <lcd.c>                                            // libreria del lcd

int8 valor_adc;                                              // declarando variable
float conver;
float k=0.019607843137254;

void main(){

// configurando puertos y registros
   lcd_init();                                                 // empiezo a usar los comandos de la libreria del lcd
   set_tris_a(255);                                        // configurando como porta entrada
   set_tris_b(0);                                           // configurando portb como salida
   setup_adc_ports(AN0_TO_AN1|VSS_VDD);     // configurando An0 y An1 como entradas analogas,el resto digital.
                                                                 // voltaje de referencia VSS_VDD( 0-5 voltios)
   setup_adc(ADC_CLOCK_DIV_4 );                  // configurando la frecuencia de lectura del ADC a 12Mhz
   set_adc_channel(0);                                  // asignando el An0 como etrada analoga para la lectura
   delay_us(10);
   
// codigo de programa
 
while(true)                                                   // bucle infinito
{ 
       read_adc(ADC_START_ONLY);                  // empieza la conversion  del modulo adc
       while (!adc_done());                              // adc_donde() es 1 cuando el moculo adc termina la conversion
                                                                // while hace un bucle en la misma linea hasta que sea 0(conversion finalizada)
       valor_adc=read_adc(ADC_READ_ONLY);    // se le asigna avalor_adc el valor analogo convertido
       conver=valor_adc*k;                             // conviertiendo a voltaje 
       lcd_gotoxy(1,1);                                   // se posiciona en la primera linea del lcd
       printf(lcd_putc,"Valor:%3u",valor_adc);    // muestra el valor convertido analogo/digital leido de AN0
       lcd_gotoxy(1,2);                                  // posicionando en linea 2 del lcd   
       printf(lcd_putc,"Voltaje:%f",conver);       // mostrando voltaje
}                     

}                                                             // fin del programa cerrado por la llave
   
   

[ccencho]

Hola chicos aca subo el video del ejemplo ADC...espero opiniones icon_biggrin icon_biggrin icon_biggrin

<a href="http://www.youtube.com/watch?v=wz-_Ce497ys" target="_blank">http://www.youtube.com/watch?v=wz-_Ce497ys</a>

[ccencho]

Hola amigos aca les traigo avances con el modulo USB en el  ejemplo 3 y bueno antes del ejemplo y compartir mis avances....bueno debo decirles que este es un primer avance del uso de las librerias del ccscompiler.....para lograr la comunicacion usb.

Bueno en esta oportunidad cabe decir que....hay 4 principales tipos de comunicacion o clases con el usb las cuales son:

• CDC ( Communications Devices Class)
• HID (Dispositivo de Interfas Humana, mouses,keypad,etc)
• BULK TRANSFERS USB( comunicacion bidireccional masiva)
• MSD USB

Yo escoji para empezar la comunicación CDC ya que según revisando es la mas facil de empezar ya que simula un puerto serial COM y lo comunica con el USB, es decir utiliza el driver del puerto serial COM que trae Windows y lo comunica con el conector USB... así que se podría decir que todo los avances con el puerto serial( comunicacion rs232,485 programas echos en visual basic ,etc) nos vas servir mucho.

Lo primero que debemos hacer es tener el driver de microchip a la mano para poder instalarlo cuando windows no lo pida al momento de enchufar nuestro usb.

Lo adjunto al final del post.

Ahora......vamos a digitar el siguiente codigo:

#include <18f2550.h>                                 // declarar pic18f2550
#fuses hspll,nowdt,noprotect,nolvp,nodebug,usbdiv,pll5,cpudiv1,vregen     // fuses
#use delay(clock=48M)                                // clock  a 48Mhz
#include <usb_cdc.h>                                 // declaro librerias USB

//*********************** configuracion y declaraciones ****************

#define ledv  PIN_B6                                 // asignando etiquetas a el pinb6
#define ledr  PIN_B7
#define ledon output_high                            // asignando etiquetas a la funcion output 
#define ledoff output_low

void main(){                                         // inicio del codigo

   ledoff(ledv);                                     // enciendo el led rojo yq aun no detecta el host
   ledon(ledr);
   
   usb_cdc_init();
   usb_init();                                        // inicializamos el USB
   usb_task();                                        //habilita periferico usb e interrupciones
   usb_wait_for_enumeration();                        //esperamos hasta que el PicUSB sea configurado por el host
   
   ledoff(ledr);                                       // encendemos el led verde
   ledon(ledv);

while(true)
   if(usb_enumerated())                               //retorna verdadero si el dispositivo esta enumerado
   {printf(usb_cdc_putc,"Enumerado\n\r");}             // envia una la palabra enumerado
   }

El cual lo que hace es encender el un diodo led rojo al conectar el usb, una vez que el usb sea reconocido por el pc , el led rojo se apagara y se encenderá el led verde y luego enviara la palabra enumerado..
Para visualizar la palabra es necesario utilizar el Hypeterminal o algún programa hecho en visual basic o C++.


Continuara.....

[ccencho]

Bueno amigos retomando de tiempo  este tema con nuevos avances jeeee, bueno primero quiero culminar el post ultimo subiendo las el circuito+ imágenes que funciona jaaa

CIRCUITO

[ccencho]

Hola amigos aca continuando con la saga del USB  jaaa..les traigo el ejemplo 4....el cual trata del Control de dispositivos mediante una interfase creada en visual basic .

Debo decir que el programa para el PIC fue realizado en CCS compiler 4.093 , fue simulado en Proteus 7.6 sp0, la interfas fue echa en visual 6.0( las proximas versiones seran hechas en visual basic 2008 ), esta vez se utilizo el pic 18F4550 ,asi como debo decir que esto es un demo academico para que todos aquellos que se inician en esto puedan empezarlo de forma facil.

El proyecto fue probado en real y funciona al 100%.....aunq debo decir que hay otros ejemplos que los probe en proteus y  no funcionan como deberia ser...pero eso es tema de otros post....

"Antes de empezar ya con el ejemplito..debo decir que es algo avanzadito yq aun me falta explicarles bien todo el tema de los comando que use en CCS asi como del visual basic,reconocimiento del HOST y enumeracion,asi como otros puntos mas que me salte jeee pero lo haré en el proximo post" 

Bueno empezamos con el proyectito.....

1. Aca ta el codigo del pic..jee

//****************************************************************************
//************* ENCIENDE LEDS DESDE LA PC( PC A PIC.....)*********************
//****************************************************************************
#include <18f4550.h>
#fuses hspll,nowdt,nomclr,noprotect,nolvp,nodebug,usbdiv,pll1,cpudiv1,vregen
#use delay(clock=48M)                                // clock  a 48Mhz
#define USB_CON_SENSE_PIN PIN_B2
#include <usb_cdc.h>                                 // declaro librerias USB
#include <usb_desc_cdc.h>                             // Descriptores del dispositivo USB.
//*********************** configuracion y declaraciones ****************
#define ledv  PIN_B6                                 // asignando etiquetas a el pinb6
#define ledr  PIN_B7
#define ledon output_high                            // asignando etiquetas a la funcion output 
#define ledoff output_low
int8 data;
void main(){                                         // inicio del codigo
   set_tris_d(0);
   set_tris_b(0);
   output_d(0);
//********* CONFIGURAR EL HOST Y VISUALIZAR MEDIANTE LEDS************//   
   ledoff(ledv);                                      // enciendo el led rojo yq aun no detecta el host
   ledon(ledr);   
   usb_cdc_init();
   usb_init();                                        // inicializamos el USB
   usb_task();                                        //habilita periferico usb e interrupciones
   usb_wait_for_enumeration();                        //esperamos hasta que el PicUSB sea configurado por el host
   ledoff(ledr);                                       // encendemos el led verde
   ledon(ledv);
//************ TERMINA DE VISUALIZAR LOS LEDS ****************************//
///////////////////////////////////////////////////////////////////////////
// ************** INICIO DEL PROGRAMA *************************************

while(!usb_cdc_connected()){}                      // espera a detectar una transmisión de la PC (Set_Line_Coding).{}                       
 
while(true)
{
      usb_task();
   if(usb_enumerated()){                               //retorna verdadero si el dispositivo esta enumerado                                                   
      if(usb_cdc_kbhit()){                               // en espera de un nuevo caracter en el buffer de recepcion                                 
       
        data=usb_cdc_getc();
        if(data=='1'){ // ¿ llegó el caracter 1?
              output_toggle(PIN_D0);}  // Conmuta Led 1.           
                                   
        if(data=='2'){ // ¿ llegó el caracter 2?
              output_toggle(PIN_D1);} // Conmuta Led 2.
                                   
        if(data=='3'){ // ¿ llegó  el caracter 3?
              output_toggle(PIN_D2); } //Conmuta Led 3.
                                     
        if(data=='4'){ // ¿ llegó el caracter 4?
              output_toggle(PIN_D3);} // Conmuta Led 4.
                                     
        if(data=='5'){ // ¿ llegó el caracter 5?
              output_toggle(PIN_D4);} // Conmuta Led 5.
                                     
        if(data=='6'){ // ¿ llegó el caracter 6?
              output_toggle(PIN_D5);} //Conmuta Led 6.
                                     
        if(data=='7'){ // ¿ llegó el caracter 7?
              output_toggle(PIN_D6);} // Conmuta Led7.
                                   
        if(data=='8'){ // ¿ llegó el caracter8?
              output_toggle(PIN_D7);} // Conmuta Led 8.
                   
       if(data=='9'){ // ¿ llegó el caracter 9?
              output_d(0); }   // apaga todo
                   
        if(data=='a'){ // ¿l llegó el caracter a?
              output_d(255);  }  // prende todo
                                     
                    usb_cdc_putc(data);                                                                   
            }                       
      }
   }
}
   

La interfas la realize en visual asiq aca unas capturas de imagen  :

Y bueno aca el circuito que ya es clasico....

Aca un videito de su funcionamiento...

<a href="http://www.youtube.com/watch?v=LjjkDPi2ThE" target="_blank">http://www.youtube.com/watch?v=LjjkDPi2ThE</a>

Bueno para todos aquellos que quieran probar esta aplicacion aca adjunto todo (programa pic .hex + circuito en proteus + archivo del visual basic)

[ccencho]

Ahora explicare las funciones(o comandos) que se utilizaron en el codigo anterior y asi poder tener las cosas mas claras que el agua de Huacachina  , bueno..aca le vamos.

FUNCIONES USB PARTE 1

usb_init()

Esta función inicializa el hardware del USB, se encuentra en un bucle infinito hasta que el conector usb es conectado al bus( puede estar enumerado o no por el HOST), Habilita y utiliza las interrupciones del USB

usb_task()

Inicializa el periférico USB o resetea el USB stack y el periférico

Esta funcion esta siempre al tanto del SENSE pin( Pin RB2 en el 18F4550) para saber si el cable usb esta conectado o no, si esta conectado inicializa el usb si es requerido, de lo contrario ( cable no conectado) desactiva el puerto usb del pic.Todo esto ocurre si el SENSE PIN esta declarado.Si el SENSE PIN no esta declarado el hadware usb es iniciado de forma automatica al conectar el cable usb al host.

usb_cdc_init()

Sencillamente esta función configura el USB para que pueda ser usado por el puerto COM virtual. Tiene que ir si o si al inicio.
Para los que han usado el puerto COM via RS232, sabran que se tiene que configurar parametros de pariedad y todo ese rollo bueno ...el USB_CDC_INIT() hace lo mismo por eso digo que se tiene que usas si o si

Sino cheuqen loq lleva esta función en su interior:

  usb_cdc_line_coding.dwDTERrate = 9600;
   usb_cdc_line_coding.bCharFormat = 0;
   usb_cdc_line_coding.bParityType = 0;
   usb_cdc_line_coding.bDataBits = 8;
   (int8)usb_cdc_carrier = 0;
   usb_cdc_got_set_line_coding = FALSE;
   usb_cdc_break = 0;
   usb_cdc_put_buffer_nextin = 0;
   usb_cdc_get_buffer_status.got = 0;


Bueno regreso...jee es hora de comer..... ..Listo regrese de comer ..ahora seguimos donde me quede aya ..haber siguiente funcion:

usb_enumerated()

Retorna con un 1 lógico si el host enumera el dispositivo, una vez esto el  pic puede enviar o recibir paquetes de datos por el puerto.

usb_wait_for_enumeration()

Se encierra en un bucle hasta que el PicUSB sea configurado por el host( para aplicaciones donde el pic hace otras cosas mas es recomendable usar el usb_enumerated())

usb_cdc_kbhit()

Devuelve TRUE( 1 lógico)  si hay uno o más caracteres recibidos y esperando en el búfer de recepción

usb_cdc_connected()

Devuelve TRUE si hemos recibido una Set_Line_Coding. En la mayoría de los programas de terminal por puerto serie (como  HyperTerminal), se enviará un Set_Line_Coding Mensaje cuando se inicia el programa y se abre el virtual Puerto COM. Esta es una forma simple para determinar si el PC está dispuesta a mostrar los datos en un programa de terminal serie.

usb_cdc_getc()

Recibe datos de la PC en el buffer del PICUsb. Si usted no quiere a esperar en un bucle infinito, use usb_cdc_kbhit  () primero para comprobar si hay datos  antes de llamar a usb_cdc_getc ().

usb_cdc_putc()

Transmite datos del PicUsb a la Pc

Bueno creo que es suficiente por ahora....asiq espero con este pequeño resumen de las funciones que hemos usado para manejar el modulo USB las cosas esten mas claras...bueno....si quieren mas detalles  revisen las librerias del CCScompiler que son:

usb_cdc.h y  usb_desc_cdc.h ahi esta al inicio de ellas la definición de las funciones mencionadas, asi como otras y otras que están en otras librerías dentro de las mismas 

[ccencho]

Bueno ahora vamos  a ver como el usb reconoce si esta conectado o no al HOST...pero antes de esto vamos a definir que es HOST

[chino]

Muy bueno tu aporte, pero tengo una duda el usb_cdc funciona solo para windows XP o puede funcionar en Vista o 7???

[ccencho]

Hola chino bueno el programa esta hecho en visual basic 6.0 el cual para windonws vista no lo he probado pero en windons7 tiene una opcion para hacer funcionar programas que corren en xp, ahora estoy por emigrar estos programas a visual basic 2008 el cual si va correr en vista y en win7....

Gracias por el comentario..

[chino]

Bueno espero entonces, ya que quiero usarlo en mi portatil todos mis programas y mis laboratorios y este que hecho gracias a tu ayuda es tambien en VB 6.0 en un XP virtual que ahi si funciona.

Tambien tengo conocimiento sobre visual 2008 asi que voy a entender lo que hagas.

Gracias

[ccencho]

Mas bien amigo te invito abrir un tema sobre visual basic haber si te animas y asi podemos...realizar interfases como estas u otras....bueno si te animas abrir el hilo de visual basic puedes hacerlo aca: http://www.icabots.com/foro/index.php?board=34.0