Subversion Repositories openrisc

/********************* (C) COPYRIGHT 2007 RAISONANCE S.A.S. *******************/

/**

*

* @file     Util.c

* @brief    Various utilities  for STM32 CircleOS.

* @author   RT

* @date     07/2007

*

**/

/******************************************************************************/

/* Includes ------------------------------------------------------------------*/

#include "circle.h"

#include "adc.h"

/// @cond Internal

/* Private defines -----------------------------------------------------------*/

#define  GPIO_USB_PIN   GPIO_Pin_1

#define  GPIOx_USB      GPIOA

#define  OsVersion      "V 1.7"    /*!< CircleOS version string. */

/* Private typedef -----------------------------------------------------------*/

enum eSpeed CurrentSpeed;

/* Private variables ---------------------------------------------------------*/

RCC_ClocksTypeDef    RCC_ClockFreq;

int                  dummycounter   = 0;

u8                   fTemperatureInFahrenheit = 0;  /*!< 1 : Fahrenheit, 0 : Celcius (default). */

/* Private function prototypes -----------------------------------------------*/

static void _int2str( char* ptr, s32 X, u16 digit, int flagunsigned, int fillwithzero );

/* Private functions ---------------------------------------------------------*/

/*******************************************************************************

*

*                    _int2str

*

*******************************************************************************/

/**

*

*  Translate a 32 bit word into a string.

*

*  @param[in,out] ptr            A pointer to a string large enough to contain

*                                the translated 32 bit word.

*  @param[in]     X              The 32 bit word to translate.

*  @param[in]     digit          The amount of digits wanted in the result string.

*  @param[in]     flagunsigned   Is the input word unsigned?

*  @param[in]     fillwithzero   Fill with zeros or spaces.

*

**/

/******************************************************************************/

static void _int2str( char* ptr, s32 X, u16 digit, int flagunsigned, int fillwithzero )

   {

   u8    c;

   u8    fFirst   = 0;

   u8    fNeg     = 0;

   u32   DIG      = 1;

   int   i;

   for( i = 1; i < digit; i++ )

      {

      DIG *= 10;

      }

   if( !flagunsigned && ( X < 0 ) )

      {

      fNeg = 1;

      X    = -X;

      }

   u32 r = X;

   for( i = 0; i < digit; i++, DIG /= 10 )

      {

      c  = (r/DIG);

      r -= (c*DIG);

      if( fillwithzero || fFirst || c || ( i == ( digit - 1 ) ) )

         {

         if( ( fFirst == 0 ) && !flagunsigned )

            {

            *ptr++ = fNeg ? '-' : ' ';

            }

         *ptr++ = c + 0x30;

         fFirst = 1;

         }

       else

         {

         *ptr++ = ' ';

         }

      }

   *ptr++ = 0;

   }

/* Public functions for CircleOS ---------------------------------------------*/

/*******************************************************************************

*

*                    delay_unit

*

*******************************************************************************/

/**

*

*  Called by starting_delay().

*

*  @note Not in main.c to avoid inlining.

*

**/

/******************************************************************************/

void delay_unit( void )

   {

   dummycounter++;

   }

/// @endcond

/* Public functions ----------------------------------------------------------*/

/*******************************************************************************

*

*                    UTIL_GetBat

*

*******************************************************************************/

/**

*

*  Return the batterie tension in mV.

*

*  @return Batterie tension in mV.

*

**/

/******************************************************************************/

u16 UTIL_GetBat( void )

   {

#ifdef _ADC

   u16 vbat;

   // Measure VBAT

   vbat = ADC_ConvertedValue[0];  //*( (u16*)ADC1_DR_Address );      // <=== note changed 

   vbat = vbat & 0xFFF;

   vbat = ( vbat * VDD_VOLTAGE_MV ) / 0x1000;

   return vbat;

#else

   return 0;

#endif

   }

/*******************************************************************************

*

*                    UTIL_GetTemp

*

*******************************************************************************/

/**

*

*  Return the Temperature: degrees / 10, Celcius or Fahrenheit.

*

*  @return The temperature (C or F) (averaging of several channels).

*

**/

/******************************************************************************/

u16 UTIL_GetTemp( void )

   {

   s32 temp;

   s16 *p=&ADC_ConvertedValue[1];  //intent; point to first of 8 results from same source - use a short name for it!

   // Measure temp

   //temp = ADC_ConvertedValue[1];//*( (u16*)ADC1_DR_Address ); 

   temp = (p[0]+p[1]+p[2]+p[3]+p[4]+p[5]+p[6]+p[7])/8; //take avg of burst of 8 temp reads. may only help reject hi freq noise a bit

                                                       //will not help reduce mains ripple because conversions are SO FAST!!

   temp = temp & 0xFFF;

   temp = ( temp * VDD_VOLTAGE_MV ) / 0x1000;  //finds mV  

   temp = (((1400-temp)*100000)/448)+25000;  //gives approx temp x 1000 degrees C

   //Fahrenheit = 32 + 9 / 5 * Celsius

   if ( fTemperatureInFahrenheit )

      {

      temp = 32000 + (9 * temp) / 5 ;

      }

   return temp / 100;

   }

/*******************************************************************************

*

*                    UTIL_SetTempMode

*

*******************************************************************************/

/**

*

*  Set the temperature mode (F/C)

*

*  @param[in]     mode       0: Celcius, 1: Fahrenheit

*

**/

/******************************************************************************/

void UTIL_SetTempMode ( int mode )

   {

   fTemperatureInFahrenheit = mode;

   return;

   }

/*******************************************************************************

*

*                    UTIL_GetUsb

*

*******************************************************************************/

/**

*

*  Return the USB connexion state.

*

*  @return The USB connexion state.

*

**/

/******************************************************************************/

u8 UTIL_GetUsb( void )

   {

   GPIO_InitStructure.GPIO_Pin   =  GPIO_USB_PIN;

   GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;

   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

   GPIO_Init( GPIOx_USB, &GPIO_InitStructure );

   return ( GPIO_ReadInputDataBit( GPIOx_USB, GPIO_USB_PIN ) == Bit_SET );

   }

/*******************************************************************************

*

*                   UTIL_uint2str

*

*******************************************************************************/

/**

*

*  Convert an <b>unsigned</b> integer into a string.

*

*  @param [out]  ptr    The output string.

*  @param [in]   X      The unsigned value to convert.

*  @param [in]   digit  The number of digits in the output string.

*  @param [in]   fillwithzero  \li 0   fill with blanks.

*                              \li 1   fill with zeros.

*

**/

/********************************************************************************/

void UTIL_uint2str( char* ptr, u32 X, u16 digit, int fillwithzero )

   {

   _int2str( ptr, X, digit, 1, fillwithzero);

   }

/*******************************************************************************

*

*                   UTIL_int2str

*

*******************************************************************************/

/**

*

*  Convert a <b>signed</b> integer into a string.

*

*  @param [out]  ptr    The output string.

*  @param [in]   X      The unsigned value to convert.

*  @param [in]   digit  The number of digits in the output string.

*  @param [in]   fillwithzero  \li 0   fill with blanks.

*                              \li 1   fill with zeros.

*

**/

/******************************************************************************/

void UTIL_int2str( char* ptr, s32 X, u16 digit, int fillwithzero )

   {

   _int2str( ptr, X, digit, 0, fillwithzero);

   }

/*******************************************************************************

*

*                                UTIL_SetPll

*

*******************************************************************************/

/**

*

*  Set clock frequency (lower to save energy)

*

*  @param [in]   speed  New clock speed from very low to very fast.

*

**/

/******************************************************************************/

void UTIL_SetPll( enum eSpeed speed )

   {

   /* Select PLL as system clock source */

   RCC_SYSCLKConfig( RCC_SYSCLKSource_HSI );

   /* Enable PLL */

   RCC_PLLCmd( DISABLE );

   if( ( speed < SPEED_VERY_LOW ) || ( speed > SPEED_VERY_HIGH ) )

      {

      speed = SPEED_MEDIUM;

      }

   CurrentSpeed = speed;

   switch( speed )

      {

      // 18 MHz

      case SPEED_VERY_LOW  :

         /* PLLCLK = 6MHz * 3 = 18 MHz */

         RCC_PLLConfig( RCC_PLLSource_HSE_Div2, RCC_PLLMul_3 );

         break;

      // 24MHz

      case SPEED_LOW       :

         /* PLLCLK = 12MHz * 2 = 24 MHz */

         RCC_PLLConfig( RCC_PLLSource_HSE_Div1, RCC_PLLMul_2 );

         break;

      // 36MHz

      case SPEED_MEDIUM    :

      default              :

         /* PLLCLK = 12MHz * 3 = 36 MHz */

         RCC_PLLConfig( RCC_PLLSource_HSE_Div1, RCC_PLLMul_3 );

         break;

      // 48MHz

      case SPEED_HIGH      :

         /* PLLCLK = 12MHz * 4 = 48 MHz */

         RCC_PLLConfig( RCC_PLLSource_HSE_Div1, RCC_PLLMul_4 );

         break;

      // 72MHz

      case SPEED_VERY_HIGH :

         /* PLLCLK = 12MHz * 6 = 72 MHz */

         RCC_PLLConfig( RCC_PLLSource_HSE_Div1, RCC_PLLMul_6 );

         break;

      }

   /* Enable PLL */

   RCC_PLLCmd( ENABLE );

   /* Wait till PLL is ready */

   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 )

      { ; }

   /* This function fills a RCC_ClocksTypeDef structure with the current frequencies

     of different on chip clocks (for debug purpose) */

   RCC_GetClocksFreq( &RCC_ClockFreq );

   }

/*******************************************************************************

*

*                                UTIL_GetPll

*

*******************************************************************************/

/**

*

*  Get clock frequency

*

*  @return   Current clock speed from very low to very fast.

*

**/

/******************************************************************************/

enum eSpeed UTIL_GetPll( void )

   {

   return CurrentSpeed;

   }

/*******************************************************************************

*

*                                UTIL_GetVersion

*

*******************************************************************************/

/**

*

*  Get CircleOS version.

*

*  @return  A pointer to a string containing the CircleOS version.

*

**/

/******************************************************************************/

const char* UTIL_GetVersion( void )

   {

   return OsVersion;

   }

/*******************************************************************************

*

*                                UTIL_ReadBackupRegister

*

*******************************************************************************/

/**

*

*  Reads data from the specified Data Backup Register.

*

*  @param[in]  BKP_DR   Specifies the Data Backup Register. This parameter can be BKP_DRx where x:[1, 10]

*

*  @return  The content of the specified Data Backup Register.

*

**/

/******************************************************************************/

u16 UTIL_ReadBackupRegister( u16 BKP_DR )

   {

  return (*(vu16 *)( BKP_BASE + 4 * BKP_DR ) );

   }

/*******************************************************************************

*

*                                UTIL_WriteBackupRegister

*

*******************************************************************************/

/**

*

*  Writes data to the specified Data Backup Register.

*

*  @param[in]  BKP_DR   Specifies the Data Backup Register. This parameter can be BKP_DRx where x:[1, 10]

*  @param[in]  Data     The data to write.

*

**/

/********************************************************************************/

void UTIL_WriteBackupRegister( u16 BKP_DR, u16 Data )

   {

  *(vu16 *)( BKP_BASE + 4 * BKP_DR ) = Data;

   }

/*******************************************************************************

*

*                                UTIL_SetIrqHandler

*

*******************************************************************************/

/**

*

*  Redirect an IRQ handler.

*

*  @param[in]  Offs   Address in the NVIC table

*  @param[in]  pHDL   Pointer to the handler.

*

**/

/********************************************************************************/

void UTIL_SetIrqHandler( int Offs, tHandler pHDL )

   {

   if ( (Offs >= 8) && (Offs<0x100) )

      *(tHandler *)( CIRCLEOS_RAM_BASE + Offs ) = pHDL;

   }

/*******************************************************************************

*

*                                UTIL_GetIrqHandler

*

*******************************************************************************/

/**

*

*  Get the current IRQ handler.

*  Since (V1.6) the vector table is relocated in RAM, the vectors can be easily modified

*  by the applications.

*

*  @param[in]  Offs   Address in the NVIC table

*  @return  A pointer to the current handler.

*

**/

/********************************************************************************/

tHandler UTIL_GetIrqHandler( int Offs )

   {

   if ( (Offs >= 8) && (Offs<0x100) )

      return *(tHandler *)( CIRCLEOS_RAM_BASE + Offs );

   }

/*******************************************************************************

*

*                                UTIL_SetSchHandler

*

*******************************************************************************/

/**

*

*  Redirect a SCHEDULER handler.

*  Set the current SCHEDULER handler. With UTIL_GetSchHandler(), these functions

*  allow to take the control of the different handler. You can:

*        - replace them (get-Set)by your own handler

*        - disable a handler: UTIL_SetSchHandler(Ix,0);

*        - create a new handler (using the unused handlers).

*  See scheduler.c to understand further...

*

*  @param[in]  Ix   ID if the SCH Handler

*  @param[in]  pHDL   Pointer to the handler.

*

**/

/********************************************************************************/

void UTIL_SetSchHandler( enum eSchHandler Ix, tHandler pHDL )

   {

   if (Ix<SCH_HDL_MAX)

      SchHandler[Ix] = pHDL;

   }

/*******************************************************************************

*

*                                UTIL_GetSchHandler

*

*******************************************************************************/

/**

*

*  Get the current SCHEDULER handler. With UTIL_SetSchHandler(), these functions

*  allow to take the control of the different handler. You can:

*        - replace them (get-Set)by your own handler

*        - disable a handler: UTIL_SetSchHandler(Ix,0);

*        - create a new handler (using the unused handlers).

*  See scheduler.c to understand further...

*

*  @param[in]  Ix   ID is the SCH Handler

*  @return  A pointer to the current handler.

*

**/

/********************************************************************************/

tHandler UTIL_GetSchHandler( enum eSchHandler Ix )

   {

   if ( Ix<SCH_HDL_MAX )

      return SchHandler [Ix] ;

   }