Scribd
Upload
211 views4 pages

Adc Lpc1769 Code

This document contains C code for initializing and reading from an analog-to-digital converter (ADC) on a microcontroller. It defines functions for initializing the ADC with a specified clock rate, reading single channels or using burst mode to read multiple channels, and an interrupt handler for the ADC interrupt. Global variables track ADC conversion values and counters for burst reads and overruns.

Uploaded by

doubletap1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
211 views4 pages

Adc Lpc1769 Code

This document contains C code for initializing and reading from an analog-to-digital converter (ADC) on a microcontroller. It defines functions for initializing the ADC with a specified clock rate, reading single channels or using burst mode to read multiple channels, and an interrupt handler for the ADC interrupt. Global variables track ADC conversion values and counters for burst reads and overruns.

Uploaded by

doubletap1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 4

#include "lpc17xx.

h"
#include "type.h"
#include "adc.h"
#ifndef _BV
#define _BV(_x_) (1UL << (_x_))
#endif
volatile
volatile
volatile
volatile

uint32_t
uint32_t
uint32_t
uint32_t

ADCValue[ADC_NUM];
ADCIntDone = 0;
BurstCounter = 0;
OverRunCounter = 0;

#if BURST_MODE
volatile uint32_t channel_flag = 0;
#endif
#if ADC_INTERRUPT_FLAG
/******************************************************************************
** Function name:
ADC_IRQHandler
**
** Descriptions:
ADC interrupt handler
**
** parameters:
None
** Returned value:
None
**
******************************************************************************/
void ADC_IRQHandler (void)
{
uint32_t regVal;
volatile uint32_t dummy;
int i;
regVal = LPC_ADC->STAT;
/* Read ADC will clear the interrupt */
if ( regVal & 0x0000FF00 )
/* check OVERRUN error first */
{
OverRunCounter++;
for ( i = 0; i < ADC_NUM; i++ )
{
regVal = (regVal & 0x0000FF00) >> 0x08;
/* if overrun, just read ADDR to clear */
/* regVal variable has been reused. */
if ( regVal & _BV(i) )
{
dummy = LPC_ADC->DR[i];
}
}
LPC_ADC->CR &= ~((0x7<<24)|(0x1<<16)); /* stop ADC now, turn off BURST
bit. */
ADCIntDone = 1;
return;
}
for ( i = 0; i < ADC_NUM; i++ )
{
if ( regVal & _BV(i) )
{
ADCValue[i] = ( LPC_ADC->DR[i] >> 4 ) & 0xFFF;
}
}

#if BURST_MODE
BurstCounter++;
channel_flag |= (regVal & 0xFF);
if ( (channel_flag & 0xFF) == 0xFF )
{
/* All the bits in have been set, it indicates all the ADC
channels have been converted. */
LPC_ADC->CR &= ~(0x1<<16);
/* Clear BURST mode, stop ADC now */
channel_flag = 0;
ADCIntDone = 1;
}
#else
LPC_ADC->CR &= ~(0x7<<24);
/* stop ADC now */
ADCIntDone = 1;
#endif
return;
}
#endif
/*****************************************************************************
** Function name:
ADCInit
**
** Descriptions:
initialize ADC channel
**
** parameters:
ADC clock rate
** Returned value:
None
**
*****************************************************************************/
void ADCInit( uint32_t ADC_Clk )
{
uint32_t i, pclkdiv, pclk;
/* Enable CLOCK into ADC controller */
LPC_SC->PCONP |= (1 << 12);
for ( i = 0; i < ADC_NUM; i++ )
{
ADCValue[i] = 0x0;
}
/* all the related pins are set to ADC inputs, AD0.0~7 */
LPC_PINCON->PINSEL0 &= ~0x000000F0; /* P0.2~3, A0.6~7, function 10 */
LPC_PINCON->PINSEL0 |= 0x000000A0;
LPC_PINCON->PINSEL1 &= ~0x003FC000; /* P0.23~26, A0.0~3, function 01 */
LPC_PINCON->PINSEL1 |= 0x00154000;
LPC_PINCON->PINSEL3 |= 0xF0000000;
/* P1.30~31, A0.4~5, function 11 */
/* No pull-up no pull-down (function 10) on these ADC pins. */
LPC_PINCON->PINMODE0 &= ~0x000000F0;
LPC_PINCON->PINMODE0 |= 0x000000A0;
LPC_PINCON->PINMODE1 &= ~0x003FC000;
LPC_PINCON->PINMODE1 |= 0x002A8000;
LPC_PINCON->PINMODE3 &= ~0xF0000000;
LPC_PINCON->PINMODE3 |= 0xA0000000;
/* By default, the PCLKSELx value is zero, thus, the PCLK for
all the peripherals is 1/4 of the SystemFrequency. */
/* Bit 24~25 is for ADC */
pclkdiv = (LPC_SC->PCLKSEL0 >> 24) & 0x03;
switch ( pclkdiv )

{
case 0x00:
default:
pclk = SystemFrequency/4;
break;
case 0x01:
pclk = SystemFrequency;
break;
case 0x02:
pclk = SystemFrequency/2;
break;
case 0x03:
pclk = SystemFrequency/8;
break;
}
LPC_ADC->CR = ( 0x01 <<
( ( pclk
- 1 */
( 0 << 16
led */
( 0 << 17
( 1 << 21
( 0 << 24
( 0 << 27
ger A/D conversion) */

0 ) | /* SEL=1,select channel 0~7 on ADC0 */


/ ADC_Clk - 1 ) << 8 ) | /* CLKDIV = Fpclk / ADC_Clk
) |

/* BURST = 0, no BURST, software control

) |
) |
) |
);

/*
/*
/*
/*

CLKS = 0, 11 clocks/10 bits */


PDN = 1, normal operation */
START = 0 A/D conversion stops */
EDGE = 0 (CAP/MAT singal falling,trig

/* If POLLING, no need to do the following */


#if ADC_INTERRUPT_FLAG
NVIC_EnableIRQ(ADC_IRQn);
#if BURST_MODE
LPC_ADC->INTEN = 0xFF;
/* Enable all interrupts */
#else
LPC_ADC->INTEN = 0x1FF;
/* Enable all interrupts */
#endif
#endif
return;
}
/*****************************************************************************
** Function name:
ADCRead
**
** Descriptions:
Read ADC channel
**
** parameters:
Channel number
** Returned value:
Value read, if interrupt driven, return channel
#
**
*****************************************************************************/
uint32_t ADCRead( uint8_t channelNum )
{
#if !ADC_INTERRUPT_FLAG
uint32_t regVal, ADC_Data;
#endif
/* channel number is 0 through 7 */
if ( channelNum >= ADC_NUM )
{
channelNum = 0;
/* reset channel number to 0 */
}

LPC_ADC->CR &= 0xFFFFFF00;


LPC_ADC->CR |= (1 << 24) | (1 << channelNum);
/* switch channel,start A/D convert */
#if !ADC_INTERRUPT_FLAG
while ( 1 )
/* wait until end of A/D convert */
{
regVal = LPC_ADC->DR[channelNum];
/* read result of A/D conversion */
if ( regVal & ADC_DONE )
{
break;
}
}
LPC_ADC->CR &= 0xF8FFFFFF;
/* stop ADC now */
if ( regVal & ADC_OVERRUN ) /* save data when it's not overrun, otherwise, r
eturn zero */
{
return ( 0 );
}
ADC_Data = ( regVal >> 4 ) & 0xFFF;
return ( ADC_Data ); /* return A/D conversion value */
#else
return ( channelNum );
/* if it's interrupt driven, the ADC reading is
done inside the handler.
so, return channel number */
#endif
}
/*****************************************************************************
** Function name:
ADC0BurstRead
**
** Descriptions:
Use burst mode to convert multiple channels once
.
**
** parameters:
None
** Returned value:
None
**
*****************************************************************************/
void ADCBurstRead( void )
{
/* Start bits need to be zero before BURST mode can be set. */
if ( LPC_ADC->CR & (0x7<<24) )
{
LPC_ADC->CR &= ~(0x7<<24);
}
LPC_ADC->CR &= ~0xFF;
/* Read all channels, 0 through 7. */
LPC_ADC->CR |= 0xFF;
LPC_ADC->CR |= (0x1<<16);
/* Set burst mode and start A/D convert
*/
return;
/* the ADC reading is do
ne inside the
handler, return
0. */
}

You might also like