projekty/Source/example1/src/delay/delay.h

Go to the documentation of this file.

/*
 * File        : delay.h
 * Title       : Delay Routines.
 *
 * Revised     : 03/Apr/2007
 * Created     : 25/Jan/2006
 * Version     : 1.0.1
 * Editor Tabs : 3
 * Tool-Chain  : arm-elf-gcc 4.0.1
 *
 * MCU         : Philips LPC2xxx (32-Bits ARM7TDMI-S Core)
 *
 * Author      : Boris Estudiez <stk@freeshell.org>
 * Website     : http://stk.freeshell.org
 * Licence     : GPL
 *
 * Description : Inline functions and macros for accurate delays.
 *
 * Note[1]     : No timers or interruptions used.
 * Note[2]     : MAM should be Fully Enabled for CCLK > 20 MHz.
 *
 * History     : Originally relased for my LPC-STXLIB library.
 *
 * (C) Copyright by slicetex electronics, 2001-2007.
 */
 
#ifndef __DELAY_H__
#define __DELAY_H__

// ---------------------------------------------------------------------------
// HEADERS
// ---------------------------------------------------------------------------

#include "inttypes.h"   // C99 Standard Integer Data Types

// ---------------------------------------------------------------------------
// CONFIGURATION
//
// Setup FOSC and PLL_MUL defines according to your system.
// 
// For example, LPC2138, XTAL = 12000000 Hz and PLL_multiplier = 5.
// CPU clock will be 60 MHz.
// ---------------------------------------------------------------------------

#define FOSC        (12000000)        // Specify Oscilator Output Frequency.
#define PLL_MUL     (5)               // Specify PLL Multiplier.

#define CCLK        (FOSC * PLL_MUL)  // CPU Clock Frequency.

// ---------------------------------------------------------------------------
// CPU CYCLES DEFINES
// 
// ARM7TDMI-S cycles per micro-second, mili-second, second, etc
// Remember: 1 clock = 1 cpu_cycle on this architecture.
// ---------------------------------------------------------------------------

#define CPU_CLOCKS_PER_CYCLE    (1)
#define CPU_CYCLES_PER_SEC      (CCLK/CPU_CLOCKS_PER_CYCLE)
#define CPU_CYCLES_PER_US       (CPU_CYCLES_PER_SEC/1000000)
#define CPU_CYCLES_PER_MS       (CPU_CYCLES_PER_SEC/1000)

// ---------------------------------------------------------------------------
// CONSTANTS AND COMPUTATIONS
// ---------------------------------------------------------------------------

// Define cycles per loop for each delay function:

#define DELAY4_CYCLES_PER_LOOP      (4)

// Compute how many CPU clycles per US, MS and Second fix into one
// delay loop for each delay function.

#define DELAY4_LOOPS_PER_US   (CPU_CYCLES_PER_US/DELAY4_CYCLES_PER_LOOP)
#define DELAY4_LOOPS_PER_MS   (CPU_CYCLES_PER_MS/DELAY4_CYCLES_PER_LOOP)
#define DELAY4_LOOPS_PER_SEC  (CPU_CYCLES_PER_SEC/DELAY4_CYCLES_PER_LOOP)

// ---------------------------------------------------------------------------
// MACROS
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// DelayUS() : Delay in Micro-Seconds.
// Max Delay : MAX_UINT32_T/DELAY4_LOOPS_PER_US [micro-seconds]
// Error     : 2 cycles (at least) + MAMTIM cycles (if CCLK > 20 Mhz).
// ---------------------------------------------------------------------------

#define DelayUS(us)   Delay4( ((uint32_t) ( (us) * (DELAY4_LOOPS_PER_US) )) )

// ---------------------------------------------------------------------------
// DelayMS() : Delay in Mili-Seconds.
// Max Delay : MAX_UINT32_T/DELAY4_LOOPS_PER_MS [mili-seconds]
// Error     : 2 cycles (at least) + MAMTIM cycles (if CCLK > 20 Mhz).
// ---------------------------------------------------------------------------

#define DelayMS(ms)   Delay4( ((uint32_t) ( (ms) * (DELAY4_LOOPS_PER_MS) )) )

// ---------------------------------------------------------------------------
// DelayS()  : Delay in Seconds.
// Max Delay : MAX_UINT32_T/(DELAY4_LOOPS_PER_SEC) [seconds]
// Error     : 2 cycles (at least) + MAMTIM cycles (if CCLK > 20 Mhz). 
// ---------------------------------------------------------------------------

#define DelayS(s)     Delay4( ((uint32_t) ( (s) * (DELAY4_LOOPS_PER_SEC) )) )

// ---------------------------------------------------------------------------
// INLINE FUNCTIONS
// ---------------------------------------------------------------------------

// ***************************************************************************
// Delay4(): Delay 4 cycles per loop.
// 
// INPUT: loops = number of loops.
//
// Total Delay Cycles = 4 * loops - 2. 
// Max Delay Cycles   = 4 * (2^32 - 1) - 2 = 17,179,869,179 (wow!!!)
//
// Example:
// If CCLK = 60 Mhz, then 1 cycle (clock) = ~ 16.666 nS.
// Max Delay Time = (Max Delay Cycles) * 16.666 nS = 286.319 Sec. = 4.77 Min.
// ***************************************************************************

static __inline__ void Delay4(uint32_t loops)
{
   asm volatile 
   (                                                                       \
      "\n\t"                                                               \
      "LOOP_%=:                                                      \n\t" \
      "subs %0, %0, #1           @ 1 cycle                           \n\t" \
      "bne LOOP_%=               @ 3 cycles (true), 1 cycle (false)  \n\t" \
      "\n\t"                                                               \
      : /* NO OUTPUTS */                                                   \
      : "r" (loops)                                                        \
   );
}


// ---------------------------------------------------------------------------
 
#endif

// ---------------------------------------------------------------------------
// END OF FILE
// ---------------------------------------------------------------------------

---