@ -0,0 +1,3 @@ | |||
[submodule "LUFA"] | |||
path = LUFA | |||
url = https://github.com/abcminiuser/lufa.git |
@ -0,0 +1,222 @@ | |||
/* | |||
LUFA Library | |||
Copyright (C) Dean Camera, 2021. | |||
dean [at] fourwalledcubicle [dot] com | |||
www.lufa-lib.org | |||
*/ | |||
/* | |||
Copyright 2021 Dean Camera (dean [at] fourwalledcubicle [dot] com) | |||
Permission to use, copy, modify, distribute, and sell this | |||
software and its documentation for any purpose is hereby granted | |||
without fee, provided that the above copyright notice appear in | |||
all copies and that both that the copyright notice and this | |||
permission notice and warranty disclaimer appear in supporting | |||
documentation, and that the name of the author not be used in | |||
advertising or publicity pertaining to distribution of the | |||
software without specific, written prior permission. | |||
The author disclaims all warranties with regard to this | |||
software, including all implied warranties of merchantability | |||
and fitness. In no event shall the author be liable for any | |||
special, indirect or consequential damages or any damages | |||
whatsoever resulting from loss of use, data or profits, whether | |||
in an action of contract, negligence or other tortious action, | |||
arising out of or in connection with the use or performance of | |||
this software. | |||
*/ | |||
/** \file | |||
* | |||
* USB Device Descriptors, for library use when in USB device mode. Descriptors are special | |||
* computer-readable structures which the host requests upon device enumeration, to determine | |||
* the device's capabilities and functions. | |||
*/ | |||
#include "Descriptors.h" | |||
/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall | |||
* device characteristics, including the supported USB version, control endpoint size and the | |||
* number of device configurations. The descriptor is read out by the USB host when the enumeration | |||
* process begins. | |||
*/ | |||
const USB_Descriptor_Device_t PROGMEM DeviceDescriptor = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device}, | |||
.USBSpecification = VERSION_BCD(1,1,0), | |||
.Class = CDC_CSCP_CDCClass, | |||
.SubClass = CDC_CSCP_NoSpecificSubclass, | |||
.Protocol = CDC_CSCP_NoSpecificProtocol, | |||
.Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE, | |||
.VendorID = 0x03EB, | |||
.ProductID = 0x2044, | |||
.ReleaseNumber = VERSION_BCD(0,0,1), | |||
.ManufacturerStrIndex = STRING_ID_Manufacturer, | |||
.ProductStrIndex = STRING_ID_Product, | |||
.SerialNumStrIndex = USE_INTERNAL_SERIAL, | |||
.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS | |||
}; | |||
/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage | |||
* of the device in one of its supported configurations, including information about any device interfaces | |||
* and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting | |||
* a configuration so that the host may correctly communicate with the USB device. | |||
*/ | |||
const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor = | |||
{ | |||
.Config = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration}, | |||
.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t), | |||
.TotalInterfaces = 2, | |||
.ConfigurationNumber = 1, | |||
.ConfigurationStrIndex = NO_DESCRIPTOR, | |||
.ConfigAttributes = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_SELFPOWERED), | |||
.MaxPowerConsumption = USB_CONFIG_POWER_MA(100) | |||
}, | |||
.CDC_CCI_Interface = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, | |||
.InterfaceNumber = INTERFACE_ID_CDC_CCI, | |||
.AlternateSetting = 0, | |||
.TotalEndpoints = 1, | |||
.Class = CDC_CSCP_CDCClass, | |||
.SubClass = CDC_CSCP_ACMSubclass, | |||
.Protocol = CDC_CSCP_ATCommandProtocol, | |||
.InterfaceStrIndex = NO_DESCRIPTOR | |||
}, | |||
.CDC_Functional_Header = | |||
{ | |||
.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalHeader_t), .Type = CDC_DTYPE_CSInterface}, | |||
.Subtype = CDC_DSUBTYPE_CSInterface_Header, | |||
.CDCSpecification = VERSION_BCD(1,1,0), | |||
}, | |||
.CDC_Functional_ACM = | |||
{ | |||
.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalACM_t), .Type = CDC_DTYPE_CSInterface}, | |||
.Subtype = CDC_DSUBTYPE_CSInterface_ACM, | |||
.Capabilities = 0x06, | |||
}, | |||
.CDC_Functional_Union = | |||
{ | |||
.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalUnion_t), .Type = CDC_DTYPE_CSInterface}, | |||
.Subtype = CDC_DSUBTYPE_CSInterface_Union, | |||
.MasterInterfaceNumber = INTERFACE_ID_CDC_CCI, | |||
.SlaveInterfaceNumber = INTERFACE_ID_CDC_DCI, | |||
}, | |||
.CDC_NotificationEndpoint = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, | |||
.EndpointAddress = CDC_NOTIFICATION_EPADDR, | |||
.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), | |||
.EndpointSize = CDC_NOTIFICATION_EPSIZE, | |||
.PollingIntervalMS = 0xFF | |||
}, | |||
.CDC_DCI_Interface = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, | |||
.InterfaceNumber = INTERFACE_ID_CDC_DCI, | |||
.AlternateSetting = 0, | |||
.TotalEndpoints = 2, | |||
.Class = CDC_CSCP_CDCDataClass, | |||
.SubClass = CDC_CSCP_NoDataSubclass, | |||
.Protocol = CDC_CSCP_NoDataProtocol, | |||
.InterfaceStrIndex = NO_DESCRIPTOR | |||
}, | |||
.CDC_DataOutEndpoint = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, | |||
.EndpointAddress = CDC_RX_EPADDR, | |||
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), | |||
.EndpointSize = CDC_TXRX_EPSIZE, | |||
.PollingIntervalMS = 0x05 | |||
}, | |||
.CDC_DataInEndpoint = | |||
{ | |||
.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, | |||
.EndpointAddress = CDC_TX_EPADDR, | |||
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), | |||
.EndpointSize = CDC_TXRX_EPSIZE, | |||
.PollingIntervalMS = 0x05 | |||
} | |||
}; | |||
/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests | |||
* the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate | |||
* via the language ID table available at USB.org what languages the device supports for its string descriptors. | |||
*/ | |||
const USB_Descriptor_String_t PROGMEM LanguageString = USB_STRING_DESCRIPTOR_ARRAY(LANGUAGE_ID_ENG); | |||
/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable | |||
* form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device | |||
* Descriptor. | |||
*/ | |||
const USB_Descriptor_String_t PROGMEM ManufacturerString = USB_STRING_DESCRIPTOR(L"LUFA Library"); | |||
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form, | |||
* and is read out upon request by the host when the appropriate string ID is requested, listed in the Device | |||
* Descriptor. | |||
*/ | |||
const USB_Descriptor_String_t PROGMEM ProductString = USB_STRING_DESCRIPTOR(L"LUFA CDC Demo"); | |||
/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors" | |||
* documentation) by the application code so that the address and size of a requested descriptor can be given | |||
* to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function | |||
* is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the | |||
* USB host. | |||
*/ | |||
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, | |||
const uint16_t wIndex, | |||
const void** const DescriptorAddress) | |||
{ | |||
const uint8_t DescriptorType = (wValue >> 8); | |||
const uint8_t DescriptorNumber = (wValue & 0xFF); | |||
const void* Address = NULL; | |||
uint16_t Size = NO_DESCRIPTOR; | |||
switch (DescriptorType) | |||
{ | |||
case DTYPE_Device: | |||
Address = &DeviceDescriptor; | |||
Size = sizeof(USB_Descriptor_Device_t); | |||
break; | |||
case DTYPE_Configuration: | |||
Address = &ConfigurationDescriptor; | |||
Size = sizeof(USB_Descriptor_Configuration_t); | |||
break; | |||
case DTYPE_String: | |||
switch (DescriptorNumber) | |||
{ | |||
case STRING_ID_Language: | |||
Address = &LanguageString; | |||
Size = pgm_read_byte(&LanguageString.Header.Size); | |||
break; | |||
case STRING_ID_Manufacturer: | |||
Address = &ManufacturerString; | |||
Size = pgm_read_byte(&ManufacturerString.Header.Size); | |||
break; | |||
case STRING_ID_Product: | |||
Address = &ProductString; | |||
Size = pgm_read_byte(&ProductString.Header.Size); | |||
break; | |||
} | |||
break; | |||
} | |||
*DescriptorAddress = Address; | |||
return Size; | |||
} | |||
@ -0,0 +1,110 @@ | |||
/* | |||
LUFA Library | |||
Copyright (C) Dean Camera, 2021. | |||
dean [at] fourwalledcubicle [dot] com | |||
www.lufa-lib.org | |||
*/ | |||
/* | |||
Copyright 2021 Dean Camera (dean [at] fourwalledcubicle [dot] com) | |||
Permission to use, copy, modify, distribute, and sell this | |||
software and its documentation for any purpose is hereby granted | |||
without fee, provided that the above copyright notice appear in | |||
all copies and that both that the copyright notice and this | |||
permission notice and warranty disclaimer appear in supporting | |||
documentation, and that the name of the author not be used in | |||
advertising or publicity pertaining to distribution of the | |||
software without specific, written prior permission. | |||
The author disclaims all warranties with regard to this | |||
software, including all implied warranties of merchantability | |||
and fitness. In no event shall the author be liable for any | |||
special, indirect or consequential damages or any damages | |||
whatsoever resulting from loss of use, data or profits, whether | |||
in an action of contract, negligence or other tortious action, | |||
arising out of or in connection with the use or performance of | |||
this software. | |||
*/ | |||
/** \file | |||
* | |||
* Header file for Descriptors.c. | |||
*/ | |||
#ifndef _DESCRIPTORS_H_ | |||
#define _DESCRIPTORS_H_ | |||
/* Includes: */ | |||
#include <LUFA/Drivers/USB/USB.h> | |||
#include <avr/pgmspace.h> | |||
/* Macros: */ | |||
/** Endpoint address of the CDC device-to-host notification IN endpoint. */ | |||
#define CDC_NOTIFICATION_EPADDR (ENDPOINT_DIR_IN | 2) | |||
/** Endpoint address of the CDC device-to-host data IN endpoint. */ | |||
#define CDC_TX_EPADDR (ENDPOINT_DIR_IN | 3) | |||
/** Endpoint address of the CDC host-to-device data OUT endpoint. */ | |||
#define CDC_RX_EPADDR (ENDPOINT_DIR_OUT | 4) | |||
/** Size in bytes of the CDC device-to-host notification IN endpoint. */ | |||
#define CDC_NOTIFICATION_EPSIZE 8 | |||
/** Size in bytes of the CDC data IN and OUT endpoints. */ | |||
#define CDC_TXRX_EPSIZE 16 | |||
/* Type Defines: */ | |||
/** Type define for the device configuration descriptor structure. This must be defined in the | |||
* application code, as the configuration descriptor contains several sub-descriptors which | |||
* vary between devices, and which describe the device's usage to the host. | |||
*/ | |||
typedef struct | |||
{ | |||
USB_Descriptor_Configuration_Header_t Config; | |||
// CDC Control Interface | |||
USB_Descriptor_Interface_t CDC_CCI_Interface; | |||
USB_CDC_Descriptor_FunctionalHeader_t CDC_Functional_Header; | |||
USB_CDC_Descriptor_FunctionalACM_t CDC_Functional_ACM; | |||
USB_CDC_Descriptor_FunctionalUnion_t CDC_Functional_Union; | |||
USB_Descriptor_Endpoint_t CDC_NotificationEndpoint; | |||
// CDC Data Interface | |||
USB_Descriptor_Interface_t CDC_DCI_Interface; | |||
USB_Descriptor_Endpoint_t CDC_DataOutEndpoint; | |||
USB_Descriptor_Endpoint_t CDC_DataInEndpoint; | |||
} USB_Descriptor_Configuration_t; | |||
/** Enum for the device interface descriptor IDs within the device. Each interface descriptor | |||
* should have a unique ID index associated with it, which can be used to refer to the | |||
* interface from other descriptors. | |||
*/ | |||
enum InterfaceDescriptors_t | |||
{ | |||
INTERFACE_ID_CDC_CCI = 0, /**< CDC CCI interface descriptor ID */ | |||
INTERFACE_ID_CDC_DCI = 1, /**< CDC DCI interface descriptor ID */ | |||
}; | |||
/** Enum for the device string descriptor IDs within the device. Each string descriptor should | |||
* have a unique ID index associated with it, which can be used to refer to the string from | |||
* other descriptors. | |||
*/ | |||
enum StringDescriptors_t | |||
{ | |||
STRING_ID_Language = 0, /**< Supported Languages string descriptor ID (must be zero) */ | |||
STRING_ID_Manufacturer = 1, /**< Manufacturer string ID */ | |||
STRING_ID_Product = 2, /**< Product string ID */ | |||
}; | |||
/* Function Prototypes: */ | |||
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, | |||
const uint16_t wIndex, | |||
const void** const DescriptorAddress) | |||
ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3); | |||
#endif | |||
@ -0,0 +1,86 @@ | |||
/* | |||
LUFA Library | |||
Copyright (C) Dean Camera, 2021. | |||
dean [at] fourwalledcubicle [dot] com | |||
www.lufa-lib.org | |||
*/ | |||
/* | |||
Copyright 2021 Dean Camera (dean [at] fourwalledcubicle [dot] com) | |||
Permission to use, copy, modify, distribute, and sell this | |||
software and its documentation for any purpose is hereby granted | |||
without fee, provided that the above copyright notice appear in | |||
all copies and that both that the copyright notice and this | |||
permission notice and warranty disclaimer appear in supporting | |||
documentation, and that the name of the author not be used in | |||
advertising or publicity pertaining to distribution of the | |||
software without specific, written prior permission. | |||
The author disclaims all warranties with regard to this | |||
software, including all implied warranties of merchantability | |||
and fitness. In no event shall the author be liable for any | |||
special, indirect or consequential damages or any damages | |||
whatsoever resulting from loss of use, data or profits, whether | |||
in an action of contract, negligence or other tortious action, | |||
arising out of or in connection with the use or performance of | |||
this software. | |||
*/ | |||
/** \file | |||
* \brief LUFA Library Configuration Header File | |||
* | |||
* This header file is used to configure LUFA's compile time options, | |||
* as an alternative to the compile time constants supplied through | |||
* a makefile. | |||
* | |||
* For information on what each token does, refer to the LUFA | |||
* manual section "Summary of Compile Tokens". | |||
*/ | |||
#ifndef _LUFA_CONFIG_H_ | |||
#define _LUFA_CONFIG_H_ | |||
/* Non-USB Related Configuration Tokens: */ | |||
// #define DISABLE_TERMINAL_CODES | |||
/* USB Class Driver Related Tokens: */ | |||
// #define HID_HOST_BOOT_PROTOCOL_ONLY | |||
// #define HID_STATETABLE_STACK_DEPTH {Insert Value Here} | |||
// #define HID_USAGE_STACK_DEPTH {Insert Value Here} | |||
// #define HID_MAX_COLLECTIONS {Insert Value Here} | |||
// #define HID_MAX_REPORTITEMS {Insert Value Here} | |||
// #define HID_MAX_REPORT_IDS {Insert Value Here} | |||
// #define NO_CLASS_DRIVER_AUTOFLUSH | |||
/* General USB Driver Related Tokens: */ | |||
// #define ORDERED_EP_CONFIG | |||
#define USE_STATIC_OPTIONS (USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL) | |||
#define USB_DEVICE_ONLY | |||
// #define USB_HOST_ONLY | |||
// #define USB_STREAM_TIMEOUT_MS {Insert Value Here} | |||
// #define NO_LIMITED_CONTROLLER_CONNECT | |||
// #define NO_SOF_EVENTS | |||
/* USB Device Mode Driver Related Tokens: */ | |||
// #define USE_RAM_DESCRIPTORS | |||
#define USE_FLASH_DESCRIPTORS | |||
// #define USE_EEPROM_DESCRIPTORS | |||
// #define NO_INTERNAL_SERIAL | |||
#define FIXED_CONTROL_ENDPOINT_SIZE 8 | |||
// #define DEVICE_STATE_AS_GPIOR {Insert Value Here} | |||
#define FIXED_NUM_CONFIGURATIONS 1 | |||
// #define CONTROL_ONLY_DEVICE | |||
// #define INTERRUPT_CONTROL_ENDPOINT | |||
// #define NO_DEVICE_REMOTE_WAKEUP | |||
// #define NO_DEVICE_SELF_POWER | |||
/* USB Host Mode Driver Related Tokens: */ | |||
// #define HOST_STATE_AS_GPIOR {Insert Value Here} | |||
// #define USB_HOST_TIMEOUT_MS {Insert Value Here} | |||
// #define HOST_DEVICE_SETTLE_DELAY_MS {Insert Value Here} | |||
// #define NO_AUTO_VBUS_MANAGEMENT | |||
// #define INVERTED_VBUS_ENABLE_LINE | |||
#endif |
@ -0,0 +1,38 @@ | |||
# | |||
# LUFA Library | |||
# Copyright (C) Dean Camera, 2015. | |||
# | |||
# dean [at] fourwalledcubicle [dot] com | |||
# www.lufa-lib.org | |||
# | |||
# -------------------------------------- | |||
# LUFA Project Makefile. | |||
# -------------------------------------- | |||
# Run "make help" for target help. | |||
MCU = atmega32u4 | |||
ARCH = AVR8 | |||
BOARD = USER | |||
F_CPU = 16000000 | |||
F_USB = $(F_CPU) | |||
OPTIMIZATION = s | |||
TARGET = usbfanctrl | |||
SRC = main.c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS) $(LUFA_SRC_PLATFORM) | |||
LUFA_PATH = LUFA/LUFA | |||
CC_FLAGS = -DUSE_LUFA_CONFIG_HEADER -IConfig | |||
LD_FLAGS = | |||
# Default target | |||
all: | |||
# Include LUFA build script makefiles | |||
include $(LUFA_PATH)/Build/lufa_core.mk | |||
include $(LUFA_PATH)/Build/lufa_sources.mk | |||
include $(LUFA_PATH)/Build/lufa_build.mk | |||
#include $(LUFA_PATH)/Build/lufa_cppcheck.mk | |||
#include $(LUFA_PATH)/Build/lufa_doxygen.mk | |||
#include $(LUFA_PATH)/Build/lufa_dfu.mk | |||
#include $(LUFA_PATH)/Build/lufa_hid.mk | |||
include $(LUFA_PATH)/Build/lufa_avrdude.mk | |||
#include $(LUFA_PATH)/Build/lufa_atprogram.mk |
@ -0,0 +1,181 @@ | |||
#include <avr/io.h> | |||
#include <avr/wdt.h> | |||
#include <avr/power.h> | |||
#include <avr/interrupt.h> | |||
#include <string.h> | |||
#include "Descriptors.h" | |||
#include <LUFA/Drivers/USB/USB.h> | |||
#include <LUFA/Platform/Platform.h> | |||
void SetupHardware(void); | |||
void CDC_Task(void); | |||
void EVENT_USB_Device_Connect(void); | |||
void EVENT_USB_Device_Disconnect(void); | |||
void EVENT_USB_Device_ConfigurationChanged(void); | |||
void EVENT_USB_Device_ControlRequest(void); | |||
/** Contains the current baud rate and other settings of the virtual serial port. While this demo does not use | |||
* the physical USART and thus does not use these settings, they must still be retained and returned to the host | |||
* upon request or the host will assume the device is non-functional. | |||
* | |||
* These values are set by the host via a class-specific request, however they are not required to be used accurately. | |||
* It is possible to completely ignore these value or use other settings as the host is completely unaware of the physical | |||
* serial link characteristics and instead sends and receives data in endpoint streams. | |||
*/ | |||
static CDC_LineEncoding_t LineEncoding = { .BaudRateBPS = 0, | |||
.CharFormat = CDC_LINEENCODING_OneStopBit, | |||
.ParityType = CDC_PARITY_None, | |||
.DataBits = 8 }; | |||
/** Main program entry point. This routine contains the overall program flow, including initial | |||
* setup of all components and the main program loop. | |||
*/ | |||
int main(void) | |||
{ | |||
SetupHardware(); | |||
GlobalInterruptEnable(); | |||
for (;;) | |||
{ | |||
CDC_Task(); | |||
USB_USBTask(); | |||
} | |||
} | |||
/** Configures the board hardware and chip peripherals for the demo's functionality. */ | |||
void SetupHardware(void) | |||
{ | |||
/* Disable watchdog if enabled by bootloader/fuses */ | |||
MCUSR &= ~(1 << WDRF); | |||
wdt_disable(); | |||
/* Disable clock division */ | |||
clock_prescale_set(clock_div_1); | |||
USB_Init(); | |||
} | |||
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and | |||
* starts the library USB task to begin the enumeration and USB management process. | |||
*/ | |||
void EVENT_USB_Device_Connect(void) | |||
{ | |||
} | |||
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via | |||
* the status LEDs and stops the USB management and CDC management tasks. | |||
*/ | |||
void EVENT_USB_Device_Disconnect(void) | |||
{ | |||
} | |||
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration | |||
* of the USB device after enumeration - the device endpoints are configured and the CDC management task started. | |||
*/ | |||
void EVENT_USB_Device_ConfigurationChanged(void) | |||
{ | |||
/* Setup CDC Data Endpoints */ | |||
Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, 1); | |||
Endpoint_ConfigureEndpoint(CDC_TX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1); | |||
Endpoint_ConfigureEndpoint(CDC_RX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1); | |||
/* Reset line encoding baud rate so that the host knows to send new values */ | |||
LineEncoding.BaudRateBPS = 0; | |||
} | |||
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to | |||
* the device from the USB host before passing along unhandled control requests to the library for processing | |||
* internally. | |||
*/ | |||
void EVENT_USB_Device_ControlRequest(void) | |||
{ | |||
/* Process CDC specific control requests */ | |||
switch (USB_ControlRequest.bRequest) | |||
{ | |||
case CDC_REQ_GetLineEncoding: | |||
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) | |||
{ | |||
Endpoint_ClearSETUP(); | |||
/* Write the line coding data to the control endpoint */ | |||
Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t)); | |||
Endpoint_ClearOUT(); | |||
} | |||
break; | |||
case CDC_REQ_SetLineEncoding: | |||
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) | |||
{ | |||
Endpoint_ClearSETUP(); | |||
/* Read the line coding data in from the host into the global struct */ | |||
Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t)); | |||
Endpoint_ClearIN(); | |||
} | |||
break; | |||
case CDC_REQ_SetControlLineState: | |||
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) | |||
{ | |||
Endpoint_ClearSETUP(); | |||
Endpoint_ClearStatusStage(); | |||
} | |||
break; | |||
} | |||
} | |||
/** Function to manage CDC data transmission and reception to and from the host. */ | |||
void CDC_Task(void) | |||
{ | |||
char* ReportString = NULL; | |||
static bool ActionSent = false; | |||
/* Device must be connected and configured for the task to run */ | |||
if (USB_DeviceState != DEVICE_STATE_Configured) | |||
return; | |||
ActionSent = false; | |||
/* Flag management - Only allow one string to be sent per action */ | |||
if ((ReportString != NULL) && (ActionSent == false) && LineEncoding.BaudRateBPS) | |||
{ | |||
ActionSent = true; | |||
/* Select the Serial Tx Endpoint */ | |||
Endpoint_SelectEndpoint(CDC_TX_EPADDR); | |||
/* Write the String to the Endpoint */ | |||
Endpoint_Write_Stream_LE(ReportString, strlen(ReportString), NULL); | |||
/* Remember if the packet to send completely fills the endpoint */ | |||
bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE); | |||
/* Finalize the stream transfer to send the last packet */ | |||
Endpoint_ClearIN(); | |||
/* If the last packet filled the endpoint, send an empty packet to release the buffer on | |||
* the receiver (otherwise all data will be cached until a non-full packet is received) */ | |||
if (IsFull) | |||
{ | |||
/* Wait until the endpoint is ready for another packet */ | |||
Endpoint_WaitUntilReady(); | |||
/* Send an empty packet to ensure that the host does not buffer data sent to it */ | |||
Endpoint_ClearIN(); | |||
} | |||
} | |||
/* Select the Serial Rx Endpoint */ | |||
Endpoint_SelectEndpoint(CDC_RX_EPADDR); | |||
/* Throw away any received data from the host */ | |||
if (Endpoint_IsOUTReceived()) | |||
Endpoint_ClearOUT(); | |||
} | |||