Codigo 18f2550 y usb con Mikrobasic

[ASTROCAR]

  Pero si ya esta todo listo miren los link:
  http://www.todopic.com.ar/foros/index.php?topic=2260.0

Jajaja si hermano pero como ya explique esta listo pero en otro lenguaje es decir en este tema es usando basic y no me rio en forma de burla sino es una manera de expresarme en un primer momento.

Esa informacion suminiostrada esta super y mil fecilitaciones al colega jim pero es orientada a ccs para pic y usando los dll de microchip; en fin este port es para aclarar el  usb de los pic pero en basic ya sea en proton o picbasic pero que sea en compiladores basado en basic de igual forma muchas gracias y es muy importante esa informacion.

Saludos y me despido un rato.
Atten.
Alexander Santana.
Barcelona-Venezuela

[ekud]

si ese que nos propone el compa parece k solo es de C pero = tiene una informacion muy valiosa... ya pude con lo de los osciladores!!! por finnn hay vamos adelantando pk yo si estoy desde cero en estos 18f

 

Pako:

Voy a intentar explicar un poco de dónde sale esto de los 4 Mhz para el USB 2.0.

Como nunca me canso de repetir: En los datasheet está T_O_D_O, absolutamente todo. 

Aqui os pego un trozo de la imagen donde aparece la estructura de configuración de las opciones de los osciladores en los PIC's de la familia 18Fxx5x que son los que soportan el USB 2.0 (Documento 39632b.pdf de Microchip dedicado a los 18F2455-2550-4455-4550)



Es sistema es complejo debido a la inmensa versatilidad y posibilidades que ofrece.

Como podéis ver en OSC1 y OSC2 conectamos nuestro cristal: 4 Mhz, 8 Mhz, 12 Mhz, 16 Mhz, 20 Mhz, 24 Mhz, 40 Mhz  ó 48 Mhz, que son los cristales validos compatibles con lo que sigue a continuación.

Tened en cuenta que este cristal es el mismo para generar la frecuencia de 48 Mhz necesaria para el USB 2.0 y para el Clock del PIC, que pueden ser la misma o no, según la configuración que al final adoptemos, quiere esto decir que podemos tener el USB a 48 Mhz y nuestro programa en el PIC funcionando a 12 Mhz por ejemplo.

Fijaos en que justo tras el Smicht Trigger del Primary Oscillator salen tres lineas en paralelo que van a modulos distintos con distintas posibilidades.

La primera línea, la superior, va directamente al switch USBDIV que si está a cero indica que la frecuenci base original del cristal es directamente inyectada al USB, si pasa el switch FSEN que elige entre todo el sistema directo/PLL o el Primary Clock del CPU. Esta Opción de inyectar directamente la frecuencia del cristal es obviamente solo posible si usamos un Cristal de 48 Mhz que es lo que necesitamos para el USB.

Cualquier otro cristal debe ser tratado para conseguir los 48 Mhz necesarios.

El módulo USB Clock Source tiene a su entrada un PLL Prescaler, o sea un divisor de frecuencia. En cada una de sus salidas vamos a tener FOSC dividida por 1, 2, 3, 4, 5, 6, 10 ó 12. Y mediante PLLDIV que no es mas que un Multiplexor vamos a seleccionar la que deseamos usar.

Así si nuestro cristal es de 12 Mhz y en PLLDIV colocamos un 010 estaremos dividiendo por 3 el valor de FOSC con lo que tendremos 4 Mhz a la salida del MUX. Si por el contrario el cristal es de 20 Mhz y en PLLDIV colocamos un 100 entonces dividiremos por 5 FOSC con lo que tendremos también 4 Mhz a la salida del MUX.

Esta salida del MUX es lo que utilizamos para inyectársela al PLL de 96 Mhz. Si le metemos 4 Mhz él genera 96 Mhz. Es esta capacidad de pasar de 4 Mhz a 96 Mhz la que nos da la posibilidad de usar un montón de cristales distintos.

Pero 96 Mhz es el doble de lo que nos hace falta para el USB que son 48 Mhz. Asi que inmediatamente después tenemos que tener, y tenemos, un divisor por 2 que es el segundo camino por el que llegamos a USBDIV y en este caso le pondremos un 1 para usar la señal proviniente del PLL.

Fijaos que además de inyectar la señal oscilante en USBDIV tambien se conecta la señal del PLL a 96 Mhz en un Postscaler, otro divisor, en este caso por 2, 3, 4 ó 6 y cuyas señales van al CPUDIV. O sea que podemos generar una señal de reloj para nuestro PIC, no para el USB sino para la velocidad de ejecución de nuestro programa tomándola del PLL y que puede ser de 16 Mhz, 24 Mhz, 32 Mhz ó 48 Mhz.

Pero además la señal original llegaba en paralelo al Oscilator Postcaler, otro divisor más, que de forma directa, sin pasar por el módulo PLL nos divide la frecuencia original del cristal por 1, 2, 3 ó 4 y que también va a parar al CPUDIV pero desde otro origen. Con este módulo podemos obtener otra gama de frecuencias distinta para hacer correr el programa.

Cúal de ambos CPUDIV vamos a utilizar lo seleccionamos con el switch FOSC3:FOSC0 que es de donde sacaremos la definitiva frecuencia de ejecución de programas.

Por último tambien tenemos disponible una entrada proviniente del Primary Clock y que dividida por 4 llega también a FSEN y podemos utilizarla en lugar de la que le llega desde el canal directo/PLL

Como podeis ver es toda una maravilla cómo esta montado este tema de los osciladores, sobre todo por lo que respecta a las inmensas capacidades que tiene para hacer correr nuestro PIC a decenas de velocidades distintas siendo capaz, al mismo tiempo de tener disponibles los 48 Mhz imprescindibles para el USB 2.0.

Me descubro ante los ingenieros de Microchip y los aplaudo, se lo merecen.
 



 

[mariano_pic]

quieres con basic aca esta un link:
la pagina de lafebre:
  http://www.freewebs.com/glafebre/
  y aca esta http://www.freewebs.com/glafebre/articulos.htm
  usb facil:
  http://www.4shared.com/file/3053768/9d9b3c15/tp2550.html
  empiesa a trabajar, esta hecho los pbasic

[ekud]

Hola a todos!

bueno lo que pasa es ps soy nuevo con esto de los micros de la serie 18f y queria comenzar con una comunicacion usb muy basica.

pues bien leyendo y leyendo tengo entendido que la frecuencia con la que trabajan estos micros para el usb 2.0 es de 48Mhz, que esta frecuencia es independiente de la frecuencia de trabajo del micro pero que aun asi su fuente es el oscilador externo que siempre se pone, solo que con un pll se amplifica hasta los 48Mhz.. y en fin...

y pues bien siempre he programado micros en el mikrobasic que ya va por la version 7.2 (7.3 en beta), en el mikrobasic hay un alibreria que me permite comunicarme con el pc via usb, tambien en l mikrobasic se incluye una aplicacion (muy parecida a lo que hace el EasyHID) que me genera un archivo con los descriptores para el microcontrolador. y asi las cosas uno pensaria que este tema esta en bandeja de plata.. listo para usarlo y ya...

pues bien... a mi no me ha kerido dar resultado el dichoso ejemplo que se plantea en este lenguaje... el ejemplo lleva un micro 18f4550 trabajando con un crytal a 8Mhz y ya... es asi de basico...

el codigo es el siguiente

(archivo USB_HID_test.pbas)

Código: [Seleccionar]

' * Project name:
'     HIDtest (Testing the USB HID connection)
' * Copyright:
'     (c) MikroElektronika, 2005 - 2008
' * Revision History:
'     20050502:
'       - initial release;
' * Description:
'     This example establishes connection with the HID terminal that is active
'     on the PC. Upon connection establishment, the HID Device Name will appear
'     in the respective window. After that software will wait for data and
'     it will return received data back.
' * Test configuration:
'     MCU:             PIC18F4550
'     Dev.Board:       EasyPIC5
'     Oscillator:      HS 8.000 MHz  (USB osc. is raised with PLL to 48.000MHz)
'     Ext. Modules:    -
'     SW:              mikroBasic v7.1
' * NOTES:
'     - Be VERY careful about the configuration flags for the 18F4550 - there's
'       so much place for mistake!
       
program USB_HID_test

include "USBdsc"

dim
 k, i, ch       as  byte
 userWR_buffer  as  byte[64]
 userRD_buffer  as  byte[64]

'******************************************************************************
' Main Interrupt Routine
'******************************************************************************
sub procedure interrupt
'** this is a way to call a procedure from interrupt
  HID_InterruptProc
end sub
'******************************************************************************


'******************************************************************************
' Initialization Routine
'******************************************************************************
sub procedure Init_Main
'--------------------------------------
' Disable interrupts
'--------------------------------------
INTCON = 0                             ' Disable GIE, PEIE, TMR0IE,INT0IE,RBIE
INTCON2 = 0xF5
INTCON3 = 0xC0
RCON.IPEN = 0                          ' Disable Priority Levels on interrupts
PIE1 = 0
PIE2 = 0
PIR1 = 0
PIR2 = 0

ADCON1 = ADCON1 or 0x0F                ' Configure all ports with analog function as digital
'--------------------------------------
' Ports Configuration
'--------------------------------------
TRISA = 0xFF
TRISB = 0xFF
TRISC = 0xFF
TRISD = 0
TRISE = 0x07

LATA = 0
LATB = 0
LATC = 0
LATD = 0
LATE = 0
end sub



'******************************************************************************
' Main Program Routine
'******************************************************************************

main:
  Init_Main()
 
  HID_Enable(@userRD_buffer, @userWR_buffer)
  Delay_mS(1000)
  Delay_mS(1000)

  while true
      k = HID_Read()
      i = 0
      while i < k
          ch = userRD_buffer[0]
          userWR_buffer[0] = ch
          HID_Write(@userWR_buffer, 1)
          inc(i)
      wend
  wend
  HID_Disable()
 
end.


el archivo del inlude (USBdsc.pbas) que es el que se genera con la aplicacion de mikrobasic para generar los descritores HId  contiene el siguiente codigo:

Código: [Seleccionar]

module USBdsc
include "HIDconstant"
' File Version 1.01
'
'******************************************************************************

'******************************************************************************
' The number of bytes in each report,
' calculated from Report Size and Report Count in the report descriptor
'******************************************************************************
 const HID_INPUT_REPORT_BYTES      = 1
 const HID_OUTPUT_REPORT_BYTES     = 1

 const HID_FEATURE_REPORT_BYTES    = 2
'******************************************************************************
' Byte constants
'******************************************************************************
 const NUM_ENDPOINTS               = 2
 const ConfigDescr_wTotalLength    = USB_CONFIG_DESCRIPTOR_LEN + USB_INTERF_DESCRIPTOR_LEN + USB_HID_DESCRIPTOR_LEN + (NUM_ENDPOINTS * USB_ENDP_DESCRIPTOR_LEN)
 const HID_ReportDesc_len          = 47

 const Low_HID_ReportDesc_len      = HID_ReportDesc_len
 const High_HID_ReportDesc_len     = HID_ReportDesc_len >> 8

 const Low_HID_PACKET_SIZE         = HID_PACKET_SIZE
 const High_HID_PACKET_SIZE        = HID_PACKET_SIZE >> 8



'******************************************************************************
' Descriptor Tables
'******************************************************************************
 const DescTables as byte[USB_DEVICE_DESCRIPTOR_ALL_LEN*2] = (

' Device Descriptor
    USB_DEVICE_DESCRIPTOR_LEN, 0,           ' bLength               - Length of Device descriptor (always 0x12)
    USB_DEVICE_DESCRIPTOR_TYPE, 0,          ' bDescriptorType       - 1 = DEVICE descriptor
    0x00, 0,                                ' bcdUSB                - USB revision 2.00 (low byte)
    0x02, 0,                                '                                           (high byte)
    0x00, 0,                                ' bDeviceClass          - Zero means each interface operates independently (class code in the interface descriptor)
    0x00, 0,                                ' bDeviceSubClass
    0x00, 0,                                ' bDeviceProtocol
    EP0_PACKET_SIZE, 0,                     ' bMaxPacketSize0       - maximum size of a data packet for a control transfer over EP0
    0x34, 0,                                ' idVendor              - Vendor  ID (low byte)
    0x12, 0,                                '                                    (high byte)
    0x01, 0,                                ' idProduct             - Product ID (low byte)
    0x00, 0,                                '                                    (high byte)
    0x01, 0,                                ' bcdDevice             - ( low byte)
    0x00, 0,                                '                         (high byte)
    0x01, 0,                                ' iManufacturer         - String1
    0x02, 0,                                ' iProduct              - String2
    0x00, 0,                                ' iSerialNumber         - ( None )
    0x01, 0,                                ' bNumConfigurations    - 1

' Configuration Descriptor
    USB_CONFIG_DESCRIPTOR_LEN, 0,           ' bLength               - Length of Configuration descriptor (always 0x09)
    USB_CONFIG_DESCRIPTOR_TYPE, 0,          ' bDescriptorType       - 2 = CONFIGURATION descriptor
    ConfigDescr_wTotalLength, 0,            ' wTotalLength          - Total length of this config. descriptor plus the interface and endpoint descriptors that are part of the configuration.
    0x00, 0,                                '                         ( high byte)
    0x01, 0,                                ' bNumInterfaces        - Number of interfaces
    0x01, 0,                                ' bConfigurationValue   - Configuration Value
    0x00, 0,                                ' iConfiguration        - String Index for this configuration ( None )
    0xA0, 0,                                ' bmAttributes          - attributes - "Bus powered" and "Remote wakeup"
    50, 0,                                  ' MaxPower              - bus-powered draws 50*2 mA from the bus.

' Interface Descriptor
    USB_INTERF_DESCRIPTOR_LEN, 0,           ' bLength               - Length of Interface descriptor (always 0x09)
    USB_INTERFACE_DESCRIPTOR_TYPE, 0,       ' bDescriptorType       - 4 = INTERFACE descriptor
    0x00, 0,                                ' bInterfaceNumber      - Number of interface, 0 based array
    0x00, 0,                                ' bAlternateSetting     - Alternate setting
    NUM_ENDPOINTS, 0,                       ' bNumEndPoints         - Number of endpoints used in this interface
    0x03, 0,                                ' bInterfaceClass       - assigned by the USB
    0x00, 0,                                ' bInterfaceSubClass    - Not A boot device
    0x00, 0,                                ' bInterfaceProtocol    - none
    0x00, 0,                                ' iInterface            - Index to string descriptor that describes this interface ( None )

' HID Descriptor
    USB_HID_DESCRIPTOR_LEN, 0,              ' bLength               - Length of HID descriptor (always 0x09)
    USB_HID_DESCRIPTOR_TYPE, 0,             ' bDescriptorType       - 0x21 = HID descriptor
    0x01, 0,                                ' HID class release number (1.01)
    0x01, 0,
    0x00, 0,                                ' Localized country code (none)
    0x01, 0,                                ' # of HID class descriptor to follow (1)
    0x22, 0,                                ' Report descriptor type (HID)
    Low_HID_ReportDesc_len, 0,
    High_HID_ReportDesc_len, 0,

' EP1_RX Descriptor
    USB_ENDP_DESCRIPTOR_LEN, 0,             ' bLength               - length of descriptor (always 0x07)
    USB_ENDPOINT_DESCRIPTOR_TYPE, 0,        ' bDescriptorType       - 5 = ENDPOINT descriptor
    0x81, 0,                                ' bEndpointAddress      - In, EP1
    USB_ENDPOINT_TYPE_INTERRUPT, 0,         ' bmAttributes          - Endpoint Type - Interrupt
    Low_HID_PACKET_SIZE, 0,                 ' wMaxPacketSize        - max packet size - low order byte
    High_HID_PACKET_SIZE, 0,                '                       - max packet size - high order byte
    1, 0,                                  ' bInterval             - polling interval (1 ms)

' EP1_TX Descriptor
    USB_ENDP_DESCRIPTOR_LEN, 0,             ' bLength               - length of descriptor (always 0x07)
    USB_ENDPOINT_DESCRIPTOR_TYPE, 0,        ' bDescriptorType       - 5 = ENDPOINT descriptor
    0x01, 0,                                ' bEndpointAddress      - Out, EP1
    USB_ENDPOINT_TYPE_INTERRUPT, 0,         ' bmAttributes          - Endpoint Type - Interrupt
    Low_HID_PACKET_SIZE, 0,                 ' wMaxPacketSize        - max packet size - low order byte
    High_HID_PACKET_SIZE, 0,                '                       - max packet size - high order byte
    1, 0,                                  ' bInterval             - polling interval (1 ms)

' HID_Report Descriptor
    0x06, 0,                                ' USAGE_PAGE (Vendor Defined)
    0xA0, 0,
    0xFF, 0,
    0x09, 0,                                ' USAGE ID (Vendor Usage 1)
    0x01, 0,
    0xA1, 0,                                ' COLLECTION (Application)
    0x01, 0,
'  The Input report
    0x09, 0,                                ' USAGE ID - Vendor defined
    0x03, 0,
    0x15, 0,                                '   LOGICAL_MINIMUM (0)
    0x00, 0,
    0x26, 0,                                '   LOGICAL_MAXIMUM (255)
    0x00, 0,
    0xFF, 0,
    0x75, 0,                                '   REPORT_SIZE (8)
    0x08, 0,
    0x95, 0,                                '   REPORT_COUNT (2)
    HID_INPUT_REPORT_BYTES, 0,
    0x81, 0,                                '   INPUT (Data,Var,Abs)
    0x02, 0,
'  The Output report
    0x09, 0,                                ' USAGE ID - Vendor defined
    0x04, 0,
    0x15, 0,                                '   LOGICAL_MINIMUM (0)
    0x00, 0,
    0x26, 0,                                '   LOGICAL_MAXIMUM (255)
    0x00, 0,
    0xFF, 0,
    0x75, 0,                                '   REPORT_SIZE (8)
    0x08, 0,
    0x95, 0,                                '   REPORT_COUNT (2)
    HID_OUTPUT_REPORT_BYTES, 0,
    0x91, 0,                                '   OUTPUT (Data,Var,Abs)
    0x02, 0,
'  The Feature report
    0x09, 0,                                ' USAGE ID - Vendor defined
    0x05, 0,
    0x15, 0,                                '   LOGICAL_MINIMUM (0)
    0x00, 0,
    0x26, 0,                                '   LOGICAL_MAXIMUM (255)
    0x00, 0,
    0xFF, 0,
    0x75, 0,                                '   REPORT_SIZE (8)
    0x08, 0,
    0x95, 0,                                '   REPORT_COUNT (2)
    HID_FEATURE_REPORT_BYTES, 0,
    0xB1, 0,                                '   FEATURE (Data,Var,Abs)
    0x02, 0,
'  End Collection
    0xC0, 0                                 ' END_COLLECTION
)
'******************************************************************************
 const LangIDDescr as byte[8] = (
    0x04, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0,
    0x09, 0,                                ' LangID (0x0409) - Low
    0x04, 0                                 '                 - High
)
'******************************************************************************
 const ManufacturerDescr as byte[68] = (
    34, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0,
    "m", 0, 0, 0,
    "i", 0, 0, 0,
    "k", 0, 0, 0,
    "r", 0, 0, 0,
    "o", 0, 0, 0,
    "E", 0, 0, 0,
    "l", 0, 0, 0,
    "e", 0, 0, 0,
    "k", 0, 0, 0,
    "t", 0, 0, 0,
    "r", 0, 0, 0,
    "o", 0, 0, 0,
    "n", 0, 0, 0,
    "i", 0, 0, 0,
    "k", 0, 0, 0,
    "a", 0, 0, 0
)
'******************************************************************************
 const ProductDescr as byte[48] = (
    24, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0,
    "H", 0, 0, 0,
    "I", 0, 0, 0,
    "D", 0, 0, 0,
    " ", 0, 0, 0,
    "L", 0, 0, 0,
    "i", 0, 0, 0,
    "b", 0, 0, 0,
    "r", 0, 0, 0,
    "a", 0, 0, 0,
    "r", 0, 0, 0,
    "y", 0, 0, 0
)
'******************************************************************************
 const StrUnknownDescr as byte[4] = (
    2, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0
)
'******************************************************************************







'******************************************************************************
' Initialization Function
'******************************************************************************
implements
sub procedure InitUSBdsc
dim dummy as byte  volatile register

dummy = NUM_ENDPOINTS
dummy = ConfigDescr_wTotalLength
dummy = HID_ReportDesc_len
dummy = Low_HID_ReportDesc_len
dummy = High_HID_ReportDesc_len
dummy = Low_HID_PACKET_SIZE
dummy = High_HID_PACKET_SIZE
dummy = HID_INPUT_REPORT_BYTES
dummy = HID_OUTPUT_REPORT_BYTES
dummy = HID_FEATURE_REPORT_BYTES
'******************************************************************************
' Byte constants
'******************************************************************************
dummy = NUM_ENDPOINTS
dummy = ConfigDescr_wTotalLength
dummy = HID_ReportDesc_len
dummy = Low_HID_ReportDesc_len
dummy = High_HID_ReportDesc_len
dummy = Low_HID_PACKET_SIZE
dummy = High_HID_PACKET_SIZE
dummy = @DescTables
dummy = @LangIDDescr
dummy = @ManufacturerDescr
dummy = @LangIDDescr
dummy = @ProductDescr
dummy = @StrUnknownDescr
end sub
end.


Y pues el circuito en el que estoy intentando simular es el siguiente:




y la verdad de todo esto no me funciona nada... el proteus ni se da por enterado cuando se simula la conexion de este micro al pc...

lo que me desmoraliza es que en los ejemplos del proteus hay varios que usan el usb y esos funcionan d mil maravillas... y ya estoy es como desesperado pk no doy con el error y llevo como 3 dias estankado en lo mismo... asi k ps si alguien pudiera hecharme una mano le estaria bastante agradecido.

ahh y ps no se uno nunca sabe si alguien desea los archivos aki los dejo para la descarga

http://rapidshare.com/files/198259931/P18F4550.rar.html

[ASTROCAR]

Ok perfecto ya veo mas adelanto en el tema pero no soy quien para decir esto porque no soy nada organizado pero creo que el mejor avance dependera de una nueva organizacion y documentacion que tengamos a la hora de ir dandole color a este tema de usb. Lo primero para mi seria armar una placa entrenadora y que sea en comun para este post y asi todos hablemos en base a esa placa entrenadora yo propongo la del buen colega Giovanni Lafebre mejor conocido por su nick LordLafebre y dicha placa entrenadora ya el colega mariano_pic  coloco los link donde aparece todo  bien explicado de como hacerla con su diagrama y pcb listo para elabora, el nombre del entrenador es TP-2550 (placa de pruebas para USB) ojo esta placa en un principio esta bajada en el pic18f2550 pero ya quedaria de nuestra parte y yo lo tengo en mente luego usar el usb con pic18f4550 pero nada mejor para comenzar que la que propuso el TP-2550.

Bueno ya teniendo un entrenado para lo del usb lo demas seria documentarce y empezar a dar ejemplo de como funciona el usb con estos pic pero asi sin un buen entrenador es un poco dificil se que el colega ekud  ya esta en un proceso de simulacion con proteus y aun no le funciopna porque son muchas cosas las cuales tiene que ir dominando en este caso tambien tiene que ir dominando el proteus y tal ves su problema no sea si su codigo en el pic ni el el soft que creo en el pc sino el mal uso del proteus por eso digo y me inclino mejor por el entrenador y luego que se tenga mucho mas experiencia uno va experimentando a mas grande y puede hasta simular en proteus, todo esto es mi humilde opinion.

Saludos y paso a eleborar el entrenador propuesto en el link que postio mariano_pic y luego les comento y asi ya se le va dando un buen sentido al tutorial usb para pic basado en basic.
Atten.
Alexander Santana.
Barcelona-Venezuela.

[ASTROCAR]

Hola a todos!

el codigo es el siguiente

(archivo USB_HID_test.pbas)

Código: [Seleccionar]

' * Project name:
'     HIDtest (Testing the USB HID connection)
' * Copyright:
'     (c) MikroElektronika, 2005 - 2008
' * Revision History:
'     20050502:
'       - initial release;
' * Description:
'     This example establishes connection with the HID terminal that is active
'     on the PC. Upon connection establishment, the HID Device Name will appear
'     in the respective window. After that software will wait for data and
'     it will return received data back.
' * Test configuration:
'     MCU:             PIC18F4550
'     Dev.Board:       EasyPIC5
'     Oscillator:      HS 8.000 MHz  (USB osc. is raised with PLL to 48.000MHz)
'     Ext. Modules:    -
'     SW:              mikroBasic v7.1
' * NOTES:
'     - Be VERY careful about the configuration flags for the 18F4550 - there's
'       so much place for mistake!
       
program USB_HID_test

include "USBdsc"

dim
 k, i, ch       as  byte
 userWR_buffer  as  byte[64]
 userRD_buffer  as  byte[64]

'******************************************************************************
' Main Interrupt Routine
'******************************************************************************
sub procedure interrupt
'** this is a way to call a procedure from interrupt
  HID_InterruptProc
end sub
'******************************************************************************


'******************************************************************************
' Initialization Routine
'******************************************************************************
sub procedure Init_Main
'--------------------------------------
' Disable interrupts
'--------------------------------------
INTCON = 0                             ' Disable GIE, PEIE, TMR0IE,INT0IE,RBIE
INTCON2 = 0xF5
INTCON3 = 0xC0
RCON.IPEN = 0                          ' Disable Priority Levels on interrupts
PIE1 = 0
PIE2 = 0
PIR1 = 0
PIR2 = 0

ADCON1 = ADCON1 or 0x0F                ' Configure all ports with analog function as digital
'--------------------------------------
' Ports Configuration
'--------------------------------------
TRISA = 0xFF
TRISB = 0xFF
TRISC = 0xFF
TRISD = 0
TRISE = 0x07

LATA = 0
LATB = 0
LATC = 0
LATD = 0
LATE = 0
end sub



'******************************************************************************
' Main Program Routine
'******************************************************************************

main:
  Init_Main()
 
  HID_Enable(@userRD_buffer, @userWR_buffer)
  Delay_mS(1000)
  Delay_mS(1000)

  while true
      k = HID_Read()
      i = 0
      while i < k
          ch = userRD_buffer[0]
          userWR_buffer[0] = ch
          HID_Write(@userWR_buffer, 1)
          inc(i)
      wend
  wend
  HID_Disable()
 
end.


el archivo del inlude (USBdsc.pbas) que es el que se genera con la aplicacion de mikrobasic para generar los descritores HId  contiene el siguiente codigo:

Código: [Seleccionar]

module USBdsc
include "HIDconstant"
' File Version 1.01
'
'******************************************************************************

'******************************************************************************
' The number of bytes in each report,
' calculated from Report Size and Report Count in the report descriptor
'******************************************************************************
 const HID_INPUT_REPORT_BYTES      = 1
 const HID_OUTPUT_REPORT_BYTES     = 1

 const HID_FEATURE_REPORT_BYTES    = 2
'******************************************************************************
' Byte constants
'******************************************************************************
 const NUM_ENDPOINTS               = 2
 const ConfigDescr_wTotalLength    = USB_CONFIG_DESCRIPTOR_LEN + USB_INTERF_DESCRIPTOR_LEN + USB_HID_DESCRIPTOR_LEN + (NUM_ENDPOINTS * USB_ENDP_DESCRIPTOR_LEN)
 const HID_ReportDesc_len          = 47

 const Low_HID_ReportDesc_len      = HID_ReportDesc_len
 const High_HID_ReportDesc_len     = HID_ReportDesc_len >> 8

 const Low_HID_PACKET_SIZE         = HID_PACKET_SIZE
 const High_HID_PACKET_SIZE        = HID_PACKET_SIZE >> 8



'******************************************************************************
' Descriptor Tables
'******************************************************************************
 const DescTables as byte[USB_DEVICE_DESCRIPTOR_ALL_LEN*2] = (

' Device Descriptor
    USB_DEVICE_DESCRIPTOR_LEN, 0,           ' bLength               - Length of Device descriptor (always 0x12)
    USB_DEVICE_DESCRIPTOR_TYPE, 0,          ' bDescriptorType       - 1 = DEVICE descriptor
    0x00, 0,                                ' bcdUSB                - USB revision 2.00 (low byte)
    0x02, 0,                                '                                           (high byte)
    0x00, 0,                                ' bDeviceClass          - Zero means each interface operates independently (class code in the interface descriptor)
    0x00, 0,                                ' bDeviceSubClass
    0x00, 0,                                ' bDeviceProtocol
    EP0_PACKET_SIZE, 0,                     ' bMaxPacketSize0       - maximum size of a data packet for a control transfer over EP0
    0x34, 0,                                ' idVendor              - Vendor  ID (low byte)
    0x12, 0,                                '                                    (high byte)
    0x01, 0,                                ' idProduct             - Product ID (low byte)
    0x00, 0,                                '                                    (high byte)
    0x01, 0,                                ' bcdDevice             - ( low byte)
    0x00, 0,                                '                         (high byte)
    0x01, 0,                                ' iManufacturer         - String1
    0x02, 0,                                ' iProduct              - String2
    0x00, 0,                                ' iSerialNumber         - ( None )
    0x01, 0,                                ' bNumConfigurations    - 1

' Configuration Descriptor
    USB_CONFIG_DESCRIPTOR_LEN, 0,           ' bLength               - Length of Configuration descriptor (always 0x09)
    USB_CONFIG_DESCRIPTOR_TYPE, 0,          ' bDescriptorType       - 2 = CONFIGURATION descriptor
    ConfigDescr_wTotalLength, 0,            ' wTotalLength          - Total length of this config. descriptor plus the interface and endpoint descriptors that are part of the configuration.
    0x00, 0,                                '                         ( high byte)
    0x01, 0,                                ' bNumInterfaces        - Number of interfaces
    0x01, 0,                                ' bConfigurationValue   - Configuration Value
    0x00, 0,                                ' iConfiguration        - String Index for this configuration ( None )
    0xA0, 0,                                ' bmAttributes          - attributes - "Bus powered" and "Remote wakeup"
    50, 0,                                  ' MaxPower              - bus-powered draws 50*2 mA from the bus.

' Interface Descriptor
    USB_INTERF_DESCRIPTOR_LEN, 0,           ' bLength               - Length of Interface descriptor (always 0x09)
    USB_INTERFACE_DESCRIPTOR_TYPE, 0,       ' bDescriptorType       - 4 = INTERFACE descriptor
    0x00, 0,                                ' bInterfaceNumber      - Number of interface, 0 based array
    0x00, 0,                                ' bAlternateSetting     - Alternate setting
    NUM_ENDPOINTS, 0,                       ' bNumEndPoints         - Number of endpoints used in this interface
    0x03, 0,                                ' bInterfaceClass       - assigned by the USB
    0x00, 0,                                ' bInterfaceSubClass    - Not A boot device
    0x00, 0,                                ' bInterfaceProtocol    - none
    0x00, 0,                                ' iInterface            - Index to string descriptor that describes this interface ( None )

' HID Descriptor
    USB_HID_DESCRIPTOR_LEN, 0,              ' bLength               - Length of HID descriptor (always 0x09)
    USB_HID_DESCRIPTOR_TYPE, 0,             ' bDescriptorType       - 0x21 = HID descriptor
    0x01, 0,                                ' HID class release number (1.01)
    0x01, 0,
    0x00, 0,                                ' Localized country code (none)
    0x01, 0,                                ' # of HID class descriptor to follow (1)
    0x22, 0,                                ' Report descriptor type (HID)
    Low_HID_ReportDesc_len, 0,
    High_HID_ReportDesc_len, 0,

' EP1_RX Descriptor
    USB_ENDP_DESCRIPTOR_LEN, 0,             ' bLength               - length of descriptor (always 0x07)
    USB_ENDPOINT_DESCRIPTOR_TYPE, 0,        ' bDescriptorType       - 5 = ENDPOINT descriptor
    0x81, 0,                                ' bEndpointAddress      - In, EP1
    USB_ENDPOINT_TYPE_INTERRUPT, 0,         ' bmAttributes          - Endpoint Type - Interrupt
    Low_HID_PACKET_SIZE, 0,                 ' wMaxPacketSize        - max packet size - low order byte
    High_HID_PACKET_SIZE, 0,                '                       - max packet size - high order byte
    1, 0,                                  ' bInterval             - polling interval (1 ms)

' EP1_TX Descriptor
    USB_ENDP_DESCRIPTOR_LEN, 0,             ' bLength               - length of descriptor (always 0x07)
    USB_ENDPOINT_DESCRIPTOR_TYPE, 0,        ' bDescriptorType       - 5 = ENDPOINT descriptor
    0x01, 0,                                ' bEndpointAddress      - Out, EP1
    USB_ENDPOINT_TYPE_INTERRUPT, 0,         ' bmAttributes          - Endpoint Type - Interrupt
    Low_HID_PACKET_SIZE, 0,                 ' wMaxPacketSize        - max packet size - low order byte
    High_HID_PACKET_SIZE, 0,                '                       - max packet size - high order byte
    1, 0,                                  ' bInterval             - polling interval (1 ms)

' HID_Report Descriptor
    0x06, 0,                                ' USAGE_PAGE (Vendor Defined)
    0xA0, 0,
    0xFF, 0,
    0x09, 0,                                ' USAGE ID (Vendor Usage 1)
    0x01, 0,
    0xA1, 0,                                ' COLLECTION (Application)
    0x01, 0,
'  The Input report
    0x09, 0,                                ' USAGE ID - Vendor defined
    0x03, 0,
    0x15, 0,                                '   LOGICAL_MINIMUM (0)
    0x00, 0,
    0x26, 0,                                '   LOGICAL_MAXIMUM (255)
    0x00, 0,
    0xFF, 0,
    0x75, 0,                                '   REPORT_SIZE (8)
    0x08, 0,
    0x95, 0,                                '   REPORT_COUNT (2)
    HID_INPUT_REPORT_BYTES, 0,
    0x81, 0,                                '   INPUT (Data,Var,Abs)
    0x02, 0,
'  The Output report
    0x09, 0,                                ' USAGE ID - Vendor defined
    0x04, 0,
    0x15, 0,                                '   LOGICAL_MINIMUM (0)
    0x00, 0,
    0x26, 0,                                '   LOGICAL_MAXIMUM (255)
    0x00, 0,
    0xFF, 0,
    0x75, 0,                                '   REPORT_SIZE (8)
    0x08, 0,
    0x95, 0,                                '   REPORT_COUNT (2)
    HID_OUTPUT_REPORT_BYTES, 0,
    0x91, 0,                                '   OUTPUT (Data,Var,Abs)
    0x02, 0,
'  The Feature report
    0x09, 0,                                ' USAGE ID - Vendor defined
    0x05, 0,
    0x15, 0,                                '   LOGICAL_MINIMUM (0)
    0x00, 0,
    0x26, 0,                                '   LOGICAL_MAXIMUM (255)
    0x00, 0,
    0xFF, 0,
    0x75, 0,                                '   REPORT_SIZE (8)
    0x08, 0,
    0x95, 0,                                '   REPORT_COUNT (2)
    HID_FEATURE_REPORT_BYTES, 0,
    0xB1, 0,                                '   FEATURE (Data,Var,Abs)
    0x02, 0,
'  End Collection
    0xC0, 0                                 ' END_COLLECTION
)
'******************************************************************************
 const LangIDDescr as byte[8] = (
    0x04, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0,
    0x09, 0,                                ' LangID (0x0409) - Low
    0x04, 0                                 '                 - High
)
'******************************************************************************
 const ManufacturerDescr as byte[68] = (
    34, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0,
    "m", 0, 0, 0,
    "i", 0, 0, 0,
    "k", 0, 0, 0,
    "r", 0, 0, 0,
    "o", 0, 0, 0,
    "E", 0, 0, 0,
    "l", 0, 0, 0,
    "e", 0, 0, 0,
    "k", 0, 0, 0,
    "t", 0, 0, 0,
    "r", 0, 0, 0,
    "o", 0, 0, 0,
    "n", 0, 0, 0,
    "i", 0, 0, 0,
    "k", 0, 0, 0,
    "a", 0, 0, 0
)
'******************************************************************************
 const ProductDescr as byte[48] = (
    24, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0,
    "H", 0, 0, 0,
    "I", 0, 0, 0,
    "D", 0, 0, 0,
    " ", 0, 0, 0,
    "L", 0, 0, 0,
    "i", 0, 0, 0,
    "b", 0, 0, 0,
    "r", 0, 0, 0,
    "a", 0, 0, 0,
    "r", 0, 0, 0,
    "y", 0, 0, 0
)
'******************************************************************************
 const StrUnknownDescr as byte[4] = (
    2, 0,
    USB_STRING_DESCRIPTOR_TYPE, 0
)
'******************************************************************************







'******************************************************************************
' Initialization Function
'******************************************************************************
implements
sub procedure InitUSBdsc
dim dummy as byte  volatile register

dummy = NUM_ENDPOINTS
dummy = ConfigDescr_wTotalLength
dummy = HID_ReportDesc_len
dummy = Low_HID_ReportDesc_len
dummy = High_HID_ReportDesc_len
dummy = Low_HID_PACKET_SIZE
dummy = High_HID_PACKET_SIZE
dummy = HID_INPUT_REPORT_BYTES
dummy = HID_OUTPUT_REPORT_BYTES
dummy = HID_FEATURE_REPORT_BYTES
'******************************************************************************
' Byte constants
'******************************************************************************
dummy = NUM_ENDPOINTS
dummy = ConfigDescr_wTotalLength
dummy = HID_ReportDesc_len
dummy = Low_HID_ReportDesc_len
dummy = High_HID_ReportDesc_len
dummy = Low_HID_PACKET_SIZE
dummy = High_HID_PACKET_SIZE
dummy = @DescTables
dummy = @LangIDDescr
dummy = @ManufacturerDescr
dummy = @LangIDDescr
dummy = @ProductDescr
dummy = @StrUnknownDescr
end sub
end.




y la verdad de todo esto no me funciona nada... el proteus ni se da por enterado cuando se simula la conexion de este micro al pc...




http://rapidshare.com/files/198259931/P18F4550.rar.html

Hola en lo personal eso es lo que veo mal que ya estas llegando directo al grano y muchos desconocemos eso de general codigos para el pic y el pc con el compilador no seria mejor irnos desde cero y asi todos entendemos mejor el asunto.

ejemplo como no estamos orientado ni  bien documentado nadie te ha dado una respuesta en concreto ve que tu mismo ya resolvistes lo del oscilador pero la idea es ir contruyendo las cosas por parte ojo con eso no quiero decir que te tu parte puedas ir mas adelantado pero mucho no estamos en tu nivel de adelanto.

La clave estaria en organizacion y documentacion y asi todos entenderemos el tema y asi no quedara uno solo  miembro que use basic que no pueda manejar usb, claro esta si lee este post jajajaja.

Saludos y dios no te la constancia para seguir en este tema del usb y concluirlo con un buen funcionamiento del usb y su tutorial los claro y explicativo para que cualquiera que lo lea pueda usar usb sin ningun problema y deje de ser un tema de temor ya que como lo dije antes usb para mi no es cosa imposible es creado por un ser huma igual y comun que nosotros solo que ya el tiene el conocimiento y por eso se le hiso posible cosa que nosotros estamos buscando el conocimiento del usb para pic.

Atten.
Alexander Santana.
Barcelona-Venezuela.

[ekud]

jeje bueno es que yo tampoco tengo muchas cosas claras... jeje pero ps pa eso estamos aki para aprender todos...

bueno siendo un poco mas especificos con este codigo que mostre intentare explicar algo haber si entre todos damos con la respuesta de por que no funciona.

La idea de este codigo es que el microcontrolador retorna al pc los mismos datos que el pc le envia al microcontrolador teniendo eso en mente comenzemos a deducir el codigo...

En la primera parte encontraremos lo siguiente:

Código: [Seleccionar]

program USB_HID_test

include "USBdsc"

dim
 k, i, ch       as  byte
 userWR_buffer  as  byte[64]
 userRD_buffer  as  byte[64]
En estas lineas lo que se le "dice" al micro es lo siguiente:

• Que el programa se llama USB_HID_test, aunque esto como tal seria una directiva del compilador y no del micro.
• Tambien que estamos incluyendo toda la informacion que se encuentra en el archivo "USBdsc", este archivo es el que generamos con la aplicaccion de mikrobasic para generar los descriptores de las conexiones usb del tipo HID, mas adelante veremos mas detalladamente como generar este archivo.
• Y lo que resta... son las declaraciones de las variables, entre estas las mas importantes para nuestros objetivos podria deirse que son los buffer de lectura y escritura del usb. En este caso notamos que ambos buffer estan compuestos por 64bytes cada uno.

Ahora bien... veamos como generar el archivo con los descriptores HID necesarios usando el mikrobasic.

lo primero es abrir el mikrobasic.... (un pokito obvio no? jeje)



Luego nos dirigimos al menu tools



Damos click en HID terminal... se nos abrira la siguiente ventana



Fijemonos en que en cuanto abrimos esta ventana en la parte superior se nos presentan dos pestañas... una que dice "terminal" y la otra que dice descriptor

En la pestaña terminal, la utilizaremos para comprobar que nuestro circuito despues de armado o simulado funciona bien, por ahora nos centraremos mas en el uso de la pestaña "descriptor".asi pues si damos click en dicha pestaña veremos lo siguiente:



modificando los parametros de esta ventana podremos obtener elarchivo descriptor que necesitemos, como para el ejemplo al que estoy haciendo alusion ya estaba creado el archivo pues por ahora no lo tocaremos, es solo para mostrar la herramienta como tal.

Bueno despues de ese "breve" parentesis sigamos analizando el codigo haber a que conlcusion llegamos...

Bueno despues de declarar las variables (y sigiendo el orden de los programas en mikrobasic) continuamos con los proeceimientos...

en este codigo se tienen dos procedimientos, uno de ellos es una interrupcion para mantener "viva" la comunicacion USB, el otro procedimiento solo es para configurar los puertos del microcontolador y todas las interrupciones.

el procedimiento para mantener viva la comunicacion usb seria el siguiente:

Código: [Seleccionar]

'******************************************************************************
' Main Interrupt Routine
'******************************************************************************
sub procedure interrupt
'** this is a way to call a procedure from interrupt
  HID_InterruptProc
end sub
'******************************************************************************

y el procedimiento en el cual se configuran los puertos y se deshabilitan las interrupciones que no son necesarias es el siguiente:

Código: [Seleccionar]


'******************************************************************************
' Initialization Routine
'******************************************************************************
sub procedure Init_Main
'--------------------------------------
' Disable interrupts
'--------------------------------------
INTCON = 0                             ' Disable GIE, PEIE, TMR0IE,INT0IE,RBIE
INTCON2 = 0xF5
INTCON3 = 0xC0
RCON.IPEN = 0                          ' Disable Priority Levels on interrupts
PIE1 = 0
PIE2 = 0
PIR1 = 0
PIR2 = 0

ADCON1 = ADCON1 or 0x0F                ' Configure all ports with analog function as digital
'--------------------------------------
' Ports Configuration
'--------------------------------------
TRISA = 0xFF
TRISB = 0xFF
TRISC = 0xFF
TRISD = 0
TRISE = 0x07

LATA = 0
LATB = 0
LATC = 0
LATD = 0
LATE = 0
end sub
Bueno ahora bien pasemos a analizar el codigo principal, el que hace la funcion de la comunicacion usb como tal.

el codigo que hace funcional nuestro ejemplo es el siguiente:

Código: [Seleccionar]

'******************************************************************************
' Main Program Routine
'******************************************************************************

main:
  Init_Main()
 
  HID_Enable(@userRD_buffer, @userWR_buffer)
  Delay_mS(1000)
  Delay_mS(1000)

  while true
      k = HID_Read()
      i = 0
      while i < k
          ch = userRD_buffer[0]
          userWR_buffer[0] = ch
          HID_Write(@userWR_buffer, 1)
          inc(i)
      wend
  wend
  HID_Disable()
 
end.
lo primero que podemos notar es que se hace un llamado al procedimiento visto anteriormente para configurar los puertos y las interrupciones, esto se logra con:

Código: [Seleccionar]

  Init_Main()
Despues de configurado los puertos y las nterrupciones, lo que sigue es Habiliatar la comunicacion usb y esto lo logramos con lo siguiente:

Código: [Seleccionar]

  HID_Enable(@userRD_buffer, @userWR_buffer)
  Delay_mS(1000)
  Delay_mS(1000)
Veamos la ayuda que nos ofrece el mikrobasic para determinar que hacen estas 3 lineas... primero comenzamos con HID_Enable.

Hid_Enable

Prototype:     sub procedure Hid_Enable(dim readbuff, writebuff as word)
 
Returns:        Nothing.
 
Description:   Enables USB HID communication. Parameters readbuff and writebuff are the addresses of Read Buffer and the Write Buffer, respectively, which are used for HID communication. You can pass buffer names with the @ operator.

This function needs to be called before using other routines of USB HID Library.
 
Requires:      Nothing.
 
Example:      Hid_Enable(@rd, @wr)

esto basicamente quiere decir que esta funcion lo que hace es habilitar la comunicacion usb y que como parametros necesita el nombre de las dos variables que le van a servir como buffers a la comnicacion usb, ademas tambien se dice que esta funcion no depende de ninguna otra funcion y que esta funcion debe ser llamada para poder usar otras funciones de esta libreria.

asi pues la linea:
  HID_Enable(@userRD_buffer, @userWR_buffer)

lo que hace es habilitar la comunicacion usb y determinar cuales van a ser los buffers de entrada y salida de la comunicacion usb.

las lineas que siguen...
  Delay_mS(1000)
  Delay_mS(1000)

lo que hacen es dar un tiempo para que este proceso de la habilitacion de la comunicacion se estabilize.

A continuacion sigue un bucle infinito:

Código: [Seleccionar]

  while true
      k = HID_Read()
      i = 0
      while i < k
          ch = userRD_buffer[0]
          userWR_buffer[0] = ch
          HID_Write(@userWR_buffer, 1)
          inc(i)
      wend
  wend
comenzemos a intentar interpretar este codigo...

primero que todo encontramos una sentencia "while true"que nos somete a un bucle infinito... luego lo que hacen es que la variabe K le asignamos lo que se lee de la comunicacion usb... veamos como funciona y para que sirve la funcion HID_Read()

Hid_Read

Prototype:    sub function Hid_Read as byte
 
Returns:       Number of characters in the Read Buffer received from the host.
 
Description:  Receives message from host and stores it in the Read Buffer. Function returns the number of characters received in the Read Buffer.
 
Requires USB HID needs to be enabled before using this function. See Hid_Enable.
 
Example:     length = Hid_Read

En otras palabras lo que hace esta funcin es recivir los bytes enviados desde el host, y guardarlos en el buffer de lectura... y nos retorna la longuitud o el numero de caracteres recividos y almacenados.

asi pues en la variable K tendiamos el numero de carateres enviados desde el host, lo que sigue es que hacemos que la variable i sea igual a cero para usarla como un contador.

Acontinuacion en esta parte del codigo se lee lo que llego del host y se envia lo mismo que llego...

Código: [Seleccionar]

       while i < k
          ch = userRD_buffer[0]
          userWR_buffer[0] = ch
          HID_Write(@userWR_buffer, 1)
          inc(i)
       wend

En este codigo hacemos que la variable ch sea iagual al primer byte del buffer de lectura, luego hacemos que el primer byte del buffer de escritura sea igual a la variable ch, luego usando la funcion "HID_Write"

Veamos para que sirva la funcion Hid_Write

Hid_Write
Prototype sub procedure Hid_Write(dim writebuff as word, dim len as byte)
 
Returns Nothing.
 
Description Function sends data from Write Buffer writebuff to host. Write Buffer is the address of the parameter used in initialization; see Hid_Enable. You can pass a buffer name with the @ operator. Parameter len should specify a length of the data to be transmitted.
 
Requires USB HID needs to be enabled before using this function. See Hid_Enable.
 
Example Hid_Write(@wr, len)

Esta funcion como parametros necesita que le digamos cual es el buffer de salida o escritura y la longitud de los datos a enviar...

asi pues... en la linea:
HID_Write(@userWR_buffer, 1)

lo que se prentende es enviar el primer byte del buffer de escritura a el host (recordemos que el primer byte del buffer de escritura fue previamente fue "llenado" con el primer byte del buffer de lectura)

despues con la instruccion:
inc(i)
logramos que este proceso se repita tantas veces como caracteres hallan llegado...

al final salimos del bucle y con la intruccion
HID_Disable()

desabilitamos la comunicacion usb y terminamos el programa

como pueden ver el codigo como tal no es complikado... y pues todo en esta prte del soft del micro es muy clara

lo que no entiendo es por que no me simula en el proteus... alguien tiene una idea de por que no funciona... o podria darnos una mano haber si los que estamos comenzando logramos despegar....

ahh por cierto el circuito propuesto por mikrobasic es el siguiente:



como ven el circuito tambien es bastante sencillo... y el que con el que yo estoy simulando en proteus es el siguiente:



y ps es el mismo no???

entonces alguien podria decirme cual es el error de por que no me simula??? 

bueno espero haber podido colaborar en algo a algun usuario con la explicacion del soft

[jonathanPIC888]

Miren leí el titulo y despues de mucho experimentar con visual basic y C de CCS pude terminar un ejemplo con PIC18F2550 y protocolo HID si quieren el código diganme y lo posteo.

[ekud]

claro por que no podria sernos de ayuda con lo del vb... y tal vez podriamos basarnos en el programa del micro para generarlo en lenguaje basic ya sea mikrobasic o proton o no se

[jonathanPIC888]

Bueno acá les dejo el ejemplo 

Ahora yo también he hecho ejemplos con HID y el proton pero me resulto increiblemente más facil usar la librería nativa de windows.

Y la programación en C cualquier cosa que no entiendan diganme pof¿r favor.

[septiembre_negro]

Hola que tal, paso por aquí  saben leí lo que comentan acerca del USB y aunque dicen que no son agresivos sus post, leyéndolos bien si  lo son y bastante. En que me baso  para decir esto, pues en lo siguiente. Llevo tiempo leyendo Todopic y M&M y la verdad he visto información clara mas con lo de USB que es lo que atacan aquí. Empezando por el tutorial con ejemplos de este mismo foro -todopic

Creo que el PDF de la página de Lord lafebre es bastante claro,
tomando en cuneta la parte introductoria
Yo pienso que Uds. están atacando mal el problema, si en realidad lo que quieren es ser expertos en USB les recomiendo antes de empezar a codificar tener claro lo siguiente:
El USB no es como una comunicación serie que solo se conecta y ya. EL USB tiene protocolos de comunicación entre los que están HID, de los cuales tiene ejemplos, CDC de los cuales también los hay, transmisión BULK
Recientemente la introducción de los PICS OTG -Onthe GO- que permiten ser 2 vias y Embbeded Host incluso con los PICs
Pero no esperen que se les de digerida esta información
Creo que los compañeros nos dan las bases pero nosotros tenemos que profundizar por ejemplo con JAN AXELSON y su libro de la 3ra edición del usb completo.
Incluso en M&M hay un post que habla de la TP2550 y MKB y a mi parecer es claro con lo de los fuses y el descriptor

Además de que esta todo comentado
Y si aun quieren usar algo que no sea HID aunque ya lo dominen esta otro ejemplo de USB en modo CDC también en M&M
Yo entiendo que ante la frustración de perder ciertos conceptos es fácil criticar el trabajo de los demás
Pero recuerden que los ejemplos los ponen con su tiempo y lo hacen sin esperar nada a cambio
Si realmente desean colaborar háganlo y no critiquen pónganlo o mejórenlo pero eviten esos comentarios y risas que finalmente si son burlonas.
Que quede muy claro que nadie va a inventar el agua tibia o el hilo negro recuerden siempre que cualquier cosa que hagamos alguien mas ya lo hizo así que a conducirse con respeto  que les caería que dentro de unos meses alguien  comience un nuevo hilo  basado en su trabajo y comience dicho hilo con frases como esta.

“Oye he estado mirando los post de usb  con pic aca en el area de basic y lo que ami respecta no hay nada claro y bien explicado”

“Jajaja si hermano pero como ya explique esta listo pero en otro lenguaje es decir en este tema es usando basic y no me rio en forma de burla”
Así que para rematar les pongo los enlaces  no sin antes agradecer a cada una de las personas que aportaron a los mismos ya que gracias a su esfuerzo y sobre todo su tiempo nos han hecho mas fácil el camino.


http://www.todopic.com.ar/foros/index.php?topic=13406.0


http://micros.mforos.com/1149902/7944595-tp2550-mikrobasic/?marcar=tp2550


http://micros.mforos.com/1149902/8249735-ejemplos-usb-en-modo-cdc-con-proton/?marcar=cdc

[ekud]

Muy buen aporte en todo sentido de la palabra!

y ps no se... tal vez soy un pokititiko nuevo ocn estos micros y tal vez por eso no me funciona...

pero definitivamente no doy con mi error...

es que nisiquiera haciendo el que propone navaismo en este link me funciona ni me simula ni naaa

http://micros.mforos.com/1149902/7944595-tp2550-mikrobasic/?marcar=tp2550

 

[jonathanPIC888]

yo vengo con el tema del usb desde principio de año y ahora recien estoy entendiendo su funcionamiento
he leido bastante y me he quemado las pestañas a mas no poder. Me ha costado mucho q me salgan bien los programas.
Igual para cualquier cosa siempre estoy dispuesto a dar una mano 

[ekud]

y en que lenguaje los manejas??

por cierto... parece k mikrobasic 7.2 tiene un bug en la libreria HID... segun parece lo estan corrigiendo ya en la 7.3 beta...

[jonathanPIC888]

Mirá todos los ejercicios y proyectos de USB los hago con C de CCS. Viene con librerías incorporadas para manejar los protocolos HID,CDC,bulk transfer . Lo único que me faltaria por ver sería el tema de MSDC que no hay nada de eso en CCS solo en C18.
Por lo pronto no utilizo basic , por que estoy familiarizado más con C, aunque utilizo visual basic para PC