/**
* @brief DFU_LeaveDFUMode
* Handles the sub-protocol DFU leave DFU mode request (leaves DFU mode
* and resets device to jump to user loaded code).
* @param pdev: device instance
* @retval None
*/
void DFU_LeaveDFUMode(void *pdev)
{
Manifest_State = Manifest_complete;
if ((usbd_dfu_CfgDesc[(11 + (9 * USBD_ITF_MAX_NUM))]) & 0x04)
{
DeviceState = STATE_dfuMANIFEST_SYNC;
DeviceStatus[4] = DeviceState;
DeviceStatus[1] = 0;
DeviceStatus[2] = 0;
DeviceStatus[3] = 0;
return;
}
else
{
DeviceState = STATE_dfuMANIFEST_WAIT_RESET;
DeviceStatus[4] = DeviceState;
DeviceStatus[1] = 0;
DeviceStatus[2] = 0;
DeviceStatus[3] = 0;
/* Disconnect the USB device */
DCD_DevDisconnect (pdev);
/* DeInitilialize the MAL(Media Access Layer) */
MAL_DeInit();
/* Generate system reset to allow jumping to the user code */
NVIC_SystemReset();
/* This instruction will not be reached (system reset) */
return;
}
}
/**
* @brief DFU_Req_DETACH
* Handles the DFU DETACH request.
* @param pdev: device instance
* @param req: pointer to the request structure.
* @retval None.
*/
static void DFU_Req_DETACH(void *pdev, USB_SETUP_REQ *req)
{
if (DeviceState == STATE_dfuIDLE || DeviceState == STATE_dfuDNLOAD_SYNC
|| DeviceState == STATE_dfuDNLOAD_IDLE || DeviceState == STATE_dfuMANIFEST_SYNC
|| DeviceState == STATE_dfuUPLOAD_IDLE )
{
/* Update the state machine */
DeviceState = STATE_dfuIDLE;
DeviceStatus[0] = STATUS_OK;
DeviceStatus[1] = 0;
DeviceStatus[2] = 0;
DeviceStatus[3] = 0; /*bwPollTimeout=0ms*/
DeviceStatus[4] = DeviceState;
DeviceStatus[5] = 0; /*iString*/
wBlockNum = 0;
wlength = 0;
}
/* Check the detach capability in the DFU functional descriptor */
if ((usbd_dfu_CfgDesc[12 + (9 * USBD_ITF_MAX_NUM)]) & DFU_DETACH_MASK)
{
/* Perform an Attach-Detach operation on USB bus */
DCD_DevDisconnect (pdev);
DCD_DevConnect (pdev);
}
else
{
/* Wait for the period of time specified in Detach request */
USB_OTG_BSP_mDelay (req->wValue);
}
}
void USBPT_Init(USBH_DEV* pdev)
{
USBPTH_OutEPCnt = 0;
USBPT_Is_Active = 1;
USBPT_Dev = pdev;
for (uint8_t i = 0; i < USBPTH_MAX_LISTENERS; i++) {
USBPTH_Listeners[i].used = 0;
USBPTH_Listeners[i].hc = -1;
}
// most of the device event handlers are spawned within ISRs
// so we must order the priorities such that the other
// ISRs can be serviced while still inside the device event handlers
NVIC_SetPriority(SysTick_IRQn, 0);
NVIC_SetPriority(USART1_IRQn, 1);
NVIC_SetPriority(OTG_FS_IRQn, 2);
NVIC_SetPriority(OTG_HS_IRQn, 7);
USBH_InitCore(&USB_OTG_Core_host, USB_OTG_FS_CORE_ID);
USBH_InitDev(&USB_OTG_Core_host, USBPT_Dev, &USBPT_Host_cb);
USBD_Init(&USB_OTG_Core_dev, USB_OTG_HS_CORE_ID, &USBPT_Dev_cb);
DCD_DevDisconnect(&USB_OTG_Core_dev);
USBPT_printf("\r\n USB Passthrough Mode \r\n");
delay_ms(2000);
}
void USBD_USR_DeInit(USB_OTG_CORE_HANDLE *pdev)
{
#if defined( STM32F2XX ) || defined( STM32F4XX )
DCD_DevDisconnect(&USB_OTG_dev);
#else
USB_DISC_ON();
#endif
cdcStatus &= ~(CONTROL_LINE_DTR | CONTROL_LINE_RTS | USB_INITIALIZED);
}
static void PIOS_USBHOOK_USR_Init(void)
{
PIOS_USB_ChangeConnectionState(false);
#if 1
/* Force a physical disconnect/reconnect */
DCD_DevDisconnect(&pios_usb_otg_core_handle);
DCD_DevConnect(&pios_usb_otg_core_handle);
#endif
}
void USB_OTG_Setup()
{
DCD_DevDisconnect (&USB_OTG_dev);
USB_OTG_StopDevice(&USB_OTG_dev);
/*
USBH_Init(&USB_OTG_dev,
USB_OTG_HS_CORE_ID,
&USB_Host,
&hidCallbacks,
&callbacks);*/
}
int usb_close(void)
{
usb_periphcfg(DISABLE);
if (usb_ready == 1)
{
DCD_DevDisconnect(&USB_OTG_dev);
USBD_DeInit(&USB_OTG_dev);
USB_OTG_StopDevice(&USB_OTG_dev);
usb_ready = 0;
}
if (usb_attr->use_present_pin)
gpio_set_mode(usb_attr->present_port, usb_attr->present_pin, GPIO_INPUT_FLOATING);
return 1;
}
/**
* @brief Execute the demo application.
* @param None
* @retval None
*/
static void Demo_Exec(void)
{
RCC_ClocksTypeDef RCC_Clocks;
uint8_t togglecounter = 0x00;
while(1)
{
DemoEnterCondition = 0x00;
/* Reset UserButton_Pressed variable */
UserButtonPressed = 0x00;
/* Initialize LEDs to be managed by GPIO */
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED5);
STM_EVAL_LEDInit(LED6);
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
/* Turn OFF all LEDs */
STM_EVAL_LEDOff(LED4);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED5);
STM_EVAL_LEDOff(LED6);
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED4);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED3);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED5);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED6);
Delay(10);
togglecounter ++;
if (togglecounter == 0x10)
{
togglecounter = 0x00;
while (togglecounter < 0x10)
{
STM_EVAL_LEDToggle(LED4);
STM_EVAL_LEDToggle(LED3);
STM_EVAL_LEDToggle(LED5);
STM_EVAL_LEDToggle(LED6);
Delay(10);
togglecounter ++;
}
togglecounter = 0x00;
}
}
/* Waiting User Button is Released */
while (STM_EVAL_PBGetState(BUTTON_USER) == Bit_SET)
{}
UserButtonPressed = 0x00;
/* TIM4 channels configuration */
TIM4_Config();
/* Disable all Timer4 channels */
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
/* MEMS configuration */
LIS302DL_InitStruct.Power_Mode = LIS302DL_LOWPOWERMODE_ACTIVE;
LIS302DL_InitStruct.Output_DataRate = LIS302DL_DATARATE_100;
LIS302DL_InitStruct.Axes_Enable = LIS302DL_XYZ_ENABLE;
LIS302DL_InitStruct.Full_Scale = LIS302DL_FULLSCALE_2_3;
LIS302DL_InitStruct.Self_Test = LIS302DL_SELFTEST_NORMAL;
LIS302DL_Init(&LIS302DL_InitStruct);
/* Required delay for the MEMS Accelerometre: Turn-on time = 3/Output data Rate
= 3/100 = 30ms */
Delay(30);
DemoEnterCondition = 0x01;
/* MEMS High Pass Filter configuration */
LIS302DL_FilterStruct.HighPassFilter_Data_Selection = LIS302DL_FILTEREDDATASELECTION_OUTPUTREGISTER;
LIS302DL_FilterStruct.HighPassFilter_CutOff_Frequency = LIS302DL_HIGHPASSFILTER_LEVEL_1;
LIS302DL_FilterStruct.HighPassFilter_Interrupt = LIS302DL_HIGHPASSFILTERINTERRUPT_1_2;
LIS302DL_FilterConfig(&LIS302DL_FilterStruct);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
X_Offset = Buffer[0];
Y_Offset = Buffer[2];
Z_Offset = Buffer[4];
/* USB configuration */
Demo_USBConfig();
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{}
/* Waiting User Button is Released */
while (STM_EVAL_PBGetState(BUTTON_USER) == Bit_SET)
{}
/* Disable SPI1 used to drive the MEMS accelerometre */
SPI_Cmd(LIS302DL_SPI, DISABLE);
/* Disconnect the USB device */
DCD_DevDisconnect(&USB_OTG_dev);
USB_OTG_StopDevice(&USB_OTG_dev);
}
}
void PIOS_USBHOOK_Deactivate(void)
{
DCD_DevDisconnect(&pios_usb_otg_core_handle);
USBD_DeInit(&pios_usb_otg_core_handle);
USB_OTG_StopDevice(&pios_usb_otg_core_handle);
}
// 移除U盘设备
void usbd_CloseMassStorage(void)
{
DCD_DevDisconnect(&USB_OTG_dev);
}
void USBPT_Work()
{
if (USBPT_Has_Dev == 0)
{
if (HCD_IsDeviceConnected(&USB_OTG_Core_host) != 0)
{
USBPT_printf("USBPT Device Connecting \r\n");
if (USBH_Open_Channel( &USB_OTG_Core_host,
&(USBPT_Dev->Control.hc_num_in),
0x80,
USBPT_Dev->device_prop.address, // still 0 at this point
USBPT_Dev->device_prop.speed,
EP_TYPE_CTRL,
USBPT_Dev->Control.ep0size) == HC_OK
&&
USBH_Open_Channel( &USB_OTG_Core_host,
&(USBPT_Dev->Control.hc_num_out),
0x00,
USBPT_Dev->device_prop.address, // still 0 at this point
USBPT_Dev->device_prop.speed,
EP_TYPE_CTRL,
USBPT_Dev->Control.ep0size) == HC_OK
) {
DCD_DevConnect(&USB_OTG_Core_dev);
USBPT_Has_Dev = 1;
}
else
{
dbg_printf(DBGMODE_ERR, "USBPT Unable to allocate control EP HC \r\n");
}
}
else
{
return;
}
}
else
{
if (HCD_IsDeviceConnected(&USB_OTG_Core_host) == 0)
{
USBPT_printf("USBPT Device Disconnecting \r\n");
USBD_DeInit(&USB_OTG_Core_dev);
DCD_DevDisconnect(&USB_OTG_Core_dev);
USBPT_Has_Dev = 0;
for (uint8_t i = 0; i < USBPTH_MAX_LISTENERS; i++)
{
USBH_Free_Channel(&USB_OTG_Core_host, &(USBPTH_Listeners[i].hc));
}
USBH_Free_Channel(&USB_OTG_Core_host, &(USBPT_Dev->Control.hc_num_out));
USBH_Free_Channel(&USB_OTG_Core_host, &(USBPT_Dev->Control.hc_num_in));
}
}
for (uint8_t i = 0; i < USBPTH_MAX_LISTENERS; i++)
{
USBPTH_HC_EP_t* pl = &USBPTH_Listeners[i];
int8_t hc = USBPTH_Listeners[i].hc;
if (hc >= 0) // if listener is actually allocated
{
USBH_EpDesc_TypeDef* epDesc = pl->epDesc;
uint8_t epnum = epDesc->bEndpointAddress;
uint8_t epType = 0;
USBPT_GeneralInDataLen = epDesc->wMaxPacketSize;
// try to send read tokens only on even frames
if (USB_OTG_IsEvenFrame(&USB_OTG_Core_host) == 0) continue;
dbg_trace();
// attempt to start the read, check the read type first
if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_INTR) {
epType = EP_TYPE_INTR;
USBH_InterruptReceiveData(&USB_OTG_Core_host, USBPT_GeneralInData, USBPT_GeneralInDataLen, hc);
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_BULK) {
epType = EP_TYPE_BULK;
USBH_BulkReceiveData(&USB_OTG_Core_host, USBPT_GeneralInData, USBPT_GeneralInDataLen, hc);
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_ISOC) {
epType = EP_TYPE_ISOC;
USBH_IsocReceiveData(&USB_OTG_Core_host, USBPT_GeneralInData, USBPT_GeneralInDataLen, hc);
}
// now we wait for a reply, or maybe there isn't one
USBH_Status status;
char sent = 0;
delay_1ms_cnt = 100;
do
{
URB_STATE us = HCD_GetURB_State(&USB_OTG_Core_host, hc);
if (us == URB_DONE)
{
// data was indeed received
// print it to the serial port for monitoring
USBPT_printf("USBPT:IN:EP0x%02X:", epnum);
for (uint16_t c = 0; c < USBPT_GeneralInDataLen; c++) {
USBPT_printf(" 0x%02X", USBPT_GeneralInData[c]);
}
USBPT_printf("\r\n");
// relay the data to the host
DCD_EP_Tx(&USB_OTG_Core_dev, epnum, USBPT_GeneralInData, USBPT_GeneralInDataLen);
sent = 1;
break;
}
else if (us == URB_ERROR) {
dbg_printf(DBGMODE_ERR, "DataIn Error on EP 0x%02X \r\n", epnum);
break;
}
else if (us == URB_STALL) {
dbg_printf(DBGMODE_ERR, "DataIn Stalled EP 0x%02X \r\n", epnum);
break;
}
else if (us == URB_NOTREADY) {
// NAK, no data
break;
}
}
while (delay_1ms_cnt > 0);
if (delay_1ms_cnt == 0) {
dbg_printf(DBGMODE_ERR, "DataIn Read Timed Out EP 0x%02X \r\n", epnum);
}
}
}
}
