Con dolor de cabeza, pero satisfecho (USBCDC PIC24)

[planeta9999]

Entonces me aconsejas el LM1117?

Si es solo para alimentar el PIC, sin cargas en los puertos, es excesivo.
Además el consumo, depende de la temperatura, la frecuencia de reloj y el voltaje de alimentación, todo eso lo tienes en el datasheet "DC CHARACTERISTICS: OPERATING CURRENT".

Me paso una cosa que no os he contado, tenia la huella del regulador dada la vuelta ya que no habia el mismo modelo de regulador que el mio, entonces durante unas cuantas veces hasta que me di cuenta estuve alimentando al pic en vez de con 3.3V con 4.2, 4.3 Voltios.
Creeis que fue suficiente para joderle? deberia de sustituirle por uno nuevo?

Como puedes ver en el datasheet, el voltaje de alimentación debe de estar entre 2v y 3.6v, yo diría que te lo has cargado.

[alperez]

Entonces me aconsejas el LM1117?

Me paso una cosa que no os he contado, tenia la huella del regulador dada la vuelta ya que no habia el mismo modelo de regulador que el mio, entonces durante unas cuantas veces hasta que me di cuenta estuve alimentando al pic en vez de con 3.3V con 4.2, 4.3 Voltios.

Creeis que fue suficiente para joderle? deberia de sustituirle por uno nuevo?

Un saludo chicos, no sabeis la ayuda que me estais prestando...os estare siempre agradecidos, si consigo terminar el proeycto os envio unos bombones jejejeje =) 

A ver si entiendo, si la das la vuelta al DC/DC "al espejo" Y UNICAMENTE AL DC/DC, vas a poner a 4.2 la entrada del DC/DC pero no del PIC.
Entonces deberías de mirar la posibilidad de que "algo de corriente viajara" desde los 3v3 hasta los 4v2 del DC/DC, suponiendo que la pata del centro sea GND.
Si es así debes mirar en el datasheet a ver si dice algo sobre la impedancia salida-entrada o corriente directa inversa.

No se si me he explicado, por darle la vuelta al DC/DC no le das 4.2v al PIC, si no a la salida del DC/DC.

De todas formas pon en alto todos los puertos y mide con un polimetro a ver si todavia funciona, si puedes leer/grabar y no está caliente el PIC (se calientan cuando tienen un corto) es posible que todavía funcione.

[musttork]

NO no! le di la vuelta al regulador de tension, no al convertidor! es decir al ponerle a la salida los 5v del convertidor y a la entrada pues todo lque venia a salida...soea un pifostio...cuand medi a la salida media 4.3V, de ahi q dije algo falla...por que si tiene que ser 3.3 y m da 4.2...y me di cuenta de lo de la huella, que estaba invertida.

De todos modos, el LM3940, es de 1A, creeis que es excesivo? unicamente tiene que alimentar lo que veis en el esquema, el PIC, y los optoaclopadores como veis, unicamente esas salidas de los optos van a salir pulsos.

[planeta9999]

De todos modos, el LM3940, es de 1A, creeis que es excesivo? unicamente tiene que alimentar lo que veis en el esquema, el PIC, y los optoaclopadores como veis, unicamente esas salidas de los optos van a salir pulsos.

Si, es excesivo.
El PIC a la máxima velocidad, alimentado a 3.3v, tendrá un consumo de unos 24mA máximo, según el datasheet, más el consumo de los puertos.
Añade 10-15mA por cada led de los optos, más el consumo de la carga que pongas a la salida de los optos.
Con un regulador que aguante 100-150mA, sobra.
Y quita ese conversor DC/DC que no vale para nada, si quieres aislar la alimentación del puerto USB, pon un diodo schottky a la entrada del regulador.

[musttork]

Chicos he puesto todos los pines a 1, para ver si sigue vivo...

a la salida del pic tengo una tension de 3Voltios más o menos, es eso normal? no tendria que dar 5v?

En cuanto al convertidor, si creo que le voy a quitar, ya que es bastante estable la tension del usb y con un diodo shotcky es suficiente.

[alperez]

Chicos he puesto todos los pines a 1, para ver si sigue vivo...

a la salida del pic tengo una tension de 3Voltios más o menos, es eso normal? no tendria que dar 5v?

En cuanto al convertidor, si creo que le voy a quitar, ya que es bastante estable la tension del usb y con un diodo shotcky es suficiente.

Estás alimentando el PIC a 3'3v, que es lo correcto, por lo tanto cuando un pin de un puerto está a nivel alto, éste se pone a la alimentación del PIC, o sea, a esos 3'3v, menos algún que otro milivoltio que se pueda perder, pero es correcto.

Mira a ver si el PIC se calienta, pero yo diría que está bien.

Otra cosa, aún sigue sin cuadrarme que al darle la vuelta al regulador te diera esa tensión de 4 y pico voltios, y aún siendo así es posible que la corriente sea minúscula y por eso tu PIC haya sobrevivido.

[musttork]

A mi tampoco me cuadró...es decir a la entrada tenia lo que tenia que tener a la alida..es decir, los pines VDD del pic, y las resistencias de los opto etc...pero ahi no deberia de haber tensiones de ningun tipo, a menos que al enchufar los 5voltios en el pin de salida se inducieran de alguna manera 4.2 voltios a la entrada...nose es raro...

aun asi, el regador funciona correctamente entregando 3.3voltios...

ahora el verdadero problema...sino es de hadware y el pic parece que sigue vivo...de que narices puede ser el problema de no reconocermele...S:S:S el PID y el VID, son el mismo que en el arhicvo .inf....

al tener un ristal de 8 mHZ he puesto en el pll DIV2 para tener los 4Mhz necesarios para el USB.

os pongo la configuracion que he puesto por is veis algo raro:

Código: [Seleccionar]

//Mi Proyecto**********************************************************************************************************
#elif defined(__PIC24FJ256GB106__)
_CONFIG1( JTAGEN_OFF & GCP_OFF & GWRP_OFF & FWDTEN_OFF & ICS_PGx1)
    _CONFIG2( PLL_96MHZ_ON & IESO_OFF & FCKSM_CSDCMD & OSCIOFNC_ON & POSCMOD_HS & FNOSC_PRIPLL & PLLDIV_DIV2 & IOL1WAY_ON)
//********************************************************************************************************** 
 

[alperez]

Prueba este hex ¡¡ PERO CON UN XTAL DE 4MHz!!!!

Yo ahora no puedo compilartelo con 8 MHz pero si tienes uno de 4MHz y puedes probarlo estarás seguro que enumerar enumera.

[musttork]

Que es el hex ese que has subido? esuqe no tengo ningun reloj de 4MHZ, no se puede utilizar el interno?

[planeta9999]

En las Microchip Solutions, tienes mucho código fuente para USB, tanto HID como MCHPUSB.
Yo he probado algunos ejemplos con PIC32, para emular teclado, ratón, joystick, comunicacion USB con driver, y me han funcionado muy bien.

[musttork]

En las Microchip Solutions, tienes mucho código fuente para USB, tanto HID como MCHPUSB.
Yo he probado algunos ejemplos con PIC32, para emular teclado, ratón, joystick, comunicacion USB con driver, y me han funcionado muy bien.

He tirado con el ejemplo de Microchip Solution CDC, cambiando e introduciendo mi PIC, el problema es que no me detecta el dispositivo, no se si por tener algun problema en el hardware o en el software...que me falte algo en la configuracioón, o algun archivo o algo.

Subiria todo mi archivo pero es demasiado grande. Tendria que pasaroslo por correo electronico.

[alperez]

Que es el hex ese que has subido? esuqe no tengo ningun reloj de 4MHZ, no se puede utilizar el interno?

es una prueba USB <-> RS485, cuando tenga tiempo te compilo ese codigo con xtal de 8Mhz

[planeta9999]

He tirado con el ejemplo de Microchip Solution CDC, cambiando e introduciendo mi PIC, el problema es que no me detecta el dispositivo, no se si por tener algun problema en el hardware o en el software...que me falte algo en la configuracioón, o algun archivo o algo.

Subiria todo mi archivo pero es demasiado grande. Tendria que pasaroslo por correo electronico.

Prueba con un HID, por ejemplo un emulador de teclado.
¿ Has mirado en el Administrador de Dispositivos de windows, a ver si sale algún error ?.

Yo solo he probado los HID, porque me interesaba emular un teclado estandar para varios proyectos, y por curiosidad también probé el MCHPUSB para ver como tira el driver de Microchip, ambos me funcionaron perfectamente con PIC32. También tengo el bootloader, que me reconoce a la perfección nada más conectar el PIC.

[musttork]

Os pongo al dia. Cambie el PIC por si estuviera dañado el otro. He revisado vuestros circuitos, el mio, 2 de internet, uno de otro chico de mi universidad y el circuito del PI24F Starter Kit de Microchip y he comprobado que el hardware está correcto, da las tensiones que tiene que dar y las conexiones como deben estar, asique supongo que es de software. He estado rehaciendo todos los archivos de nuevo, siendo muy semejarntes al proyecto del chico que os digo para comunicarle con el USB, ya que él lo logro pero con un PIC32X, he cambiado cosas, y a la hora de compilar parecia que estaban arreglados todos los fallos, pero me da al final este:

main.o(.text+0x5a): In function `USBCBSuspend':
C:\Documents and Settings\BlackCrystal™\Escritorio\MI PROYECTO MPLAB\main.c:234: undefined reference to `USBSleepOnSuspend'

Alguno sabe de que puede ser?

Saludos y gracias, si necesitais que suba el Main decirlo....bueno le subo de todos modos

Código: [Seleccionar]

//**Victor Manuel San Segundo Jimenez**//
//**main - PIC24FJ256GB106**//

/** INCLUDES ***********************************************************************/

#include <p24Fxxxx.h>
#include "./USB/usb.h"
#include "./USB/usb_function_cdc.h"
#include "HardwareProfile.h"

/** CONFIGURACION CALIBRADOR DE CALIBRES*************************************************************/

#if defined(__PIC24FJ256GB106__)
   _CONFIG1( JTAGEN_OFF & GCP_OFF & GWRP_OFF & FWDTEN_OFF & ICS_PGx1)
   _CONFIG2( PLL_96MHZ_ON & IESO_OFF & FCKSM_CSDCMD & OSCIOFNC_ON & POSCMOD_HS & FNOSC_PRIPLL & PLLDIV_DIV2 & IOL1WAY_ON)

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

#else
     #error No hardware board defined, see "HardwareProfile.h" and __FILE__
#endif


/** V A R I A B L E S ********************************************************/
#pragma udata
char USB_In_Buffer[64]; //Buffer de 64 caracteres para enviar por el USB
char USB_Out_Buffer[64];//Buffer de 64 caracteres para recibir desde el USB

BOOL stringPrinted;
volatile BOOL buttonPressed;
volatile BYTE buttonCount;

BYTE CAN1MessageFifoArea[2 * 8 * 16];

/** P R I V A T E  P R O T O T Y P E S ***************************************/

static void InitializeSystem(void);
void ProcessIO(void);
void USBDeviceTasks(void);
void YourHighPriorityISRCode();
void YourLowPriorityISRCode();
void USBCBSendResume(void);
void BlinkUSBStatus(void);
void UserInit(void);

/** DECLARATIONS ***************************************************/

#pragma code

/******************************************************************************
 * Function:        void main(void)
 *****************************************************************************/

int main(void)
{
   //Configura el sistema para un máximo rendimiento y habilita las interrupciones del multivector
   
   InitializeSystem();      /* Inicializamos el USB */
               /* Inicializamos el CAN */

    while(1){
        #if defined(USB_INTERRUPT)
            if(USB_BUS_SENSE && (USBGetDeviceState() == DETACHED_STATE))
            {
                USBDeviceAttach();
            }
        #endif

        #if defined(USB_POLLING)
      // Check bus status and service USB interrupts.
        USBDeviceTasks(); // Interrupt or polling method.  If using polling, must call
                      // this function periodically.  This function will take care
                      // of processing and responding to SETUP transactions
                      // (such as during the enumeration process when you first
                      // plug in).  USB hosts require that USB devices should accept
                      // and process SETUP packets in a timely fashion.  Therefore,
                      // when using polling, this function should be called
                      // regularly (such as once every 1.8ms or faster** [see
                      // inline code comments in usb_device.c for explanation when
                      // "or faster" applies])  In most cases, the USBDeviceTasks()
                      // function does not take very long to execute (ex: <100
                      // instruction cycles) before it returns.
        #endif       

        ProcessIO();       
    }//end while
}//end main

/********************************************************************
 * Function:        static void InitializeSystem(void)
 *******************************************************************/

static void InitializeSystem(void)
{
     #if defined(__C30__)
       
            AD1PCFGL = 0xFFFF;
       
   
    #endif
   
    #if defined(PIC24FJ64GB004_PIM) || defined(PIC24FJ256GB106)
   //On the PIC24FJ64GB004 Family of USB microcontrollers, the PLL will not power up and be enabled
   //by default, even if a PLL enabled oscillator configuration is selected (such as HS+PLL).
   //This allows the device to power up at a lower initial operating frequency, which can be
   //advantageous when powered from a source which is not gauranteed to be adequate for 32MHz
   //operation.  On these devices, user firmware needs to manually set the CLKDIV<PLLEN> bit to
   //power up the PLL.
    {
        unsigned int pll_startup_counter = 600;
        CLKDIVbits.PLLEN = 1;
        while(pll_startup_counter--);
    }

    //Device switches over automatically to PLL output after PLL is locked and ready.
    #endif

//"USE_USB_BUS_SENSE_IO" has been defined in the HardwareProfile.h file.   
    #if defined(USE_USB_BUS_SENSE_IO)
    tris_usb_bus_sense = INPUT_PIN; // See HardwareProfile.h
    #endif
   
//   "USE_SELF_POWER_SENSE_IO" in HardwareProfile.h.
    #if defined(USE_SELF_POWER_SENSE_IO)
    tris_self_power = INPUT_PIN;   // See HardwareProfile.h
    #endif
   
    UserInit();
    USBDeviceInit();   //usb_device.c.  Initializes USB module SFRs and firmware variables to known states.

}//end InitializeSystem

/******************************************************************************
 * Function:        void UserInit(void)
 *****************************************************************************/
void UserInit(void)
{
    //Initialize all of the debouncing variables
    buttonCount = 0;
    buttonPressed = FALSE;
    stringPrinted = TRUE;

    //Inicializar todos los pines de los LEDs
    mInitAllLEDs();

}//end UserInit

/******************************************************************************
 * Function:        void ProcessIO(void)
Aqui hacemos que parpadee el LED 1 (Rojo) cuando conectamos la tarjeta al PC
 ******************************************************************************/
void ProcessIO(void)
{   
    mLED_2_On();
    //Blink the LEDs according to the USB device status
    BlinkUSBStatus();


}   //end ProcessIO

/********************************************************************
 * Function:        void BlinkUSBStatus(void)
 *******************************************************************/
void BlinkUSBStatus(void)
{
    /*static WORD led_count=0;
   
    if(led_count == 0)led_count = 40000U;
         led_count--;

    #define mLED_Both_Off()         {mLED_1_Off();mLED_2_Off();}
    #define mLED_Both_On()          {mLED_1_On();mLED_2_On();}
    #define mLED_Only_1_On()        {mLED_1_On();mLED_2_Off();}
    #define mLED_Only_2_On()        {mLED_1_Off();mLED_2_On();}

    if(USBSuspendControl == 1)
    {
        if(led_count==0)
        {
            mLED_1_Toggle();
            if(mGetLED_1())
            {
                mLED_2_On();
            }
            else
            {
                mLED_2_Off();
            }
        }//end if
    }
    else
    {
        if(USBDeviceState == DETACHED_STATE)
        {
            mLED_Both_Off();
        }
        else if(USBDeviceState == ATTACHED_STATE)
        {
            mLED_Both_On();
        }
        else if(USBDeviceState == POWERED_STATE)
        {
            mLED_Only_1_On();
        }
        else if(USBDeviceState == DEFAULT_STATE)
        {
            mLED_Only_2_On();
        }
        else if(USBDeviceState == ADDRESS_STATE)
        {
             if(led_count == 0)
            {
                mLED_1_Toggle();
                mLED_2_Off();
            }//end if
        }
        else if(USBDeviceState == CONFIGURED_STATE)
        {
            if(led_count==0)
            {
                mLED_1_Toggle();      // Parpadeo LED Rojo (1)
            }//end if
        }//end if(...)
    }//end if(UCONbits.SUSPND...)
    */
}//end BlinkUSBStatus

/******************************************************************************
 * Function:        void USBCBSuspend(void)
 *****************************************************************************/
void USBCBSuspend(void)
{
   #if defined(__C30__)
        USBSleepOnSuspend();
    #endif
}

/******************************************************************************
 * Function:        void USBCBWakeFromSuspend(void)
 *****************************************************************************/
void USBCBWakeFromSuspend(void)
{

}

/********************************************************************
 * Function:        void USBCB_SOF_Handler(void)
 *******************************************************************/
void USBCB_SOF_Handler(void)
{
    // No need to clear UIRbits.SOFIF to 0 here.
    // Callback caller is already doing that.

    //This is reverse logic since the pushbutton is active low
/*    if(buttonPressed == sw1)//AQUI CAMBIO EL PULSADOR QUE QUIERO VER
    {
        if(buttonCount != 0)
        {
            buttonCount--;
        }
        else
        {
            //This is reverse logic since the pushbutton is active low
            buttonPressed = !sw1;//AQUI CAMBIO EL PULSADOR QUE QUIERO VER

            //Wait 100ms before the next press can be generated
            buttonCount = 100;
        }
    }
    else
    {
        if(buttonCount != 0)
        {
            buttonCount--;
        }
    }*/
}

/*******************************************************************
 * Function:        void USBCBErrorHandler(void)
 *******************************************************************/
void USBCBErrorHandler(void)
{
   
}

/*******************************************************************
 * Function:        void USBCBCheckOtherReq(void)
 *******************************************************************/
void USBCBCheckOtherReq(void)
{
    USBCheckCDCRequest();
}//end


/*******************************************************************
 * Function:        void USBCBStdSetDscHandler(void)
 *******************************************************************/
void USBCBStdSetDscHandler(void)
{
    // Must claim session ownership if supporting this request
}//end


/*******************************************************************
 * Function:        void USBCBInitEP(void)
 *******************************************************************/
void USBCBInitEP(void)
{
    CDCInitEP();
}

/********************************************************************
 * Function:        void USBCBSendResume(void)
 *******************************************************************/
void USBCBSendResume(void)
{
    static WORD delay_count;
   
    //First verify that the host has armed us to perform remote wakeup.
    //It does this by sending a SET_FEATURE request to enable remote wakeup,
    //usually just before the host goes to standby mode (note: it will only
    //send this SET_FEATURE request if the configuration descriptor declares
    //the device as remote wakeup capable, AND, if the feature is enabled
    //on the host (ex: on Windows based hosts, in the device manager
    //properties page for the USB device, power management tab, the
    //"Allow this device to bring the computer out of standby." checkbox
    //should be checked).
    if(USBGetRemoteWakeupStatus() == TRUE)
    {
        //Verify that the USB bus is in fact suspended, before we send
        //remote wakeup signalling.
        if(USBIsBusSuspended() == TRUE)
        {
            USBMaskInterrupts();
           
            //Clock switch to settings consistent with normal USB operation.
            USBCBWakeFromSuspend();
            USBSuspendControl = 0;
            USBBusIsSuspended = FALSE;  //So we don't execute this code again,
                                        //until a new suspend condition is detected.

            //Section 7.1.7.7 of the USB 2.0 specifications indicates a USB
            //device must continuously see 5ms+ of idle on the bus, before it sends
            //remote wakeup signalling.  One way to be certain that this parameter
            //gets met, is to add a 2ms+ blocking delay here (2ms plus at
            //least 3ms from bus idle to USBIsBusSuspended() == TRUE, yeilds
            //5ms+ total delay since start of idle).
            delay_count = 3600U;       
            do
            {
                delay_count--;
            }while(delay_count);
           
            //Now drive the resume K-state signalling onto the USB bus.
            USBResumeControl = 1;       // Start RESUME signaling
            delay_count = 1800U;        // Set RESUME line for 1-13 ms
            do
            {
                delay_count--;
            }while(delay_count);
            USBResumeControl = 0;       //Finished driving resume signalling

            USBUnmaskInterrupts();
        }
    }
}


/*******************************************************************
 * Function:        void USBCBEP0DataReceived(void)
*******************************************************************/
#if defined(ENABLE_EP0_DATA_RECEIVED_CALLBACK)
void USBCBEP0DataReceived(void)
{
}
#endif

/*******************************************************************
 * Function:        BOOL USER_USB_CALLBACK_EVENT_HANDLER(
 *                        USB_EVENT event, void *pdata, WORD size)
 *******************************************************************/
BOOL USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, WORD size)
{
    switch(event)
    {
        case EVENT_TRANSFER:
            //Add application specific callback task or callback function here if desired.
            break;
        case EVENT_SOF:
            USBCB_SOF_Handler();
            break;
        case EVENT_SUSPEND:
            USBCBSuspend();
            break;
        case EVENT_RESUME:
            USBCBWakeFromSuspend();
            break;
        case EVENT_CONFIGURED:
            USBCBInitEP();
            break;
        case EVENT_SET_DESCRIPTOR:
            USBCBStdSetDscHandler();
            break;
        case EVENT_EP0_REQUEST:
            USBCBCheckOtherReq();
            break;
        case EVENT_BUS_ERROR:
            USBCBErrorHandler();
            break;
        case EVENT_TRANSFER_TERMINATED:
            //Add application specific callback task or callback function here if desired.
            //The EVENT_TRANSFER_TERMINATED event occurs when the host performs a CLEAR
            //FEATURE (endpoint halt) request on an application endpoint which was
            //previously armed (UOWN was = 1).  Here would be a good place to:
            //1.  Determine which endpoint the transaction that just got terminated was
            //      on, by checking the handle value in the *pdata.
            //2.  Re-arm the endpoint if desired (typically would be the case for OUT
            //      endpoints).
            break;
        default:
            break;
    }     
    return TRUE;
}


/** EOF main.c *************************************************/

[alperez]

Esa función está definida en "usb_hal_pic24.c" forma parte del stack USB