Timer.c

Go to the documentation of this file.

// DOCUMENTAZIONE DOXYGEN
/*!
\file
\page Timer_ Timer page
*\brief  <span style="color:red;"> <b> Timing functions  </b> </span>
*\tableofcontents
 
 \b SUMMARY:
*\arg \ref Timer_fun
 
 
*\section Timer_fun User use of the Timer
<hr width="75%" size="10" align="left">
 
\n A very simple and friendly function has been created for waiting time during slow operations
such as relay setting. The function is blocking and is Aspetta_tanti_ms(int m) and wait \b m milliseconds. Example:
 
<span style="color:orange;"> <I>
\code {.c}
//Wait 10 ms
Aspetta_tanti_ms(10);
\endcode
</I> </span>
 
\n The counter is bae on the SysTick_Handler() which increases the counter every ms.
 
\n The code:
*\snippet{lineno} Timer.c fun_timer
 
*/
 
#include "tutti_gli_header.h"
 
 
// Vengono inizializzati dei parametri
 
volatile bool timer             =                0;
volatile uint32_t ticks             =            0;
volatile uint32_t N                     =            100;
 
 
/*****************************************************************************
 Aspetta_tanti_ms
******************************************************************************/
/*! \brief The timing function
\param[in] millisecondi the time to wait in millisec
*\return No Parameters
 \showrefby
*\snippet{lineno} Timer.c fun_timer
 */
//! <!-- [fun_timer] -->
void Aspetta_tanti_ms(int millisecondi)
{
#define come_dovrebbe_funzionare
//#define uso_di_timer0 
#ifdef  come_dovrebbe_funzionare
    N = millisecondi;                                       // Viene stabilito quanti ms il micro dovr\'a aspettare
    timer = 1;                              // Viene impostato il flag timer a 1
    while(timer!=0)                     // Viene fatto un ciclo infinito finch\'e il flag non viene azzerato
    {
    }
#endif
#ifdef uso_di_timer0
    int32_t partenza,arrivo ;
    millisecondi = millisecondi * TIMER0_coefficiente_per_millisec ;
  LPC_TIM0->MR0 = millisecondi ;
    LPC_TIM0->TC =0;
    TIMER0_start_conteggio
    while( (LPC_TIM0->IR & 1) ==0 ){}
    LPC_TIM0->IR |=1 ; //Azzero il flag di fine misura
#endif
}
//! <!-- [fun_timer] -->
 
/******************************************************************************
  SysTick Handler
 ******************************************************************************/
/*! \brief The timing function
\param[in] m the time to wait in millisec
*\return No Parameters
 \showrefby
*\snippet{lineno} Timer.c fun_SysTick_Handler
 */
//! <!-- [fun_SysTick_Handler] -->
void SysTick_Handler (void)
{                                                           // Se il flag timer \'e 0, non viene fatto niente
    if (timer == 1)                         // Se il flag timer \'e 1, viene aumentato ticks finch\'e non diventa N-1
    {
        if(ticks>=(N-1))
        {
            ticks=0;                                // Quando ticks = N-1, vengono azzerati ticks e timer
            timer=0;
//          return;
        }
        else
        {
            ++ticks;
//          return;
        }
    }
#ifdef true
    //temporizzatore LED rosso
    if (LED_rosso_attivo || prolungamento){
        if( prolungamento==0){
            prolungamento=10;
            LED_rosso_tempo=0;
            LED_accendi_spegni(LED_RED, accendi);
            acceso=0;
        }
        if( (LED_rosso_tempo >= LED_rosso_fondo_scala)   ){
            LED_rosso_tempo =0;
            LED_RED_lampeggio();
            prolungamento--;
            if(prolungamento==0)LED_accendi_spegni(LED_RED, spegni);
        }else{
            LED_rosso_tempo++;
        }
    }
    
//temporizzatore LED verde
    if(LED_verde_attivo){
        if( (LED_verde_tempo >= LED_verde_fondo_scala) ){
            LED_verde_tempo =0;
            LED_VERDE_lampeggio();
        }else{
            LED_verde_tempo++;
        }
    }
#endif  
    //temporizzazione powerdown
    if( POWER_DOWN_ABILITA_CONTEGGIO) POWER_DOWN_TEMPO_ATTESA ++;
            
}
//! <!-- [fun_SysTick_Handler] -->
 
/*! \brief Use of timer0 as a delay
 
*\return No Parameters
 \showrefby
*\snippet{lineno} Timer.c fun_TIMER0_setup
 */
//! <!-- [fun_TIMER0_setup] -->
void TIMER0_setup(void){
    LPC_SC->PCONP |= 1; //Acensione timer0 (\'e gi\'a acceso, ma per sicurezza)
    LPC_SC->PCLKSEL0 |= 1 << 2; //Clock = a quello della cpu
    LPC_TIM0->PR = SystemCoreClock / TIMER0_freqeunza ; // 1 contenggio ogni 100 micros
    LPC_TIM0 -> MCR |=  TIM0_MR0I | TIM0_MR0S | TIM0_MR0R ; //Interrupt + reset conteggio e stop
}
//! <!-- [fun_TIMER0_setup] -->
 
/*! \brief Use of timer0 as an endless counter
 
*\return No Parameters
 \showrefby
*\snippet{lineno} Timer.c fun_TIMER1_setup
 */
//! <!-- [fun_TIMER1_setup] -->
void TIMER1_setup(void){
    LPC_SC->PCONP |= 2; //Acensione timer1 (\'e gi\'a acceso, ma per sicurezza)
    LPC_SC->PCLKSEL0 |= 1 << 4; //Clock = a quello della cpu
    LPC_TIM1->PR = SystemCoreClock / TIMER0_freqeunza ; // 1 contenggio ogni 100 micros
//  LPC_TIM1 -> MCR |=  TIM0_MR0I | TIM0_MR0S | TIM0_MR0R ; //Interrupt + reset conteggio e stop
    TIMER1_start_conteggio
}
//! <!-- [fun_TIMER1_setup] -->