void cat_driver_stop(void)
{
// Stop driver
USBD_DeInit(&USB_OTG_dev);
printf("cat driver stopped\n\r");
}
/**
* @brief USBD_Init
* Initializes the device stack and load the class driver
* @param pdev: device instance
* @param class_cb: Class callback structure address
* @param usr_cb: User callback structure address
* @retval None
*/
void USBD_Init(USB_CORE_HANDLE *pdev,
USBD_DEVICE *pDevice,
USBD_Class_cb_TypeDef *class_cb,
USBD_Usr_cb_TypeDef *usr_cb)
{
/* Hardware Init */
USB_BSP_Init(pdev);
USBD_DeInit(pdev);
/*Register class and user callbacks */
pdev->dev.class_cb = class_cb;
pdev->dev.usr_cb = usr_cb;
pdev->dev.usr_device = pDevice;
/* Update the serial number string descriptor with the data from the unique ID*/
Get_SerialNum();
/* set USB DEVICE core params */
DCD_Init(pdev);
/* Upon Init call usr callback */
pdev->dev.usr_cb->Init();
/* Enable Interrupts */
USB_BSP_EnableInterrupt(pdev);
/* Enable the pull-up */
#ifdef INTERNAL_PULLUP
DCD_DevConnect(pdev);
#else
USB_BSP_DevConnect(pdev);
#endif
}
/**
* @brief USBD_Init
* Initailizes the device stack and load the class driver
* @param pdev: device instance
* @param core_address: USB OTG core ID
* @param class_cb: Class callback structure address
* @param usr_cb: User callback structure address
* @retval None
*/
void USBD_Init(USB_OTG_CORE_HANDLE *pdev,
USB_OTG_CORE_ID_TypeDef coreID,
USBD_DEVICE *pDevice,
USBD_Class_cb_TypeDef *class_cb,
USBD_Usr_cb_TypeDef *usr_cb)
{
/* Hardware Init */
USB_OTG_BSP_Init(pdev);
USBD_DeInit(pdev);
/*Register class and user callbacks */
pdev->dev.class_cb = class_cb;
pdev->dev.usr_cb = usr_cb;
pdev->dev.usr_device = pDevice;
/* set USB OTG core params */
DCD_Init(pdev , coreID);
/* Upon Init call usr callback */
pdev->dev.usr_cb->Init();
/* Enable Interrupts */
USB_OTG_BSP_EnableInterrupt(pdev);
}
void pyb_usb_dev_deinit(void) {
usb_device_t *usb_dev = &usb_device;
if (usb_dev->enabled) {
USBD_Stop(&usb_dev->hUSBDDevice);
USBD_DeInit(&usb_dev->hUSBDDevice);
usb_dev->enabled = false;
}
}
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;
}
void io_usb_enable(unsigned char enabled) {
if (enabled) {
os_memset(&USBD_Device, 0, sizeof(USBD_Device));
/* Init Device Library */
USBD_Init(&USBD_Device, &HID_Desc, 0);
/* Register the HID class */
USBD_RegisterClass(&USBD_Device, &USBD_CUSTOM_HID);
USBD_CUSTOM_HID_RegisterInterface(&USBD_Device, &USBD_CustomHID_template_fops);
/* Start Device Process */
USBD_Start(&USBD_Device);
}
else {
USBD_DeInit(&USBD_Device);
}
}
void USB_power(unsigned char enabled) {
os_memset(&USBD_Device, 0, sizeof(USBD_Device));
if (enabled) {
os_memset(&USBD_Device, 0, sizeof(USBD_Device));
/* Init Device Library */
USBD_Init(&USBD_Device, (USBD_DescriptorsTypeDef*)&HID_Desc, 0);
/* Register the HID class */
USBD_RegisterClass(&USBD_Device, (USBD_ClassTypeDef*)&USBD_HID);
/* Start Device Process */
USBD_Start(&USBD_Device);
}
else {
USBD_DeInit(&USBD_Device);
}
}
/**
* @brief Execute the demo application.
* @param None
* @retval None
*/
static void Demo_Exec(void)
{
uint8_t togglecounter = 0x00;
/* Initialize Accelerometer MEMS*/
if(BSP_ACCELERO_Init() != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
while(1)
{
DemoEnterCondition = 0x00;
/* Reset UserButton_Pressed variable */
UserButtonPressed = 0x00;
/* Configure LEDs to be managed by GPIO */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_LED_Init(LED5);
BSP_LED_Init(LED6);
/* SysTick end of count event each 10ms */
SystemCoreClock = HAL_RCC_GetHCLKFreq();
SysTick_Config(SystemCoreClock / 100);
/* Turn OFF all LEDs */
BSP_LED_Off(LED4);
BSP_LED_Off(LED3);
BSP_LED_Off(LED5);
BSP_LED_Off(LED6);
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
HAL_Delay(10);
/* Toggle LED4 */
BSP_LED_Toggle(LED3);
HAL_Delay(10);
/* Toggle LED4 */
BSP_LED_Toggle(LED5);
HAL_Delay(10);
/* Toggle LED4 */
BSP_LED_Toggle(LED6);
HAL_Delay(10);
togglecounter ++;
if (togglecounter == 0x10)
{
togglecounter = 0x00;
while (togglecounter < 0x10)
{
BSP_LED_Toggle(LED4);
BSP_LED_Toggle(LED3);
BSP_LED_Toggle(LED5);
BSP_LED_Toggle(LED6);
HAL_Delay(10);
togglecounter ++;
}
togglecounter = 0x00;
}
}
/* Waiting User Button is Released */
while (BSP_PB_GetState(BUTTON_KEY) != KEY_NOT_PRESSED)
{}
UserButtonPressed = 0x00;
/* TIM4 channels configuration */
TIM4_Config();
DemoEnterCondition = 0x01;
/* USB configuration */
Demo_USBConfig();
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{}
/* Waiting User Button is Released */
while (BSP_PB_GetState(BUTTON_KEY) != KEY_NOT_PRESSED)
{}
/* Disconnect the USB device */
USBD_Stop(&hUSBDDevice);
USBD_DeInit(&hUSBDDevice);
if(HAL_TIM_PWM_DeInit(&htim4) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
}
}
/**
* @brief DeInit USBD
* @param None.
* @retval USBD status.
*/
USBD_ErrorTypdef USBDSTOR_Stop(void)
{
USBD_DeInit(&USBD_Device);
return USBD_ERROR_NONE;
}
/**
* @brief Manages Menu Process.
* @param None
* @retval None
*/
void Menu_Process(void)
{
tsl_user_status_t tsl_status;
/* background menu: entry menu */
switch(menu_state)
{
case BACKGROUND_MENU:
BSP_EPD_SetFont(&Font16);
BSP_EPD_DrawImage(0, 0, 72, 172, Background_pic);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"STM32L053", RIGHT_MODE);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(87, 8, (uint8_t*)"DISCOVERY", LEFT_MODE);
BSP_EPD_DisplayStringAt(71, 3, (uint8_t*)"DEMONSTRATION", LEFT_MODE);
BSP_EPD_DisplayStringAt(94, 0, (uint8_t*)"V1.0.0", LEFT_MODE);
BSP_EPD_RefreshDisplay();
HAL_Delay(2000);
menu_state = MAIN_MENU;
break;
/* main menu */
case MAIN_MENU:
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_DrawImage(5, 0, 48, 48, Mouse_pic);
BSP_EPD_DrawImage(130, 0, 48, 26, Batery_pic);
BSP_EPD_DrawImage(60, 0, 16, 60, Slider_pic);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"STM32L053 Demonstration", CENTER_MODE);
BSP_EPD_DisplayStringAt(56, 7, (uint8_t*)"USE LTS to", LEFT_MODE);
BSP_EPD_DisplayStringAt(53, 4, (uint8_t*)"Select Demo", LEFT_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_RefreshDisplay();
menu_state = MODULE_MENU;
break;
case MODULE_MENU:
MyLinRots[0].p_Data->Position = 0;
/* Execute STMTouch Driver state machine */
tsl_status = tsl_user_Exec();
if(tsl_status != TSL_USER_STATUS_BUSY)
{
if(LINEAR_DETECT)
{
/* USB Module Menu*****************************************************/
if((LINEAR_POSITION >= 1 ) && (LINEAR_POSITION <= 127))
{
menu_state = USB_MENU;
}
/* PWR Module Menu*****************************************************/
else if ((LINEAR_POSITION >= 128 ) && (LINEAR_POSITION < 255))
{
menu_state = PWR_MENU;
}
}
}
break;
case USB_MENU:
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_DrawImage(13, 4, 28, 146, FullSlider_pic);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"STM32L053 USB Demo", CENTER_MODE);
BSP_EPD_DisplayStringAt(15, 1, (uint8_t*)"LEFT RIGHT UP DOWN", LEFT_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_DrawRect(145, 0, 26, 4);
BSP_EPD_SetFont(&Font8);
BSP_EPD_DisplayStringAt(146, 1, (uint8_t*)"B1 Ex", LEFT_MODE);
BSP_EPD_RefreshDisplay();
MyLinRots[0].p_Data->Position = 0;
/* USB Clock config */
USBClock_Enable();
/* USB Initialization */
BSP_USB_Init();
ButtonPressed = 0;
while(ButtonPressed == 0)
{
/* Execute STMTouch Driver state machine */
tsl_status = tsl_user_Exec();
if(tsl_status != TSL_USER_STATUS_BUSY)
{
USB_process(tsl_status);
}
}
/* USB Clock disable */
USBClock_Disable();
/* USB DeInitialize */
USBD_DeInit(&USBD_Device);
ButtonPressed = 0;
menu_state = MAIN_MENU;
break;
case PWR_MENU:
BSP_LED_Off(LED4);
BSP_LED_Off(LED3);
/* Power Main IDD Menu ****************************************************/
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_DrawImage(30, 0, 16, 60, Slider_pic);
BSP_EPD_DrawImage(3, 4, 32, 32, Run_pic);
BSP_EPD_DrawImage(50, 4, 32, 29, Sleep_pic);
BSP_EPD_DrawImage(90, 4, 32, 29, LPSleep_pic);
BSP_EPD_DrawImage(130, 4, 32, 32, Stop_pic);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"STM32L053 IDD Demo", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_DrawRect(113, 0, 57, 3);
BSP_EPD_SetFont(&Font8);
BSP_EPD_DisplayStringAt(116, 1, (uint8_t*)"B1 to Exit", LEFT_MODE);
BSP_EPD_RefreshDisplay();
MyLinRots[0].p_Data->Position = 0;
MyLinRots[0].p_Data->StateId = TSL_STATEID_RELEASE;
ButtonPressed = 0;
tsl_status = tsl_user_Exec();
while((ButtonPressed == 0) && ((MyLinRots[0].p_Data->StateId != TSL_STATEID_DETECT) || (LINEAR_POSITION == 0)) && (!LINEAR_POSITION))
{
tsl_status = tsl_user_Exec();
}
if(MyLinRots[0].p_Data->StateId == TSL_STATEID_DETECT)
{
/* Run mode menu ********************************************************/
if((LINEAR_POSITION >= 1 ) && (LINEAR_POSITION <= 64))
{
Idd_Run_process();
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"MCU in Run Mode", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_DisplayStringAt(8, 7, (uint8_t*)"Current consumption", LEFT_MODE);
BSP_EPD_DisplayStringAt(8, 3, str, LEFT_MODE);
BSP_EPD_DrawRect(113, 0, 57, 4);
BSP_EPD_SetFont(&Font8);
BSP_EPD_DisplayStringAt(116, 1, (uint8_t*)"B1 to Exit", LEFT_MODE);
BSP_EPD_RefreshDisplay();
}
/* Sleep mode menu ******************************************************/
else if ((LINEAR_POSITION >= 65 ) && (LINEAR_POSITION <= 127))
{
/* Display before entering Sleep mode */
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"MCU in Sleep Mode", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_RefreshDisplay();
/* Execute Sleep */
Idd_Sleep_process();
/* Display after wakeup from Sleep mode */
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"Wake up from Sleep", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_DisplayStringAt(8, 7, (uint8_t*)"Current consumption", LEFT_MODE);
BSP_EPD_DisplayStringAt(8, 3, str, LEFT_MODE);
BSP_EPD_DrawRect(113, 0, 57, 4);
BSP_EPD_SetFont(&Font8);
BSP_EPD_DisplayStringAt(116, 1, (uint8_t*)"B1 to Exit", LEFT_MODE);
BSP_EPD_RefreshDisplay();
}
/* LP Sleep menu ********************************************************/
else if ((LINEAR_POSITION >= 128 ) && (LINEAR_POSITION <= 191))
{
/* Display before entering LP Sleep mode */
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"MCU in LPSleep Mode", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_RefreshDisplay();
/* Execute LP SLEEP */
Idd_LPSleep_process();
/* Display after wakeup from LP Sleep mode */
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"Wake up from LPSleep", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_DisplayStringAt(8, 7, (uint8_t*)"Current consumption", LEFT_MODE);
BSP_EPD_DisplayStringAt(8, 3, str, LEFT_MODE);
BSP_EPD_DrawRect(113, 0, 57, 4);
BSP_EPD_SetFont(&Font8);
BSP_EPD_DisplayStringAt(116, 1, (uint8_t*)"B1 to Exit", LEFT_MODE);
BSP_EPD_RefreshDisplay();
}
/* Stop menu ************************************************************/
else
{
/* Display before entering Stop mode */
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_SetFont(&Font12);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"MCU in Stop Mode", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_RefreshDisplay();
/* Execute STOP Process */
Idd_Stop_process();
/* Display after wakeup from Stop mode */
BSP_EPD_Clear(EPD_COLOR_WHITE);
BSP_EPD_DisplayStringAt(0, 13, (uint8_t*)"Wake up from STOP", CENTER_MODE);
BSP_EPD_DrawRect(2, 12, 166, 5);
BSP_EPD_DisplayStringAt(8, 7, (uint8_t*)"Current consumption", LEFT_MODE);
BSP_EPD_DisplayStringAt(8, 3, str, LEFT_MODE);
BSP_EPD_DrawRect(113, 0, 57, 4);
BSP_EPD_SetFont(&Font8);
BSP_EPD_DisplayStringAt(116, 1, (uint8_t*)"B1 to Exit", LEFT_MODE);
BSP_EPD_RefreshDisplay();
}
ButtonPressed = 0;
while(ButtonPressed == 0)
{
}
menu_state = PWR_MENU;
}
else /* BUTTON_KEY != 0 */
{
menu_state = MAIN_MENU;
}
break;
default:
break;
}
}
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);
}
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);
}
}
}
}
void usbDeInit(void)
{
USBD_DeInit(&USB_OTG_dev);
}
void usb_device_deinit(void)
{
USBD_DeInit(&hUsbDeviceFS);
}
void usb_serial_deinit(void)
{
good=0;
USBD_DeInit(&USB_OTG_dev);
USB_OTG_StopDevice(&USB_OTG_dev);
}
