main.c

ATmega8实现USB接口（采用USB的CDC类

                 * tty devices can only be opened when carrier detect is set.
                 */
                intr3Status = 2;
            }
#   endif
#endif
        }
    }
#if ENABLE_DEBUG_INTERFACE
    else if(rqType == USBRQ_TYPE_VENDOR){   /* vendor requests */
        if(rq->bRequest == 1){  /* transmit data */
            serialPutc(rq->wValue.bytes[0]);
        }else if(rq->bRequest == 2){
            requestType = REQUEST_TYPE_VENDOR;
            return 0xff;    /* handle in usbFunctionRead() */
        }
    }
#endif
    return 0;
}

uchar usbFunctionRead(uchar *data, uchar len)
{
    if(requestType == REQUEST_TYPE_LINE_CODING){
#if ENABLE_CDC_INTERFACE
        /* return the "virtual" configuration */
        memcpy(data, modeBuffer, 7);
        return 7;
#endif
    }
#if ENABLE_DEBUG_INTERFACE
    else if(requestType == REQUEST_TYPE_VENDOR){
        uchar cnt;
        for(cnt = 0; cnt < len && ringBufferHasData(&serialRingBuffer); cnt++){
            *data++ = ringBufferRead(&serialRingBuffer);
        }
        return cnt;
#if ENABLE_HID_INTERFACE
    }else if(requestType == REQUEST_TYPE_HID_DEBUGDATA){
        uchar *p = data, remaining;
        if(hidStatus == 5){ /* first call */
            *p++ = hidStatus;   /* report ID */
            *p++ = ringBufferCount(&serialRingBuffer);
            remaining = len - 2;
            hidStatus = 1;  /* continue with subsequent call */
        }else{
            remaining = len;
        }
        if(hidStatus){
            do{
                if(!ringBufferHasData(&serialRingBuffer)){
                    hidStatus = 0;
                    break;
                }
                *p++ = ringBufferRead(&serialRingBuffer);
            }while(--remaining);
        }
        return len;
#endif
    }
#endif
#if ENABLE_HID_INTERFACE
    else if(requestType == REQUEST_TYPE_HID_FIRST || requestType == REQUEST_TYPE_HID_SUBSEQUENT){
        uchar *p = data, remaining;
        if(requestType == REQUEST_TYPE_HID_FIRST){
            int cnt;
            *p++ = hidStatus;   /* report ID */
            cnt = stkGetTxCount();
            if(utilHi8(cnt)){
                *p = 255;
            }else{
                *p = cnt;     /* second byte is number of remaining bytes buffered */
            }
            p++;
            remaining = len - 2;
            requestType = REQUEST_TYPE_HID_SUBSEQUENT;
        }else{
            remaining = len;
        }
        if(hidStatus){
            do{
                int c = stkGetTxByte();
                if(c < 0){
                    hidStatus = 0;
                    break;
                }
                *p++ = c;
            }while(--remaining);
        }
        return len;
    }
#endif
    return 0;   /* error -> terminate transfer */
}

uchar usbFunctionWrite(uchar *data, uchar len)
{
    if(requestType == REQUEST_TYPE_LINE_CODING){
#if ENABLE_CDC_INTERFACE
        /* Don't know why data toggling is reset when line coding is changed, but it is... */
        usbTxPacketCnt1 = 1;    /* enforce DATA0 token for next transfer */
        /* store the line configuration so that we can return it on request */
        memcpy(modeBuffer, data, 7);
        return 1;
#endif
    }
#if ENABLE_HID_INTERFACE
#if ENABLE_DEBUG_INTERFACE
    else if(requestType == REQUEST_TYPE_HID_DEBUGDATA){
        uchar *p = data, rval = len != 8;
        if(hidStatus == 5){ /* first call */
            hidStatus = -p[1]; /* second byte is data length */
            p += 2;
            len -= 2;
        }
        do{
            if(!hidStatus)
                break;
            serialPutc(*p++);
            hidStatus++;
        }while(--len);
        return rval;    /* the last packet must have 7 bytes insted of 8 */
    }
#endif
    else if(requestType == REQUEST_TYPE_HID_FIRST || requestType == REQUEST_TYPE_HID_SUBSEQUENT){
        uchar *p = data, rval = len != 8;
        if(requestType == REQUEST_TYPE_HID_FIRST){
            hidStatus = p[1]; /* second byte is data length */
            p += 2;
            len -= 2;
            requestType = REQUEST_TYPE_HID_SUBSEQUENT;
        }
        do{
            if(!hidStatus)
                break;
            stkSetRxChar(*p++);
            hidStatus--;
        }while(--len);
        return rval;    /* the last packet must have 7 bytes insted of 8 */
    }
#endif
    return 1;   /* error -> accept everything until end */
}

void usbFunctionWriteOut(uchar *data, uchar len)
{
#if ENABLE_CDC_INTERFACE
    do{ /* len must be at least 1 character, the driver discards zero sized packets */
        stkSetRxChar(*data++);
    }while(--len);
#endif
}

/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */

static void readInterfaceType(void)
{
#if ENABLE_HID_INTERFACE && ENABLE_CDC_INTERFACE
    PORT_DDR_SET(HWPIN_ISP_MOSI);
    PORT_PIN_SET(HWPIN_ISP_MOSI);
//    _delay_us(10);
    PORT_DDR_CLR(HWPIN_ISP_MOSI);
    PORT_PIN_CLR(HWPIN_ISP_MOSI);   /* deactivate pullup */
    useHIDInterface = PORT_PIN_VALUE(HWPIN_ISP_MOSI) == 0;
#elif ENABLE_HID_INTERFACE
    useHIDInterface = 1;
#elif !ENABLE_CDC_INTERFACE
#error "You must set either ENABLE_HID_INTERFACE or ENABLE_CDC_INTERFACE in hardware.h!"
#endif
}

/*
20 pin HVSP / PP connector:
    1 .... GND
    2 .... Vtarget
    3 .... HVSP SCI
    4 .... RESET
    16 ... HVSP SDO
    18 ... HVSP SII
    20 ... HVSP SDI

 * Timer usage:
 * Timer 0 [8 bit]:
 *   1/64 prescaler for timer interrupt
 * Timer 1 [16 bit]:
 *   PWM for voltage supply -> fastPWM mode
 *   f = 23.4 kHz -> prescaler = 1, 9 bit
 * Timer 2 [8 bit]:
 *   Clock generation for target device
 */

static void hardwareInit(void)
{
uchar   i, j;
uchar   portB = 0, portC = 0, portD = 0, ddrB = 0, ddrC = 0, ddrD = 0;

    UTIL_PBIT_SET(port, HWPIN_HVSP_SUPPLY);
    UTIL_PBIT_SET(ddr, HWPIN_HVSP_SUPPLY);
    UTIL_PBIT_CLR(port, HWPIN_SMPS_OUT);
    UTIL_PBIT_SET(ddr, HWPIN_SMPS_OUT);
    UTIL_PBIT_CLR(port, HWPIN_HVSP_HVRESET);
    UTIL_PBIT_SET(ddr, HWPIN_HVSP_HVRESET);
    UTIL_PBIT_CLR(port, HWPIN_HVSP_SCI);
    UTIL_PBIT_SET(ddr, HWPIN_HVSP_SCI);
    UTIL_PBIT_CLR(port, HWPIN_ISP_CLK);
    UTIL_PBIT_SET(ddr, HWPIN_ISP_CLK);
    UTIL_PBIT_CLR(port, HWPIN_ISP_DRIVER);
    UTIL_PBIT_SET(ddr, HWPIN_ISP_DRIVER);
    UTIL_PBIT_CLR(port, HWPIN_LED);
    UTIL_PBIT_SET(ddr, HWPIN_LED);

    UTIL_PBIT_CLR(port, HWPIN_ADC_SMPS);
    UTIL_PBIT_CLR(ddr, HWPIN_ADC_SMPS);
    UTIL_PBIT_CLR(port, HWPIN_ADC_VTARGET);
    UTIL_PBIT_CLR(ddr, HWPIN_ADC_VTARGET);
    UTIL_PBIT_CLR(port, HWPIN_ISP_SCK);
    UTIL_PBIT_SET(ddr, HWPIN_ISP_SCK);
    UTIL_PBIT_SET(port, HWPIN_ISP_MISO);
    UTIL_PBIT_CLR(ddr, HWPIN_ISP_MISO);
    UTIL_PBIT_CLR(port, HWPIN_ISP_MOSI);
    UTIL_PBIT_SET(ddr, HWPIN_ISP_MOSI);
    UTIL_PBIT_CLR(port, HWPIN_ISP_RESET);
    UTIL_PBIT_SET(ddr, HWPIN_ISP_RESET);

    UTIL_PBIT_SET(port, HWPIN_ISP_TXD);
    UTIL_PBIT_SET(ddr, HWPIN_ISP_TXD);
    UTIL_PBIT_SET(port, HWPIN_ISP_RXD);
    UTIL_PBIT_CLR(ddr, HWPIN_ISP_RXD);
    UTIL_PBIT_CLR(port, HWPIN_USB_DPLUS);
    UTIL_PBIT_SET(ddr, HWPIN_USB_DPLUS);
    UTIL_PBIT_CLR(port, HWPIN_USB_DMINUS);
    UTIL_PBIT_SET(ddr, HWPIN_USB_DMINUS);
    UTIL_PBIT_SET(port, HWPIN_JUMPER);
    UTIL_PBIT_CLR(ddr, HWPIN_JUMPER);
    UTIL_PBIT_CLR(port, HWPIN_HVSP_SII);
    UTIL_PBIT_SET(ddr, HWPIN_HVSP_SII);
    UTIL_PBIT_CLR(port, HWPIN_HVSP_SDI);
    UTIL_PBIT_SET(ddr, HWPIN_HVSP_SDI);
    UTIL_PBIT_CLR(port, HWPIN_HVSP_SDO);
    UTIL_PBIT_CLR(ddr, HWPIN_HVSP_SDO);

    PORTB = portB;
    DDRB = ddrB;
    PORTC = portC;
    DDRC = ddrC;
    PORTD = portD;
    DDRD = ddrD;
    j = 0;
    while(--j){          /* USB Reset by device only required on Watchdog Reset */
        i = 0;
        while(--i);      /* delay >10ms for USB reset */
    }
    UTIL_PBIT_CLR(ddr, HWPIN_USB_DPLUS);
    UTIL_PBIT_CLR(ddr, HWPIN_USB_DMINUS);
    DDRD = ddrD;

    /* timer 0 configuration: ~ 1.365 ms interrupt */
    TCCR0 = 3;              /* 1/64 prescaler */
    TIMSK = (1 << TOIE0);   /* enable timer0 overflow interrupt */
    
    /* timer 1 configuration: ~23.4 kHz PWM (9 bit) */
    TCCR1A = UTIL_BIN8(1000, 0010);  /* OC1A = PWM, OC1B disconnected, 9 bit */
    TCCR1B = UTIL_BIN8(0000, 1001);  /* 9 bit, prescaler=1 */
    OCR1A = 1;      /* set duty cycle to minimum */
    
    /* timer 2 configuration */
    TCCR2 = UTIL_BIN8(0000, 1001);  /* OC2 disconnected, prescaler=1 */
    OCR2 = 2;       /* should give 3 MHz clock */
}

int main(void)
{
    wdt_enable(WDTO_1S);
    odDebugInit();
#if ENABLE_DEBUG_INTERFACE
    serialInit();
#endif
    readInterfaceType();
    hardwareInit();
    vregInit();
    usbInit();
    sei();
    for(;;){    /* main event loop */
        wdt_reset();
        usbPoll();
#if ENABLE_CDC_INTERFACE
        if(!useHIDInterface && usbInterruptIsReady()){
            static uchar sendEmptyFrame = 1, buffer[8];
            /* start with empty frame because the host eats the first packet -- don't know why... */
            int c;
            uchar i = 0;
            while(i < 8 && (c = stkGetTxByte()) >= 0){
                buffer[i++] = c;
            }
            if(i > 0 || sendEmptyFrame){
                sendEmptyFrame = i;     /* send an empty block after last data block to indicate transfer end */
                usbSetInterrupt(buffer, i);
            }
        }
#endif
#if USE_DCD_REPORTING && ENABLE_CDC_INTERFACE
        /* We need to report rx and tx carrier after open attempt */
        if(usbInterruptIsReady3() && intr3Status != 0){
            static uchar serialStateNotification[8] = {0xa1, 0x20, 0, 0, 0, 0, 2, 0};
            static uchar serialStateData[2] = {3, 0};
            if(intr3Status == 2){
                usbSetInterrupt3(serialStateNotification, 8);
            }else{
                usbSetInterrupt3(serialStateData, 2);
            }
            intr3Status--;
        }
#endif
    }
    return 0;
}