Subversion Repositories openrisc

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

/**

*

* @file     buzzer.c

* @brief    Buzzer dedicated functions with RTTTL format support.

* @author   IB

* @date     07/2007

*

**/

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

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

#include "circle.h"

/// @cond Internal

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

/*! Octaves */

enum eOctave  {

      OCT_440  = 0,  /*!< o = 5 */

      OCT_880  = 1,  /*!< o = 6 */

      OCT_1760 = 2,  /*!< o = 7 */

      OCT_3520 = 3,  /*!< o = 8 */

      OCT_7040 = 4   /*!< o = 9 */

      } octave;

/*! Notes */

enum eNotes  {

      NOTE_PAUSE = 0,    /*!< P  */

      NOTE_LA    = 1,    /*!< A  */

      NOTE_LA_H  = 8+1,  /*!< A# */

      NOTE_SI    = 2,    /*!< B  */

      NOTE_DO    = 3,    /*!< C  */

      NOTE_DO_H  = 8+3,  /*!< C# */

      NOTE_RE    = 4,    /*!< D  */

      NOTE_RE_H  = 8+4,  /*!< D# */

      NOTE_MI    = 5,    /*!< E  */

      NOTE_FA    = 6,    /*!< F  */

      NOTE_FA_H  = 8+6,  /*!< F# */

      NOTE_SOL   = 7,    /*!< G  */

      NOTE_SOL_H = 8+7   /*!< G# */

      } note;

/* Private define ------------------------------------------------------------*/

#define BUZZER_SHORTBEEP_DURATION   100

#define BUZZER_LONGBEEP_DURATION    1000

#define RTTTL_SEP                   ':'

/* Private macro -------------------------------------------------------------*/

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

int                              buzz_counter         = 0;

int                              buzz_in_progress     = 0;

static TIM_TimeBaseInitTypeDef   TIM_TimeBaseStructure;

static TIM_OCInitTypeDef         TIM_OCInitStructure;

u16                              CCR_Val              = 0x2EE0;

enum BUZZER_mode                 Buzzer_Mode          = BUZZER_UNDEF;

u32                              Buzzer_Counter       = 0;

// For the melody.

const u8*                        CurrentMelody        = 0;

const u8*                        CurrentMelodySTART   = 0;

u8                               DefaultOctave        = OCT_880;

u8                               DefaultDuration      = 4;

u16                              DefaultBeats         = 63;

u16 Note_Freq [16] = {

   0,    //pause

   440,  //A=LA

   494,  //B=SI

   524,  //C=DO

   588,  //D=RE

   660,  //E=MI

   698,  //F=FA

   784,  //G=SOL

   0,    // "8+n" for "NOTE#"

   466,  //A#=LA#

   0,

   544,  //C#=DO#

   622,  //D#=RE#

   0,

   740,  //F#=FA#

   830   //G#=SOL#

   };

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

static void PlayMusic( void );

static void BUZZER_SetFrequency( u16 freq );

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

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

*

*                                PlayMusic

*

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

/**

*

*  Play the next note of the current melody.

*

**/

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

static void PlayMusic( void )

   {

   u8 duration = DefaultDuration;

   u8 c;

   // Discard blank characters

   while ( *CurrentMelody == ' ')

      {

      CurrentMelody++;

      }

   // Check whether a duration is present.

   if ( (*CurrentMelody > '0') && (*CurrentMelody < '9') )

      {

      duration = *CurrentMelody++ - '0';

      if ( (*CurrentMelody > '0') && (*CurrentMelody < '9') )

         {

         duration *= 10;

         duration += (*CurrentMelody++ - '0');

         }

      }

   Buzzer_Counter = ( (32/duration) * 256L * 32L) / DefaultBeats;

   Buzzer_Counter*= (RCC_ClockFreq.SYSCLK_Frequency / 12000000L); //Adapt to HCLK1

   //read the note

   c = *CurrentMelody++;

   if ( (c >= 'a') && (c <= 'z') )

      {

      c+=('A'-'a');

      }

   if ( c == 'P' )

      {

      note = NOTE_PAUSE;

      }

   else if ( (c >= 'A') && (c <= 'G') )

      {

      note = (c - 'A') + NOTE_LA;

      if ( *CurrentMelody == '#' )

         {

         note|=0x8;

         CurrentMelody++;

         }

      }

   octave = DefaultOctave;

   c = *CurrentMelody;

   if ( (c>= '5') && (c<= '8') )

      {

      octave = OCT_440 + (c-'5');

      CurrentMelody++;

      }

   BUZZER_SetFrequency ( (Note_Freq [ note ] * (1<<octave)));

   //discard delimiter and ignore special duration

   while ( (c = *CurrentMelody++) != 0 )

      {

      if ( c==',')

         break;

      }

   if ( *(CurrentMelody-1)==0 )

      {

      CurrentMelody  = 0;

      }

   if ( c == 0 )

      {

      BUZZER_SetMode ( BUZZER_OFF );

      }

   }

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

*

*                                BUZZER_SetFrequency

*

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

/**

*

*  Set the buzzer frequency

*

*  @param[in]  freq New frequency.

*

**/

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

void BUZZER_SetFrequency ( u16 freq )

   {

   /* Calculate the frequency (depend on the PCLK1 clock value) */

   CCR_Val = (RCC_ClockFreq.PCLK1_Frequency / freq);

   TIM_TimeBaseStructure.TIM_Period          = CCR_Val * 2;

   TIM_TimeBaseStructure.TIM_Prescaler       = 0x0;

   TIM_TimeBaseStructure.TIM_ClockDivision   = 0x0;

   TIM_TimeBaseStructure.TIM_CounterMode     = TIM_CounterMode_Up;

   TIM_TimeBaseInit( TIM3, &TIM_TimeBaseStructure );

   /* Output Compare Toggle Mode configuration: Channel3 */

   TIM_OCInitStructure.TIM_OCMode   = TIM_OCMode_PWM1;

   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

   TIM_OCInitStructure.TIM_Pulse    = CCR_Val;

   TIM_OC3Init( TIM3, &TIM_OCInitStructure );

   TIM_OC3PreloadConfig( TIM3, TIM_OCPreload_Enable );

   }

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

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

*

*                                BUZZER_Init

*

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

/**

*

*  Buzzer Initialization

*

*  @attention  This function must <b>NOT</b> be called by the user.

*

**/

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

void BUZZER_Init( void )

   {

   GPIO_InitTypeDef GPIO_InitStructure;

   /* Enable GPIOB clock  */

   RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );

   /* GPIOB Configuration: TIM3 3in Output */

   GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_0;

   GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;

   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

   GPIO_Init( GPIOB, &GPIO_InitStructure );

   /* TIM3 Configuration ------------------------------------------------------*/

   /* TIM3CLK = 18 MHz, Prescaler = 0x0, TIM3 counter clock = 18  MHz */

   /* CC update rate = TIM3 counter clock / (2* CCR_Val) ~= 750 Hz */

   /* Enable TIM3 clock */

   RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM3, ENABLE );

   TIM_DeInit( TIM3 );

   TIM_TimeBaseStructInit( &TIM_TimeBaseStructure );

   TIM_OCStructInit( &TIM_OCInitStructure );

   /* Time base configuration */

   TIM_TimeBaseStructure.TIM_Period          = 0xFFFF;

   TIM_TimeBaseStructure.TIM_Prescaler       = 0x0;

   TIM_TimeBaseStructure.TIM_ClockDivision   = 0x0;

   TIM_TimeBaseStructure.TIM_CounterMode     = TIM_CounterMode_Up;

   TIM_TimeBaseInit( TIM3, &TIM_TimeBaseStructure );

   /* Output Compare Toggle Mode configuration: Channel3 */

   TIM_OCInitStructure.TIM_OCMode   = TIM_OCMode_Toggle;

   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

   TIM_OCInitStructure.TIM_Pulse    = CCR_Val;

   TIM_OC3Init( TIM3, &TIM_OCInitStructure );

   TIM_OC3PreloadConfig( TIM3, TIM_OCPreload_Disable );

   BUZZER_SetFrequency( 440 );

   /* Enable TIM3 IT */

   TIM_ITConfig( TIM3, TIM_IT_CC3, ENABLE );

   Buzzer_Mode  = BUZZER_OFF;

   }

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

*

*                                BUZZER_Handler

*

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

/**

*

*  Called by the CircleOS scheduler to manage Buzzer tasks.

*

*  @attention  This function must <b>NOT</b> be called by the user.

*

**/

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

void BUZZER_Handler( void )

   {

   int fSetOFF = 0;

   if ( Buzzer_Mode == BUZZER_PLAYMUSIC )

      {

      if ( Buzzer_Counter == 0 )

         {

         PlayMusic();

         }

      else

         {

         Buzzer_Counter--;

         }

      return;

      }

   else if ( Buzzer_Mode == BUZZER_SHORTBEEP )

      {

      if ( Buzzer_Counter++ == (BUZZER_SHORTBEEP_DURATION) )

         {

         Buzzer_Mode  = BUZZER_OFF;

         return;

         }

      if ( Buzzer_Counter == (BUZZER_SHORTBEEP_DURATION/2) )

         {

         fSetOFF = 1;

         }

      }

   else if ( Buzzer_Mode == BUZZER_LONGBEEP )

      {

      if ( Buzzer_Counter++ == (BUZZER_LONGBEEP_DURATION) )

         {

         Buzzer_Mode  = BUZZER_OFF;

         return;

         }

      if ( Buzzer_Counter > (BUZZER_LONGBEEP_DURATION/2) )

         {

         fSetOFF = 1;

         }

      }

   if ( fSetOFF == 1 )

      {

      TIM_Cmd(TIM3, DISABLE);

      }

   }

/// @endcond

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

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

*

*                                BUZZER_GetMode

*

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

/**

*

*  Get the current buzzer mode.

*

*  @return  Current buzzer mode.

*

**/

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

enum BUZZER_mode BUZZER_GetMode( void )

   {

   return Buzzer_Mode;

   }

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

*

*                                BUZZER_SetMode

*

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

/**

*

*  Set new buzzer mode

*

*  @param[in]  mode  New buzzer mode.

*

**/

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

void BUZZER_SetMode( enum BUZZER_mode mode )

   {

   Buzzer_Mode    = mode;

   Buzzer_Counter = 0;

   switch ( mode )

      {

      case BUZZER_PLAYMUSIC   :

         PlayMusic(); //start melody

         /* no break */

      case BUZZER_LONGBEEP    :

      case BUZZER_SHORTBEEP   :

      case BUZZER_ON          :

         TIM_Cmd( TIM3, ENABLE );

         break;

      case BUZZER_OFF         :

         TIM_Cmd( TIM3, DISABLE );

         break;

      }

   }

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

*

*                                BUZZER_PlayMusic

*

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

/**

*

*  Plays the provided melody that follows the RTTTL Format.

*

*  Official Specification

*  @verbatim

<ringing-tones-text-transfer-language> :=

   <name> <sep> [<defaults>] <sep> <note-command>+

<name> := <char>+ ; maximum name length 10 characters

<sep> := ":"

<defaults> :=

   <def-note-duration> |

   <def-note-scale> |

   <def-beats>

<def-note-duration> := "d=" <duration>

<def-note-scale> := "o=" <scale>

<def-beats> := "b=" <beats-per-minute>

<beats-per-minute> := 25,28,...,900 ; decimal value

; If not specified, defaults are

   ;

   ; 4 = duration

   ; 6 = scale

   ; 63 = beats-per-minute

<note-command> :=

   [<duration>] <note> [<scale>] [<special-duration>] <delimiter>

   <duration> :=

   "1" | ; Full 1/1 note

   "2" | ; 1/2 note

   "4" | ; 1/4 note

   "8" | ; 1/8 note

   "16" | ; 1/16 note

   "32" | ; 1/32 note

<note> :=

   "P"  | ; pause

   "C"  |

   "C#" |

   "D"  |

   "D#" |

   "E"  |

   "F"  |

   "F#" |

   "G"  |

   "G#" |

   "A"  |

   "A#" |

   "B"

<scale> :=

   "5" | ; Note A is 440Hz

   "6" | ; Note A is 880Hz

   "7" | ; Note A is 1.76 kHz

   "8" ; Note A is 3.52 kHz

<special-duration> :=

   "." ; Dotted note

<delimiter> := ","

@endverbatim

*

*  @param[in]  melody New melody to play on buzzer.

*

**/

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

void BUZZER_PlayMusic (const u8 *melody )

   {

   u8    c;

   u8    default_id  = 0;

   u16   default_val = 0;

   DefaultOctave      = OCT_880;  // Default for the default Octave.

   DefaultDuration    = 4;        // Default for the default Duration.

   DefaultBeats       = 63;

   CurrentMelody      = melody;

   CurrentMelodySTART = melody;

   while( *CurrentMelody != RTTTL_SEP )

      {

      if( *CurrentMelody == 0 )

         {

         return;

         }

      // Discard the melody name.

      CurrentMelody++;

      }

   // Now read the defaults if any.

   for( ++CurrentMelody; *CurrentMelody != RTTTL_SEP; CurrentMelody++ )

      {

      if( *CurrentMelody == 0 )

         {

         return;

         }

      // Discard any blank.

      while ( *CurrentMelody == ' ' )

         {

         CurrentMelody++;

         }

      c = *CurrentMelody;

      if ( c == RTTTL_SEP )

         {

         break;

         }

      if ( (c >= 'a') && (c <= 'z') )

         {

         c+=('A'-'a');

         }

      if ( (c >= 'A') && (c <= 'Z') )

         {

         default_id = c;

         continue;

         }

      if ( (c >= '0') && (c <= '9') )

         {

         default_val *= 10;

         default_val += (c-'0');

         c = * (CurrentMelody + 1 );

         if ( (c >= '0') && (c <= '9') )

            {

            continue;

            }

         if ( default_id == 'D' )

            {

            DefaultDuration = default_val;

            }

         else if ( default_id == 'O' )

            {

            DefaultOctave = default_val - 5;

            if ( DefaultOctave > OCT_7040 )

               DefaultOctave = OCT_440;

            }

         else if ( default_id == 'B' )

            {

            DefaultBeats = default_val;

            if ( ( DefaultBeats == 0 ) || ( DefaultBeats > 500 ) )

               DefaultBeats = 63;

            }

         default_val = 0;

         default_id  = 0;

         }

      }

   BUZZER_SetMode( BUZZER_PLAYMUSIC );

   }