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:
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:
'******************************************************************************
' 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:
'******************************************************************************
' 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:
'******************************************************************************
' 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:
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:
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:
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...
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