#include "Conección USB.h" //-------------------------------------------> Aca estan todos los FUSES.
//-------------------------------------------------------------------------------> Incluimos librerías utilizadas por la aplicación.
#include "pic18_usb.h" //----------------------------------------------> Drivers's USB de los PIC18F [ original ].
#include "Descriptor_easyHID.h" //----------------------------------------------> Descriptores HID del proyecto.
#include "USB.c" //----------------------------------------------> Funciones del USB [ original ].
//------------------------------------------------------------------------------->
#byte porta= 0xf80
#byte portb= 0xf81
#byte portc= 0xf82
#byte portd= 0xf83
#byte porte= 0xf84
#bit ra0= 0xf80.0
#bit ra1= 0xf80.1
#bit ra2= 0xf80.2
#bit ra3= 0xf80.3
#bit ra4= 0xf80.4
#bit ra5= 0xf80.5
#bit rb0= 0xf81.0
#bit rb1= 0xf81.1
#bit rb2= 0xf81.2
#bit rb3= 0xf81.3
#bit rb4= 0xf81.4
#bit rb5= 0xf81.5
#bit rb6= 0xf81.6
#bit rb7= 0xf81.7
#bit rc0= 0xf82.0
#bit rc1= 0xf82.1
#bit rc2= 0xf82.2
#bit rc6= 0xf82.6 //----------------------------------------------> Led Error al enumerar.
#bit rc7= 0xf82.7 //----------------------------------------------> Led USB_OK al enumerar.
#bit rd0= 0xf83.0
#bit rd1= 0xf83.1
#bit rd2= 0xf83.2
#bit rd3= 0xf83.3
#bit rd4= 0xf83.4
#bit rd5= 0xf83.5
#bit rd6= 0xf83.6
#bit rd7= 0xf83.7
#bit re0= 0xf84.0 //----------------------------------------------> Usado para "USB_CON_SENSE_PIN"
#bit re1= 0xf84.1
#bit re2= 0xf84.2
#define USB_CON_SENSE_PIN re0
//#define USB_CONFIG_HID_TX_SIZE 32 //-------------------------------------------> Definimos el tamaño del endpoint de salida.
//#define USB_CONFIG_HID_RX_SIZE 32 //-------------------------------------------> Definimos el tamaño del endpoint de entrada.
int recibe[USB_EP1_RX_SIZE]; //-------------------------------------------> Declaramos la variable recibe de 32 bytes.
int envia[USB_EP1_TX_SIZE]; //-------------------------------------------> Declaramos la variable envía de 32 bytes.
void secuencia ()
{
rb0= 1;
delay_ms (250);
rb1= 1;
delay_ms (250);
rb2= 1;
delay_ms (250);
rb3= 1;
delay_ms (250);
portb= 0x00;
}
void secuencia_0 ()
{
rb0= 1;
delay_ms (100);
rb1= 1;
delay_ms (100);
rb2= 1;
delay_ms (100);
rb3= 1;
delay_ms (100);
portb= 0x00;
}
void USB_debug()
{
rc6= 1; //----------------------------------------------> Enciende el led error y apaga el led USB_OK.
rc7= 0;
usb_wait_for_enumeration(); //----------------------------------------------> Espera a ser enumerado por el host.
rc6= 0; //----------------------------------------------> Enciende el led USB_OK y apaga el led USB_ERROR.
rc7= 1;
}
void main()
{
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_CLOCK_DIV_2|ADC_TAD_MUL_0);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
//Setup_Oscillator parameter not selected from Intr Oscillator Config tab
// TODO: USER CODE!!
set_tris_a (0x00);
set_tris_b (0x00);
set_tris_c (0x00);
set_tris_d (0x00);
set_tris_e (0x00);
porta= 0x00;
portb= 0x00;
portc= 0x00;
portd= 0x00;
porte= 0x00;
usb_init(); //--------------------------------------------------> Inicializamos el stack USB.
USB_debug(); //--------------------------------------------------> Nos muestra el estado de conección del USB.
while (1)
{
usb_init_cs();
usb_task(); //--------------------------------------------------> Habilita el periferico usb y las interrupciones.
if (usb_attached())
{
if(usb_enumerated()) //-------------------------------------------------> Si el dispositivo está configurado...
{
usb_put_packet(1, envia, USB_CONFIG_HID_TX_SIZE, USB_DTS_TOGGLE);//-------> Enviamos el paquete de datos por USB.
if (usb_kbhit(1)) //----------------------------------> Si hay un paquete de datos del host.. en el buffer lo tomamos y guardamos en la variable data.
{
usb_get_packet(1, recibe, USB_CONFIG_HID_RX_SIZE);//----------------> En el buffer lo tomamos del EP1 y lo guardamos en la variable recibe....
if (recibe[0]==0x00) {secuencia();}
}
}
}
if (!usb_attached())
{
secuencia_0();
}
}
}
void main(void) // Función Principal.
{
// Variables globales.
int8 recibe[USB_EP1_RX_SIZE]; // Declaramos la variable recibe de 32 bytes.
// Configuraciones varias.
set_tris_b(0xF0); // Nibble bajo salidas, el alto entradas.
output_b(0x00); // Inicializamos las salidas a 0.
set_tris_c(0b00111000); // RC0,RC1,RC2,RC6,RC7,como salidas. Las demás
// RC4,RC5, como entradas.
usb_init(); // Inicializamos el stack USB.
usb_task(); // Habilita el periferico usb y las interrupciones.
while (TRUE) // Bucle infinito.
{
if(usb_enumerated()) // Si el dispositivo está configurado...
{
if (usb_kbhit(1)) // Si hay un paquete de datos del host.. en el buffer lo tomamos y guardamos en la variable data.
{
usb_get_packet(1, recibe, USB_CONFIG_HID_RX_SIZE); // En el buffer lo tomamos
output_toggle(pin_b1); // Enciende porque hay datos
if(recibe[0]==0x0A){
output_toggle(pin_b1); // Enciende porque mande el comando de control
if(recibe[1]==0x0A){
output_toggle(pin_b0);
//Deveria encender porque tambien le mande el dato de control desde el c#
}
}
}
}
}
}
}// Versión de la plantilla para cristal de 4.00Mhz.
#include <18F4550.h> // Definición de registros internos del PIC18F4550.
#fuses NOMCLR,XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN,NOPBADEN
#use delay(clock=48000000) // Trabajamos a 48.00Mhz.
// Definiciones del USB:
#DEFINE USB_HID_DEVICE TRUE // Vamos a utilizar el protocolo HID.
#define USB_EP1_TX_ENABLE USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE 8 // Definición del tamaño del buffer de salida.
#define USB_EP1_RX_ENABLE USB_ENABLE_INTERRUPT
#define USB_EP1_RX_SIZE 8 // Definición del tamaño del buffer de entrada.
// Definiciones varias:
#define ON output_high
#define OFF output_low
// Definicion de control
#define CARTON 170 //Comando para activar visualizador
// Salidas de uso general.
#define LED1 PIN_B0
//Registro 4094
#define DATA PIN_B1
#define CLOCK PIN_B2
#define STROBE PIN_B3
/*********************************************************************************************************/
// Definición de las librerías utilizadas.
#include <pic18_usb.h> // Drivers's USB del PIC18F4550.
#include <USB_easyHID_descriptores.h> // Descriptores USB para la placa MoyaPIC_USB28 y easyHID.
#include <usb.c> // Funciones del USB.
//0 1 2 3 4 5 6 7 8 9
INT const segmentos[10]={0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};
void escribir(INT caracter);
/**********************************************************************************************************/
void main()
{
//Cuerpo principal del programa.
//Variables locales del main.
CHAR recibe[8];//Variable que contiene los datos que se van a visualizar en los led's.
CHAR dcarton[5];
INT t;
//Configuramos los puertos del microcontrolador:
//set_tris_a(0x00);//Define el puerto A.//RA0, como entrada
set_tris_b(0x00);//Define el puerto B.//Todo el puerto B como salida.
//set_tris_c(0b00000000);
//set_tris_d(0b00000000);
//set_tris_e(0b00000000);
output_b(0x00);//Limpiamos el puerto B.
output_b(0xff);
delay_ms(500);
output_b(0x00);
//Otras configuraciones:
disable_interrupts(global);
disable_interrupts(INT_timer1);
disable_interrupts(INT_rda);
disable_interrupts(INT_ext);
disable_interrupts(INT_ext1);
disable_interrupts(INT_ext2);
setup_spi(FALSE);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
port_b_pullups(FALSE);
usb_init_cs();//inicia el USB y sale. Va de la mano con usb_task().
WHILE(true)
{
usb_task();//Configuramos el puerto USB.
IF(usb_enumerated())//Si el puerto es enumerado y configurado por el host..
{
IF(usb_kbhit(1))//Si hay un paquete de datos en el buffer lo tomamos y guardamos en la variable data.
{
usb_get_packet(1, recibe, 8);
output_toggle(LED1);
delay_ms(200);
IF(recibe[0]==CARTON)
{
[B][COLOR="Red"] // Aqui esta el error[/COLOR][/B]
dcarton[0]=recibe[1];[COLOR="Lime"] //funciona[/COLOR]
delay_ms(50);
dcarton[1]=recibe[2];[COLOR="rgb(65, 105, 225)"]//no funciona[/COLOR]
delay_ms(50);
dcarton[2]=recibe[3];[COLOR="rgb(65, 105, 225)"]//no funciona[/COLOR]
delay_ms(50);
dcarton[3]=recibe[4];[COLOR="rgb(65, 105, 225)"]//no funciona[/COLOR]
delay_ms(50);
dcarton[4]=recibe[5];[COLOR="RoyalBlue"]//no funciona[/COLOR]
delay_ms(50);
output_toggle(LED1);
delay_ms(50);
}
}
}
//Visualizadores
FOR(t=0; t<5; t++)
{
escribir(dcarton[t]);
delay_ms(500);
}
}
}
void escribir(INT caracter)
{
INT c;
OFF(PIN_B1);
OFF(STROBE);
OFF(CLOCK);
FOR(c=0; c<8; c++)
{
output_bit(DATA, bit_test(segmentos[caracter], c));
ON(CLOCK);
delay_cycles(1);
OFF(CLOCK);
}
OFF(CLOCK);
ON(STROBE);
delay_cycles(1);
OFF(STROBE);
} private void UPDATE_USB_Tick(object sender, EventArgs e)
{
int num1;
//Datos a enviar al pic
byte[] BufferOUT = new byte[EasyHID.BUFFER_OUT_SIZE];
BufferOUT[0] = 0x0; // Report ID
BufferOUT[1] = 0xAA; // Primero enviamos un comando de control 0x0A (CARTON).
char MYCARACTER;
string mystr = CARTON.Text;
int i;
for (i = 0; i < 5; i++)
{
MYCARACTER = mystr[i];
// COMO CONVIERTO DE CHART A INT
num1 = (Convert.ToInt32(MYCARACTER)) - 48;
switch (num1)
{
case 0:
dato = 0x00; break;
case 1:
dato = 0x01; break;
case 2:
dato = 0x02; break;
case 3:
dato = 0x03; break;
case 4:
dato = 0x04; break;
case 5:
dato = 0x05; break;
case 6:
dato = 0x06; break;
case 7:
dato = 0x07; break;
case 8:
dato = 0x08; break;
case 9:
dato = 0x09; break;
}
BufferOUT[i + 2] = dato;
}
EasyHID.Write(controlador, BufferOUT); // Envía los datos.
}Bueno perdón por no poder responder todas sus preguntas a la brevedad ...las he leido..pero no he tenido tiempo para analizar lo que les pasa
Les explico algunos puntos para que tengan en cuenta:
Las transferencias que yo he realizado siempre las realicé usando 1 solo buffer con un tamaño máximo máximo de 64 bytes.
Esto es una limitación física ya que por endpoint no podemos manejar más de 64 bytes...según lo que dice la hoja de datos del PIC18F2550.
Según la arquitectura del PIC18F2550 podemos manejar hasta 15 endpoint's (16 tomando en cuenta el de control).
El PIC puede realizar transferencias usando el modo PING - PONG....usando toda la capacidad del microcontrolador para comunicarse....el problema está en que hay definido 1 solo endpoint para trabajar con la librería de CCS...cosa que no ocurre en el driver de C18..con lo cual nuestro buffer puede tener un tamaño máximo de 64 bytes de entrada y 64 bytes de salida.
En su momento encontré un modo de acceder a más endpoint...según lo que hizo un usuario de otro foro...pero nunca lo implementé.
AHORA LO IMPORTANTE:
El error que se muestra más arriba es por los cambios que ha relizado CCS en sus librerías a partir de la versión 4.093....es por esto que a los usuarios han tenido problemas al manejar sus programas...debido a que no he posteado las diferencias que encontré.
Ahora SI expuse las diferencias en el manual que realicé sobre el puerto USB ...(que cabe mencionar, no está terminado)..ahí se muestra en el firmware los cambios que hice, por lo que es cuestión de analizar el código e implementarlo en sus propios programas.
Un saludo !
Primero que nada muchisimas gracias por toda la informacion que a puesto en este hilo.
El problema que tenia ya lo resolvi el descriptor que tengo declarado en el codigo fue lo que cambie por otro y funciono correctamente.
Al parecer el archivo del descriptor no estaba bien configurado.
Muchas gracias por su ayuda
