#include <pic.h>

#include <stdio.h>

#include <string.h>

#include "usbfull.h"

/*описание стандартных дескрипторов USB*/

const USB_DEVICE_DESCRIPTOR DeviceDescriptor = {

sizeof(USB_DEVICE_DESCRIPTOR), /* Длинна дескриптора */

TYPE_DEVICE_DESCRIPTOR, /* Тип дескриптора */

0x0110, /* Версия USB Version 1.1 */

0, /* bDeviceClass */

0, /* bDeviceSubclass */

0, /* bDeviceProtocol */

64, /* размер пакета bMaxPacketSize 64Bytes */

0x0000, /* Производитель idVendor */

0x0000, /* Продукт idProduct (USB Thermometer Example) */

0x0001, /* Версия устройства bcdDevice */

1, /* iManufacturer String Index */

0, /* iProduct String Index */

0, /* iSerialNumber String Index */

1 /* число конфигураций bNumberConfigurations */

},

const USB_CONFIG_DATA ConfigurationDescriptor = {

{ /* configuration descriptor */

sizeof(USB_CONFIGURATION_DESCRIPTOR), /* bLength */

TYPE_CONFIGURATION_DESCRIPTOR, /* bDescriptorType */

sizeof(USB_CONFIG_DATA), /* wTotalLength */

1, /* bNumInterfaces */

1, /* bConfigurationValue */

0, /* iConfiguration String Index */

0x40, /* питание автономное*/

0x85 /* bMaxPower, 133 mA */

},

{ /* interface descriptor */

sizeof(USB_INTERFACE_DESCRIPTOR), /* bLength */

TYPE_INTERFACE_DESCRIPTOR, /* bDescriptorType */

0, /* Номер интерфейса */

0, /* bAlternateSetting */

0x2, /* Количество точек */

0xFF, /* Класс интерфейса(Производителя) */

0xFF, /* Класс интерфейса (Производителя) */

0xFF, /* Протокол интерфейса (Производителя) */

0 /* iInterface String Index */

},

{ /* Дескриптор точки*/

sizeof(USB_ENDPOINT_DESCRIPTOR), /* bLength */

TYPE_ENDPOINT_DESCRIPTOR, /* bDescriptorType */

0x82, /* точка 2 ввода */

0х1, /* точка 1 вывода */

0x11, /* bmAttributes - прерывание */

0x0064, /* wMaxPacketSize */

0x10 /* для передач данных - bInterval */

},

{ /* endpoint descriptor */

sizeof(USB_ENDPOINT_DESCRIPTOR), /* bLength */

TYPE_ENDPOINT_DESCRIPTOR, /* bDescriptorType */

0x81, /* bEndpoint Address EP1 IN */

0x03, /* bmAttributes - Interrupt */

0x0008, /* wMaxPacketSize */

0x10 /* bInterval */

}

};

const MANUFACTURER_DESCRIPTOR Manufacturer_Descriptor = { производитель */

sizeof(MANUFACTURER_DESCRIPTOR), /* bLenght */

TYPE_STRING_DESCRIPTOR, /* bDescriptorType */

"m\0a\0r\0i\0n\0a\0" /* Название в UNICODE */

};

#define MAX_BUFFER_SIZE 80

bank1 unsigned char circularbuffer[MAX_BUFFER_SIZE];

unsigned char inpointer;

unsigned char outpointer;

unsigned char *pSendBuffer;

unsigned char BytesToSend;

unsigned char CtlTransferInProgress;

unsigned char DeviceAddress;

unsigned char DeviceConfigured;

#define PROGRESS_IDLE 0

#define PROGRESS_ADDRESS 3

void main (void)

{

TRISB = 0x03; /* Int & Suspend Inputs */

RB3 = 1; /* Device Not Configured (LED) */

RB2 = 0; /* Reset PDIUSBD12 */

I2C_Init();

RB2 = 1; /* Bring PDIUSBD12 out of reset */

USB_Data();

while(1) {

if (!P3.2) Int_USB(); /* если было прерывание */

else Proc_OU(); /* если не было прерывание */

}

}

void USB_Data(void)

{

unsigned char Buffer[2];

/* Установка адреса по умолчания и активация функции */

Buffer[0] = 0x80;

D11CmdDataWrite(D11_SET_ADDRESS_ENABLE, Buffer, 1);

/* Активировать конечную точку */

Buffer[0] = 0x01;

D11CmdDataWrite(D11_SET_ENDPOINT_ENABLE, Buffer, 1);

/* Установка режима - Enable SoftConnect */

Buffer[0] = 0x1E; /* ISO-i/o,SoftConnect ,no interrupt,clock,no lazy clock*/

D11CmdDataWrite(D11_SET_MODE, Buffer, 1);

}

void Int_USB(void)

{ unsigned short Irq;

unsigned char Buffer[1];

/* Считываем регистр прерываний */

D11CmdDataRead(D11_READ_INTERRUPT_REGISTER, (unsigned char *)&Irq, 2);

/*сброс по шине*/

if (Irq & D11_INT_BUS_RESET) {/**/

USB_Init();

}

/*конечная точка 0 out*/

if (Irq & D11_INT_EP0_OUT) {

Process_EP0_OUT_Interrupt();

}

/*конечная точка 0 in*/

if (Irq & D11_INT_EP0_IN)

if (CtlTransferInProgress == PROGRESS_ADDRESS) { /*передали адрес?*/

D11CmdDataWrite(D11_SET_ADDRESS_ENABLE,&DeviceAddress,1);

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP0_IN, Buffer, 1);

CtlTransferInProgress = PROGRESS_IDLE;

}

else {

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP0_IN, Buffer, 1);

WriteBufferToEndPoint();

}

}

/*конечная точка 1 iout*/

if (Irq & D11_INT_EP1_OUT) {

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP1_OUT, Buffer, 1);

bytes = D11ReadEndpoint(D11_ENDPOINT_EP1_OUT, Buffer);

for (count = 0; count < bytes; count++) {

circularbuffer[inpointer++] = Buffer[count];

if (inpointer >= MAX_BUFFER_SIZE) inpointer = 0;

}

loadfromcircularbuffer(); //Kick Start

}

if (Irq & D11_INT_EP1_IN) {

printf("EP1_IN\n\r");

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP1_IN, Buffer, 1);

loadfromcircularbuffer();

}

if (Irq & D11_INT_EP2_OUT) {

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP2_OUT, Buffer, 1);

Buffer[0] = 0x01; /* Stall Endpoint */

D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + D11_ENDPOINT_EP2_OUT, Buffer, 1);

}

if (Irq & D11_INT_EP2_IN) {

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP2_IN, Buffer, 1);

Buffer[0] = 0x01; /* Stall Endpoint */

D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + D11_ENDPOINT_EP2_IN, Buffer, 1);

}

}

void Process_EP0_OUT_Interrupt(void)

{

unsigned long a;

unsigned char Buffer[2];

USB_SETUP_REQUEST SetupPacket;

/* Проверка типа пакета SETUP или DATA */

D11CmdDataRead(D11_READ_LAST_TRANSACTION + D11_ENDPOINT_EP0_OUT, &SetupPacket, 1);

if (SetupPacket.bmRequestType & D11_LAST_TRAN_SETUP) {

/* если это пакет установки считываем его */

D11ReadEndpoint(D11_ENDPOINT_EP0_OUT, &SetupPacket);

/* посылаем сигнал квитирования и очищаем буфер точки 0 OUT */

D11CmdDataWrite(D11_ACK_SETUP, NULL, 0);

D11CmdDataWrite(D11_CLEAR_BUFFER, NULL, 0);

/* посылаем сигнал квитирования в точку 0 IN*/

D11CmdDataWrite(D11_ENDPOINT_EP0_IN, NULL, 0);

D11CmdDataWrite(D11_ACK_SETUP, NULL, 0);

/* Рассматриваем тип запроса */

switch (SetupPacket.bmRequestType & 0x7F) {

case STANDARD_DEVICE_REQUEST:

/*стандартный запрос к устройству*/

switch (SetupPacket.bRequest) {

case GET_STATUS:

/* Remote Wakeup and Self Powered Status */

Buffer[0] = 0x01;

Buffer[1] = 0x00;

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, Buffer, 2);

break;

case CLEAR_FEATURE:

/*выбор возможности*/

case SET_FEATURE:

ErrorStallControlEndPoint();

break;

case SET_ADDRESS:

/*установка адреса*/

DeviceAddress = SetupPacket.wValue | 0x80;

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, NULL, 0);

CtlTransferInProgress = PROGRESS_ADDRESS;

break;

case GET_DESCRIPTOR:

/*дать дескриптор*/

GetDescriptor(&SetupPacket);

break;

case GET_CONFIGURATION:

/*дать конфигурацию*/

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, &DeviceConfigured, 1);

break;

case SET_CONFIGURATION:

/*установить конфигурацию*/

DeviceConfigured = SetupPacket.wValue & 0xFF;

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, NULL, 0);

break;

//case SET_DESCRIPTOR:

default:

/* Unsupported - Request Error - Stall */

ErrorStallControlEndPoint();

break;

}

break;

case STANDARD_INTERFACE_REQUEST:

/*стандартный запрос к интерфейсу*/

switch (SetupPacket.bRequest) {

case GET_STATUS:

/* Дать стстус */

/* статус 0 */

Buffer[0] = 0x00;

Buffer[1] = 0x00;

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, Buffer, 2);

break;

case SET_INTERFACE:

/* Device Only supports default setting, Stall may be */

/* returned in the status stage of the request */

if (SetupPacket.wIndex == 0 && SetupPacket.wValue == 0)

/* Interface Zero, Alternative Setting = 0 */

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, NULL, 0);

else ErrorStallControlEndPoint();

break;

case GET_INTERFACE:

if (SetupPacket.wIndex == 0) { /* Interface Zero */

Buffer[0] = 0; /* Alternative Setting */

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, Buffer, 1);

break;

} /* else fall through as RequestError */

//case CLEAR_FEATURE:

//case SET_FEATURE:

/* Interface has no defined features. Return RequestError */

default:

ErrorStallControlEndPoint();

break;

}

break;

case STANDARD_ENDPOINT_REQUEST:

/*Запрос к точке доступа*/

case CLEAR_FEATURE:

case SET_FEATURE:

/* Halt(Stall) feature required to be implemented on all Interrupt and */

/* Bulk Endpoints. It is not required nor recommended on the Default Pipe */

if (SetupPacket.wValue == ENDPOINT_HALT)

{

if (SetupPacket.bRequest == CLEAR_FEATURE) Buffer[0] = 0x00;

else Buffer[0] = 0x01;

switch (SetupPacket.wIndex & 0xFF) {

case 0x01 : D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + \

D11_ENDPOINT_EP1_OUT, Buffer, 1);

break;

case 0x81 : D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + \

D11_ENDPOINT_EP1_IN, Buffer, 1);

break;

case 0x02 : D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + \

D11_ENDPOINT_EP2_OUT, Buffer, 1);

break;

case 0x82 : D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + \

D11_ENDPOINT_EP2_IN, Buffer, 1);

break;

case 0x03 : D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + \

D11_ENDPOINT_EP3_OUT, Buffer, 1);

break;

case 0x83 : D11CmdDataWrite(D11_SET_ENDPOINT_STATUS + \

D11_ENDPOINT_EP3_IN, Buffer, 1);

break;

default : /* Invalid Endpoint - RequestError */

ErrorStallControlEndPoint();

break;

}

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, NULL, 0);

} else {

/* No other Features for Endpoint - Request Error */

ErrorStallControlEndPoint();

}

break;

case GET_STATUS:

/* Get Status Request to Endpoint should return */

/* Halt Status in D0 for Interrupt and Bulk */

switch (SetupPacket.wIndex & 0xFF) {

case 0x01 : D11CmdDataRead(D11_READ_ENDPOINT_STATUS + \

D11_ENDPOINT_EP1_OUT, Buffer, 1);

break;

case 0x81 : D11CmdDataRead(D11_READ_ENDPOINT_STATUS + \

D11_ENDPOINT_EP1_IN, Buffer, 1);

break;

case 0x02 : D11CmdDataRead(D11_READ_ENDPOINT_STATUS + \

D11_ENDPOINT_EP2_OUT, Buffer, 1);

break;

case 0x82 : D11CmdDataRead(D11_READ_ENDPOINT_STATUS + \

D11_ENDPOINT_EP2_IN, Buffer, 1);

break;

case 0x03 : D11CmdDataRead(D11_READ_ENDPOINT_STATUS + \

D11_ENDPOINT_EP3_OUT, Buffer, 1);

break;

case 0x83 : D11CmdDataRead(D11_READ_ENDPOINT_STATUS + \

D11_ENDPOINT_EP3_IN, Buffer, 1);

break;

default : /* Invalid Endpoint - RequestError */

ErrorStallControlEndPoint();

break;

}

if (Buffer[0] & 0x08) Buffer[0] = 0x01;

else Buffer[0] = 0x00;

Buffer[1] = 0x00;

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, Buffer, 2);

break;

default:

/* Unsupported - Request Error - Stall */

ErrorStallControlEndPoint();

break;

}

break;

case VENDOR_DEVICE_REQUEST:

case VENDOR_ENDPOINT_REQUEST:

printf("Vendor Device bRequest = 0x%X, wValue = 0x%X, wIndex = 0x%X\n\r", \

SetupPacket.bRequest, SetupPacket.wValue, SetupPacket.wIndex);

switch (SetupPacket.bRequest) {

case VENDOR_GET_ANALOG_VALUE:

printf("Get Analog Value, Channel %x :",SetupPacket.wIndex & 0x07);

ADCON0 = 0xC1 | (SetupPacket.wIndex & 0x07) << 3;

/* Wait Acquistion time of Sample and Hold */

for (a = 0; a <= 255; a++);

ADGO = 1;

while(ADGO);

Buffer[0] = ADRESL;

Buffer[1] = ADRESH;

a = (Buffer[1] << 8) + Buffer[0];

a = (a * 500) / 1024;

printf(" Value = %d.%02d\n\r",(unsigned int)a/100,(unsigned int)a%100);

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, Buffer, 2);

break;

case VENDOR_SET_RB_HIGH_NIBBLE:

printf("Write High Nibble of PORTB\n\r");

PORTB = (PORTB & 0x0F) | (SetupPacket.wIndex & 0xF0);

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, NULL, 0);

break;

default:

ErrorStallControlEndPoint();

break;

}

break;

default:

printf("UnSupported Request Type 0x%X\n\r",SetupPacket.bmRequestType);

ErrorStallControlEndPoint();

break;

}

} else {

printf("Data Packet?\n\r");

/* This is a Data Packet */

}

}

/*Вернуть дескриптор*/

void GetDescriptor(PUSB_SETUP_REQUEST SetupPacket)

{

switch((SetupPacket->wValue & 0xFF00) >> 8) {

case TYPE_DEVICE_DESCRIPTOR:

/*дескриптор устройства*/

pSendBuffer = (const unsigned char *)&DeviceDescriptor;

BytesToSend = DeviceDescriptor.bLength;

if (BytesToSend > SetupPacket->wLength)

BytesToSend = SetupPacket->wLength;

WriteBufferToEndPoint();

break;

case TYPE_CONFIGURATION_DESCRIPTOR:

/*дескриптор конфигурации*/

SetupPacket->wLength, sizeof(ConfigurationDescriptor));

pSendBuffer = (const unsigned char *)&ConfigurationDescriptor;

BytesToSend = sizeof(ConfigurationDescriptor);

if (BytesToSend > SetupPacket->wLength)

BytesToSend = SetupPacket->wLength;

WriteBufferToEndPoint();

break;

case TYPE_STRING_DESCRIPTOR:

/*дескриптор строки*/

SetupPacket->wIndex, SetupPacket->wValue & 0xFF);

switch (SetupPacket->wValue & 0xFF){

case 0 : pSendBuffer = (const unsigned char *)&LANGID_Descriptor;

BytesToSend = sizeof(LANGID_Descriptor);

break;

case 1 : pSendBuffer = (const unsigned char *)&Manufacturer_Descriptor;

BytesToSend = sizeof(Manufacturer_Descriptor);

break;

default : pSendBuffer = NULL;

BytesToSend = 0;

}

if (BytesToSend > SetupPacket->wLength)

BytesToSend = SetupPacket->wLength;

WriteBufferToEndPoint();

break;

default:

ErrorStallControlEndPoint();

break;

}

}

/*читать точку*/

unsigned char D11ReadEndpoint(unsigned char Endpoint, unsigned char *Buffer)

{

unsigned char D11Header[2];

unsigned char BufferStatus = 0;

/* Проверяем буфер точки */

D11CmdDataRead(Endpoint, &BufferStatus, 1);

if(BufferStatus & 0x01)

{

/*читаем из буфера*/

D11CmdDataRead(D11_READ_BUFFER, D11Header, 2);

if(D11Header[1]) D11CmdDataRead(D11_READ_BUFFER, Buffer, D11Header[1]);

/* очищаем буфер*/

D11CmdDataWrite(D11_CLEAR_BUFFER, NULL, 0);

}

return D11Header[1];

}

/*записываем в точку*/

void D11WriteEndpoint(unsigned char Endpoint, const unsigned char *Buffer, unsigned char Bytes)

{

unsigned char D11Header[2];

unsigned char BufferStatus = 0;

D11Header[0] = 0x00;

D11Header[1] = Bytes;

D11CmdDataRead(Endpoint, &BufferStatus, 1);

/* записываем заголовок */

D11CmdDataWrite(D11_WRITE_BUFFER, D11Header, 2);

/* записываем в буфер*/

if (Bytes) D11CmdDataWrite(D11_WRITE_BUFFER, Buffer, Bytes);

/* Буфер полон */

D11CmdDataWrite(D11_VALIDATE_BUFFER, NULL, 0);

}

/*записываем буфер в точку*/

void WriteBufferToEndPoint(void)

{

if (BytesToSend == 0) {

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, NULL, 0);

} else if (BytesToSend >= 64) {

/* считываем 64 байта и посылаем */

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, pSendBuffer, 8);

pSendBuffer += 64;

BytesToSend -= 64;

} else {

D11WriteEndpoint(D11_ENDPOINT_EP0_IN, pSendBuffer, BytesToSend);

BytesToSend = 0;

}

}

void loadfromcircularbuffer(void)

{

unsigned char Buffer[10];

unsigned char count;

// Read Buffer Full Status

D11CmdDataRead(D11_ENDPOINT_EP1_IN, Buffer, 1);

if (Buffer[0] == 0){

// Buffer Empty

if (inpointer != outpointer){

// We have bytes to send

count = 0;

do {

Buffer[count++] = circularbuffer[outpointer++];

if (outpointer >= MAX_BUFFER_SIZE) outpointer = 0;

if (outpointer == inpointer) break; // No more data

} while (count < 8); // Maximum Buffer Size

// Now load it into EP1_In

D11WriteEndpoint(D11_ENDPOINT_EP1_IN, Buffer, count);

}

}

}

/*команда записать*/

void D11CmdDataWrite(unsigned char Command, const unsigned char *Buffer, unsigned char Count)

{

I2C_Write(D11_CMD_ADDR, &Command, 1);

if(Count) I2C_Write(D11_DATA_ADDR_WRITE, Buffer, Count);

}

/*команда читать*/

void D11CmdDataRead(unsigned char Command, unsigned char Buffer[], unsigned char Count)

{

I2C_Write(D11_CMD_ADDR, &Command, 1);

if(Count) I2C_Read(D11_DATA_ADDR_READ, Buffer, Count);

}

/*Обработка ОУ*/

void Proc_OU(void)

{

if (P3.0==1) OUT_OU(); /*если необходим вывод в ОУ*/

if (P3.1==0), (P3.5==1) INP_OU(); /*если необходим ввод из ОУ*/

}

void INP_OU (void)

{

unsigned char Buffer[2];

Buffer[0] = P1; /*считывание первого байта */

Buffer[1] = P0; /*считывание второго байта */

P0.4 Buffer[1] = 0;

P0.5 Buffer[1] = 0;

P0.6 Buffer[1] = 0;

P0.7 Buffer[1] = 0;

P3.4 = 1; /* импульс START_CT*/

D11WriteEndpoint(D11_ENDPOINT_EP2_IN, Buffer, 2); /*запись данных в буфер*/

}

void OUT_OU (void)

{

unsigned char Buffer[64];

unsigned char count;

unsigned char byte;

byte = D11ReadEndpoint(D11_ENDPOINT_EP2_OUT, Buffer);

if (byte){

/* если непустой*/

for (count = 0; count < byte; count++) {

while(P3.0) /*если ОУ требует данные */

{

P2 = buffer[count];

P0.7 = 1; /*строб данных Output*/

}

P0.7 = 0; /*сброс строба данных*/

}

}