PIC Mikrocontroller Forum

void USBCheckBusStatus(void)
{
    UCON = 0b00001000;              // Enable USBEN only
    /*
     * After enabling the USB module, it takes some time for the voltage
     * on the D+ or D- line to rise high enough to get out of the SE0 condition.
     * The USB Reset interrupt should not be unmasked until the SE0 condition is
     * cleared. This helps preventing the firmware from misinterpreting this
     * unique event as a USB bus reset from the USB host.
     */
    while(UCONbits.SE0);            // Blocking loop
    UIR = 0;                        // Clear all USB interrupts
    UIE = 0b00010001;               // Unmask RESET & IDLE interrupts only
    usb_device_state = POWERED_STATE;
}//end USBCheckBusStatus

/** I N C L U D E S **********************************************************/
#include <p18cxxx.h>
#include <p18f4455.h>
#include "system\typedefs.h"                        // Required
#include "system\usb\usb.h"                         // Required
#include "io_cfg.h"                                 // Required

#include "system\usb\usb_compile_time_validation.h" // Optional

/** C O N F I G U R A T I O N ************************************************/

#if   defined(__18F4550)||defined(__18F4455)|| \
      defined(__18F2550)||defined(__18F2455)|| \
      defined(__18F4553)||defined(__18F4458)|| \
      defined(__18F2553)||defined(__18F2458)

// Note: Some of the below configuration bits are commented out
// to prevent build errors with some of the above listed devices.
// For example, on the PIC18F4458 CP3, WRT3, and EBTR3 don't exist.

#pragma config PLLDIV   = 2       //8MHz (5:20 MHz input)
#pragma config CPUDIV   = OSC1_PLL2
#pragma config USBDIV   = 2       // Clock source from 96MHz PLL/2 
#pragma config FOSC     = HSPLL_HS
//#pragma config FCMEN    = OFF
#pragma config IESO     = OFF
#pragma config PWRT     = ON
#pragma config BOR      = OFF
//#pragma config BORV     = 3
#pragma config VREGEN   = ON
#pragma config WDT      = OFF
#pragma config WDTPS    = 32768
#pragma config MCLRE    = ON
#pragma config LPT1OSC  = OFF
#pragma config PBADEN   = OFF
#pragma config CCP2MX   = OFF
#pragma config STVREN   = ON
#pragma config LVP      = OFF
//#pragma config ICPRT    = OFF       // Dedicated In-Circuit Debug/Programming
#pragma config XINST    = OFF       // Extended Instruction Set
#pragma config CP0      = OFF
#pragma config CP1      = OFF
#pragma config CP2      = OFF
//#pragma config CP3      = OFF
#pragma config CPB      = OFF
#pragma config CPD      = OFF
#pragma config WRT0     = OFF
#pragma config WRT1     = OFF
#pragma config WRT2     = OFF
//#pragma config WRT3     = OFF
#pragma config WRTB     = OFF       // Boot Block Write Protection
#pragma config WRTC     = OFF
#pragma config WRTD     = OFF
#pragma config EBTR0    = OFF
#pragma config EBTR1    = OFF
#pragma config EBTR2    = OFF
//#pragma config EBTR3    = OFF
#pragma config EBTRB    = OFF

#endif

/** V A R I A B L E S ********************************************************/
#pragma udata

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

/** V E C T O R  R E M A P P I N G *******************************************/

#pragma code _HIGH_INTERRUPT_VECTOR = 0x000008
void _high_ISR (void)
{
    _asm goto RM_HIGH_INTERRUPT_VECTOR _endasm
}

#pragma code _LOW_INTERRUPT_VECTOR = 0x000018
void _low_ISR (void)
{
    _asm goto RM_LOW_INTERRUPT_VECTOR _endasm
}

void mein_main(void);

#pragma code

/** D E C L A R A T I O N S **************************************************/
#pragma code
/******************************************************************************
 * Function:        void main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Main program entry point.
 *
 * Note:            None
 *****************************************************************************/
void main(void)
{
    byte temp;
    temp = ADCON1;
    ADCON1 |= 0x0F;
   
    //TRISBbits.TRISB4 = 1;     // Reset value is already '1'
   
    //Check Bootload Mode Entry Condition
//    if(PORTBbits.RB4 == 1)      // If not pressed, User Mode

//    if (PORTEbits.RE3 == 1)  // kein jumper
    {
//        _asm goto RM_RESET_VECTOR _endasm //
    }//end if
   
    //Bootload Mode
    mInitAllLEDs();
    mInitializeUSBDriver();     // See usbdrv.h
    USBCheckBusStatus();        // Modified to always enable USB module
    while(1)
    {
       USBDriverService();     // See usbdrv.c
       BootService();          // See boot.c
    }//end while
}//end main

#pragma code user = RM_RESET_VECTOR

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

void mein_main(void)
{
    while(1)
    {
PORTAbits.RA4 = 1;
PORTAbits.RA4 = 0;
    }//end while
}
/** EOF main.c ***************************************************************/

void main(void)
{
[...]
    //Check Bootload Mode Entry Condition
    if(PORTAbits.RA1 == 1 && boot != 0xA9 && boot != 0xff)      // If not pressed, value set by setup or
    { // if program space is emtpy (eeprom is 0xff)
        _asm goto RM_RESET_VECTOR _endasm
    }//end if

[..]

    //Bootload Mode
    mInitAllLEDs();
mLED_1_Off();
mLED_2_On();
    led_count = 0; //Initialize blink rate counter
    mInitializeUSBDriver();     // See usbdrv.h
    USBCheckBusStatus();        // Modified to always enable USB module
    while(1)
    {
        USBDriverService();     // See usbdrv.c
        BootService();          // See boot.c
    }//end while
}//end main

#pragma config PLLDIV   = 2       //8MHz (5:20 MHz input)
#pragma config CPUDIV   = OSC1_PLL2
#pragma config USBDIV   = 2       // Clock source from 96MHz PLL/2  
#pragma config FOSC     = HSPLL_HS
//#pragma config FCMEN    = OFF
#pragma config IESO     = OFF
#pragma config PWRT     = ON
#pragma config BOR      = OFF
//#pragma config BORV     = 3
#pragma config VREGEN   = ON
#pragma config WDT      = OFF
#pragma config WDTPS    = 32768
#pragma config MCLRE    = ON
#pragma config LPT1OSC  = OFF
#pragma config PBADEN   = OFF
#pragma config CCP2MX   = OFF
#pragma config STVREN   = ON
#pragma config LVP      = OFF
//#pragma config ICPRT    = OFF       // Dedicated In-Circuit Debug/Programming
#pragma config XINST    = OFF       // Extended Instruction Set
#pragma config CP0      = OFF
#pragma config CP1      = OFF
#pragma config CP2      = OFF
//#pragma config CP3      = OFF
#pragma config CPB      = OFF
#pragma config CPD      = OFF
#pragma config WRT0     = OFF
#pragma config WRT1     = OFF
#pragma config WRT2     = OFF
//#pragma config WRT3     = OFF
#pragma config WRTB     = OFF       // Boot Block Write Protection
#pragma config WRTC     = OFF
#pragma config WRTD     = OFF
#pragma config EBTR0    = OFF
#pragma config EBTR1    = OFF
#pragma config EBTR2    = OFF
//#pragma config EBTR3    = OFF
#pragma config EBTRB    = OFF

...
//----------------------------------------------------------------------------
// High priority interrupt vector

#pragma code InterruptVectorHigh = 0x08
void
InterruptVectorHigh (void)
{
  _asm
    goto InterruptHandlerHigh //jump to interrupt routine
  _endasm
}

//----------------------------------------------------------------------------
// Low priority interrupt vector

#pragma code InterruptVectorLowh = 0x18
void
InterruptVectorLow (void)
{
  _asm
    goto InterruptHandlerLow //jump to interrupt routine
  _endasm
}

//---------------------------------------------------------------------------------
#pragma code boot_sector = 0x0020
void main(void)
{
// OSCCON = 0b01100010;
regsetup();
DEVICE_init();
USB_init();
USB_reset();
PIR2bits.USBIF = 0; //reset any USB interrupts pending
  IPR2bits.USBIP = 1; //USB is a high priority interrupt source
RCONbits.IPEN = 1; //enable interrupt priority levels
INTCONbits.PEIE = 1; //enable peripheral interrupt sources
PIE2bits.USBIE = 1; //enable USB interrupt
UIR = 0;
INTCONbits.GIE = 1; //global interrupt enable bit

USBTMCindicator_pulse();//fliegt noch raus

Hauptschleife:

while (1)
{
PORTAbits.RA4 = !PORTAbits.RA4;
}

}
//-----------------------------Register einstellen---------------------------------
void regsetup(void)
{
InitAdcons(); //Macro in iocfg.h
InitPORTA(); //Macro in iocfg.h
InitPORTB(); //Macro in iocfg.h
InitPORTC(); //Macro in iocfg.h
InitPORTD(); //Macro in iocfg.h
InitPORTE(); //Macro in iocfg.h
EECON1 = 0;
EECON2 = 0;
TABLAT = 0;
TBLPTRL = 0;
TBLPTRH = 0;
TBLPTRU = 0;
IPR1 = 0; //nur USB hohe Int.Priority
IPR2 = 0x20; //nur USB hohe Int.Priority
T0CON = 0;
T1CON = 0;
T2CON = 0;
T3CON = 0;
TMR0L = 0;
TMR0H = 0;
TMR1L = 0;
TMR1H = 0;
TMR2 = 0;
TMR3L = 0;
TMR3H= 0;

PIR1 = 0; //Alle Flags aus
PIR2 = 0; //Alle Flags aus
// PIR3 = 0; //Alle Flags aus
RCON = 0b00000000; //IP verbieten
INTCON = 0b00000000; //nix erlauben
INTCON2 = 0b10000000; //
INTCON3 = 0b00000000; //nix erlauben
PIE1 = 0b00000000; //CCPIE an
PIE2 = 0; //
hilf = 0;
// PIE3 = 0; //
}
//----------------------------------------------------------------------------
// High priority interrupt routine

#pragma code
#pragma interrupt InterruptHandlerHigh

void InterruptHandlerHigh (void)
{
//HighInt
//; save working registers
retteArbeitsregisterHighInt() //Macro in inthandvo1.h

LATCbits.LATC0 = 1;
if (hilf==4)
{
Nop();
Nop();
}
TestCounter[hilf] = UIR;
hilf++;

HighIntuerrif_test:
if (UIRbits.UERRIF)
goto HighIntUerrif;
HighIntStallif_test:
if (UIRbits.STALLIF)
goto HighIntStall;
HighIntUrstif_test:
if (UIRbits.URSTIF)
goto HighIntUSBreset;
HighIntTrnif_test:
if (UIRbits.TRNIF)
goto HighIntTrnif;
HighIntActvif_test:
if (UIRbits.ACTVIF)
goto HighIntActvif;

HighInt2:

//; insert here: any other high priority interrupt queries

HighIntEnd:
PIR2bits.USBIF = 0;
goto fast_end;
//; this is an USB reset interrupt
HighIntUSBreset:
USB_reset();
HighIntSE0Test:
while (UCONbits.SE0);
UIRbits.URSTIF = 0;
goto fast_end;
//; this is an USB transaction complete interrupt
HighIntTrnif:
USBtranscompleteInterrupt();
UIRbits.TRNIF = 0;
goto fast_end;
//; this is an USB stall interrupt
HighIntStall:
UIRbits.STALLIF = 0;
USBStallInterrupt();
goto fast_end;
//; this is an USB resume interrupt
HighIntActvif:
USBresumeInterrupt();
goto fast_end;
//; this is an USB error interrupt
HighIntUerrif:
USBerrorInterrupt();
goto fast_end;

//; insert here: all other fast interrupt service routine calls

//; this is all fast ISR's end

fast_end:
//; restore working registers
UIR = 0;
PIR2bits.USBIF = 0;
LATCbits.LATC0 = 0;
holeArbeitsregisterHighInt() //Macro in inthandvo1.h
_asm
RETFIE 1
_endasm //;never use 'retfie fast' because of early silicon errors

}


//; Low priority interrupt routine
#pragma interrupt InterruptHandlerLow

void
InterruptHandlerLow()
{
retteArbeitsregisterLowInt() //Macro in inthandvo1.h
/*** low priority interrupt code goes here ***/
//; execute operation pending function

holeArbeitsregisterLowInt()
// retfie
}


void DEVICE_init(void)
{
REN = 0;
RLstate = 0; //LOCS
STB = 0; //
ESR.byte = 0; //
ESE = 0; //
BULKOUT_PROGRESS = 0; //no transfer is in progress
BULKOUT_CONTENT = 0; //bulk-OUT is empty
BULKOUT_RXD[0] = 0; //no data transmitted
BULKOUT_RXD[1] = 0; //
BULKOUT_RXD[2] = 0; //
BULKOUT_RXD[3] = 0; //
BULKIN_PROGRESS = 0; //no transfer is in progress
BULKIN_CONTENT = 0; //bulk-IN is empty
BULKIN_TXD[0] = 0; //no data transmitted
BULKIN_TXD[1] = 0; //
BULKIN_TXD[2] = 0; //
BULKIN_TXD[3] = 0; //
OperCond[0] = 0; //status reporting acc. SCPI Syntax & Style chapter 9
OperCond[1] = 0; //
OperEven[0] = 0; //
OperEven[1] = 0; //
OperEnab[0] = 0; //
OperEnab[1] = 0; //
QuesCond[0] = 0; //
QuesCond[1] = 0; //
QuesEven[0] = 0; //
QuesEven[1] = 0; //
QuesEnab[0] = 0; //
QuesEnab[1] = 0; //
ErrorCount = 0; //no errors in the Error/Event Queue
ESR.PON = 1; //ESR
noopFLAG = 0xFF;
// OPCstate.OCIS = 1;
OPCstate.byte = 0xFF;
// OQIS = 0xFF;
OPCqstate.byte = 0xFF;
return;
}

void USB_init(void)
{
UCON = 0; //;clear USB Control Register
UADDR = 0; //USB address 0 (done automatically if USB reset occurs)
SetAddress = 0;
USBAddress = 0;
bConfigurationValue = 0; //device is not configured
//; CPU gets ownership of the whole USB RAM and clears the buffer descriptors
// FSR0L = 0;
// FSR0H = 0x04;
DescriptorPointer = 0;
EPx.EParray[0] = 0x00;
do
{
DescriptorPointer++;
EPx.EParray[DescriptorPointer] = 0x00;
}while (DescriptorPointer<0xFF);

UCFG = 0b00010100;

UEP0 = 0;
UEP1 = 0;
UEP2 = 0;
UEP3 = 0;
UEP4 = 0;
UEP5 = 0;
UEP6 = 0;
UEP7 = 0;
UEP8 = 0;
UEP9 = 0;
UEP10 = 0;
UEP11 = 0;
UEP12 = 0;
UEP13 = 0;
UEP14 = 0;
UEP15 = 0;

//; Initialization of the USB interrupt funnel (reference: DS39632C Section 17.5)
clearACTVIF();
UIR = 0;
UIE = 0;
UEIR = 0;
UEIE = 0;
UIRbits.URSTIF = 0; //clear interrupt status flag
UIEbits.URSTIE = 1; //enable reset interrupt
UIEbits.STALLIE = 1; //enable stall interrupt
UIEbits.TRNIE = 1; //enable transaction complete interrupt

//; enable USB interface
UCONbits.USBEN = 1;

while (UCONbits.SE0);

return;
}
/
void clearACTVIF(void)
{
UCONbits.SUSPND = 0;
while (UIRbits.ACTVIF)
{
UIRbits.ACTVIF = 0;
}
return;
}

void USB_unconfig(void)
{
  bConfigurationValue = 0; //this will be read back with "GET_CON-
//; FIGURATION
USBindicatorUNCONFIG();
return;
}

void USBindicatorUNCONFIG(void)

{
return;
}

void USB_reset(void)
{
UADDR = 0; //USB address 0 (done automatically if USB reset occurs)
bConfigurationValue = 0; //device is not configured
UIR = 0; //clear all pending USB interrupts
UEIR = 0; //clear all USB error interrupts
//;disable all endpoints
UEP0 = 0;
UEP1 = 0;
UEP2 = 0;
UEP3 = 0;
UEP4 = 0;
UEP5 = 0;
UEP6 = 0;
UEP7 = 0;
UEP8 = 0;
UEP9 = 0;
UEP10 = 0;
UEP11 = 0;
UEP12 = 0;
UEP13 = 0;
UEP14 = 0;
UEP15 = 0;
//;unconfigure device
USB_unconfig();
//;configure endpoint 0
config_EP0();
UCONbits.PKTDIS = 0; //clear packet transfer disable
//;flush any pending transactions
while (UIRbits.TRNIF);
return;
}

void config_EP0(void)
{
//; Control OUT Buffer Descriptor
//; can receive 64 bytes
//; buffer starts at adress 0x0480
union
{
struct
{
unsigned char low8;
unsigned char high8;
};
unsigned int gesamt;
}adr;

//Die Adresse des Output-Buffers in den Endpunkt0 schreiben
adr.gesamt = (unsigned short long) USB_CONTROL_OUT;
EPx.BD0ADRL = adr.low8;
EPx.BD0ADRH = adr.high8;

//Die Adresse des Input-Buffers in den Endpunkt1 schreiben
adr.gesamt = (unsigned short long) USB_CONTROL_IN;
EPx.BD1ADRL = adr.low8;
EPx.BD1ADRH = adr.high8;

EPx.BD0CNT = 64; //Buffer-Breite 64Bit
EPx.BD0STAT = 0b10000000; //turn ownership to SIE

//; configure UEP0 Register
UEP0 = 0;

return;
}

void USBTMCindicator_pulse(void)
{

// timerIndicator = 100; //count down in 0.5s
// IndicateINDICATORon();
return;
}


void BulkTransferIndicator(void)
{

if (timerBulk==0)
return;
timerBulk = 30;
return;
}

void USBresumeInterrupt(void)
{
clearACTVIF();
//; set oscillator to primary clock source
OSCCONbits.SCS1 = 0;
OSCCONbits.SCS0 = 0;
OSCCONbits.IDLEN = 0;
UIEbits.ACTVIE = 0; //;disable bus activity interrupt
UIRbits.IDLEIF = 0;
return;
}

void USBtranscompleteInterrupt(void)
{
//; read USB status register to localize the endpoint
TINKER = 0x78 & USTAT;
switch (TINKER)
{
case 0x00:
// goto transcmpl_0; //transaction complete in physical endpoint 0
break;

case 0x08:
// goto transcmpl_1; //transaction complete in physical endpoint 1
break;

case 0x10:
// goto transcmpl_2; //transaction complete in physical endpoint 2
break;

case 0x18:
// goto transtest_over; //transaction complete in physical endpoint 3
break;
}



transtest_over:
return;
}

void USBStallInterrupt(void)
{
    if (UEP0bits.EPSTALL==0)
return;

StallTrap:
//; return ownership of control OUT endpoint to SIE
EPx.BD0STAT = 0x08; //10000000
//; return ownership of control IN endpoint to CPU
EPx.BD1STAT = 0;
//; reset EPSTALL-bit
UEP0bits.EPSTALL = 0;
return;
}

void USBerrorInterrupt()
{
UEIR = 0;
return;
}


void transtest_over_ctl_out(void)
{
UCONbits.PKTDIS = 0; //clear packet transfer disable
//; Control OUT Buffer Descriptor
//; can receive 64 bytes
//; buffer starts at adress 0x0500
EPx.BD0CNT = 64;
EPx.BD0STAT = 0x80; //turn ownership to SIE
return;
}