usb_main.c

用 Hitex 工具软件开发 stm32 的例子

/********************************************************************
 * Project:    Tasking-STM32-Stick
 * File:       usb_main.c
 *
 * System:     Cortex ARMv7 32 Bit (STM32FRT)
 * Compiler:   Tasking Altuim VX Toolchain v2.01
 *
 * Date:       2007-08-20
 * Author:     [e-mail]
 *
 * Rights:     Hitex Development Tools GmbH
 *             Greschbachstr. 12
 *             D-76229 Karlsruhe
 ********************************************************************
 * Description:
 *
 * This file is part of the Tasking Example chain
 * The code is based on usage of the STmicro library functions
 * This is a small implementation of different features
 * The application runs in ARM mode with high optimization level.
 *
 ********************************************************************
 * History:
 *
 *    Revision 1.0    2007/08/20      Gn
 *    Initial revision
 ********************************************************************
 * This is a preliminary version.
 *
 * WARRANTY:  HITEX warrants that the media on which the SOFTWARE is
 * furnished is free from defects in materials and workmanship under
 * normal use and service for a period of ninety (90) days. HITEX entire
 * liability and your exclusive remedy shall be the replacement of the
 * SOFTWARE if the media is defective. This Warranty is void if failure
 * of the media resulted from unauthorized modification, accident, abuse,
 * or misapplication.
 *
 * DISCLAIMER:  OTHER THAN THE ABOVE WARRANTY, THE SOFTWARE IS FURNISHED
 * "AS IS" WITHOUT WARRANTY OF ANY KIND. HITEX DISCLAIMS ALL OTHER WARRANTIES,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * NEITHER HITEX NOR ITS AFFILIATES SHALL BE LIABLE FOR ANY DAMAGES ARISING
 * OUT OF THE USE OF OR INABILITY TO USE THE SOFTWARE, INCLUDING DAMAGES FOR
 * LOSS OF PROFITS, BUSINESS INTERRUPTION, OR ANY SPECIAL, INCIDENTAL, INDIRECT
 * OR CONSEQUENTIAL DAMAGES EVEN IF HITEX HAS BEEN ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGES.
 ********************************************************************/

#include "system.h"
#include "usb_lib.h"
#include "usb_main.h"
#include "usb_desc.h"


TaskInfo USBState = {FALSE, FALSE};
TaskInfo USB_ApplState = {FALSE, FALSE};
TaskInfo USB_ENUM = {FALSE, FALSE};
u8 USB_AppConfig[4] = {0xFF,0,0,0}; // Intervall, shape, size, step
u16 USBApplIndex = 0;
u8 USBApplSideIndex = 0;
u32 USBApplTime;


/*******************************************************************************
* Function Name  : USB_Cable_Config.
* Description    : Software Connection/Disconnection of USB Cable.
* Input          : NewState: new state.
* Output         : None.
* Return         : None
*******************************************************************************/

static u8 UnicodeToAscii( u8* Source, u8 *Destination)
{
   u8 Length;
   u8 Bytes;
   Bytes = *Source;
   /* Set pointer to first character */
   Source+=2; Bytes -=2;
   Length = (Bytes/2)-1;

   while ( Bytes > 0 )
   {
      *Destination++ = *Source;
      Source+=2;
      Bytes -=2;
   }
   *Destination = 0; /* Create a 0 terminated string */
   return Length +1;
}

void USB_Cable_Config (FunctionalState NewState)
{
   if (NewState != DISABLE)
   {
      GPIO_SetBits(GPIOD, GPIO_Pin_2);
   }
   else
   {
      GPIO_ResetBits(GPIOD, GPIO_Pin_2);
}
}

void USBStart (void)
{
   u32 tmpreg = 0;
   u8 PLLSet[5];
   /* switch to 48 MHz */

   /* disable UART receive interrupt */
   USART_ITConfig(USART3, (USART_IT_RXNE),DISABLE);
   /* clear pending bits */
   USART_ClearITPendingBit(USART3,USART_IT_RXNE);

   PLLSet[1] = 0x69;
   PLLSet[2] = 0x05;
   PLLSet[3] = 0x0A;

   //tmpreg &= (CFGR_HPRE_Reset_Mask | CFGR_PPRE2_Reset_Mask | CFGR_PPRE1_Reset_Mask);
   tmpreg = PLLSet[3] | (u32)PLLSet[2]<<8 | (u32)PLLSet[1]<<16;

   /* Select HSE as system clock source */
   RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE);

   RCC_PLLCmd(DISABLE);

   /* Store the new value */
   RCC->CFGR = tmpreg;

   RCC_PLLCmd(ENABLE);

   while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
   /* Select PLL as system clock source */
   RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

   /* Wait till PLL is used as system clock source */
   while(RCC_GetSYSCLKSource() != 0x08);
   /* reinit RS232 USRART3 */
   USART_Configuration();
   /* clear pending bits */
   USART_ClearITPendingBit(USART3,USART_IT_RXNE);
   /* enable UART receive interrupt */
   USART_ITConfig(USART3, (USART_IT_RXNE), ENABLE);

   /* Select USBCLK source */
   RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_Div1);

   USB_Init();
   USBState.enabled = TRUE;
}

void USBStop(void)
{
   u32 tmpreg = 0;
   // 0x39
   // 0x04
   // 0x0A
   /* reset the clocks */
}

void USBApplStart(void)
{
   USB_ApplState.enabled = TRUE;
   ReEntry.enabled = TRUE;
   ReEntryProcess = USBAppl;
}
void USBApplStop(void)
{
   USB_ApplState.enabled = FALSE;
   ReEntry.enabled = FALSE;
   ReEntryProcess = Dummy;
}

/* generate mouse message data */
void USBAppl (void)
{
   u8 newpos[4] = {0,0,0,0};
   u8 StepSize;
   u8 maxlength;  

   if (TimeTick > USBApplTime)
   {
      maxlength = 0x01<<(USB_AppConfig[2]+1);
      if (USB_AppConfig[3] == 0) 
         USB_AppConfig[3] = 1;
      StepSize = 0x01<<(USB_AppConfig[3]-1); // stepsize
      switch (USB_AppConfig[1]) {
       case USB_Shape_Line    :  /* 0 or 128 no movement, FF-126 / 127 max speed */
                                 USBApplIndex += StepSize;            // increment stepsize
                                 if (USBApplIndex > maxlength)        // check overrun
                                 {
                                    USBApplSideIndex++;
                                    if (USBApplSideIndex > 1)
                                       USBApplSideIndex = 0;
                                    USBApplIndex = 0;
                                 }
                                 switch (USBApplSideIndex) {
                                  case 0 : /* side a */  
                                           newpos[1] = 1*StepSize;
                                           newpos[2] = 0;
                                           break;
                                  case 1 : /* side b */  
                                           newpos[1] = (s8)(-1*StepSize);
                                           newpos[2] = 0;
                                           break;
                                  default : /* error */
                                           USBApplSideIndex = 0;
                                           break;
                                  }
                                 break;
       case USB_Shape_Triangle:  /* */
                                 USBApplIndex += StepSize;            // increment stepsize
                                 if (USBApplIndex > maxlength)        // check overrun
                                 {
                                    USBApplSideIndex++;
                                    if (USBApplSideIndex > 2)
                                       USBApplSideIndex = 0;
                                    USBApplIndex = 0;
                                 }
                                 switch (USBApplSideIndex) {
                                  case 0 : /* side a */  
                                           newpos[1] = 1*StepSize;
                                           newpos[2] = 0;
                                           break;