void confADC(){
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); // Habilita ADC0
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceDisable(ADC0_BASE,0); // Deshabilita el secuenciador 1 del ADC0 para su configuracion
HWREG(ADC0_BASE + ADC_O_PC) = (ADC_PC_SR_500K); // usar en lugar de SysCtlADCSpeedSet
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_TIMER, 0);// Disparo de muestreo por instrucciones de Timer
ADCHardwareOversampleConfigure(ADC0_BASE, 64); //SobreMuestreo de 64 muestras
// Configuramos los 4 conversores del secuenciador 1 para muestreo del sensor de temperatura
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0); //Sequencer Step 0: Samples Channel PE3
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH1); //Sequencer Step 1: Samples Channel PE2
ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH2 | ADC_CTL_IE | ADC_CTL_END); //Sequencer Step 2: Samples Channel PE1
IntPrioritySet(INT_ADC0SS0,5<<5);
// Tras configurar el secuenciador, se vuelve a habilitar
ADCSequenceEnable(ADC0_BASE, 0);
//Asociamos la funcion a la interrupcion
ADCIntRegister(ADC0_BASE, 0,ADCIntHandler);
//Activamos las interrupciones
ADCIntEnable(ADC0_BASE,0);
}
//---------------------------------------------------------------------------
// hardware_init()
//
// inits GPIO pins for toggling the LED
//---------------------------------------------------------------------------
void hardware_init(void)
{
//Set CPU Clock to 40MHz. 400MHz PLL/2 = 200 DIV 5 = 40MHz
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//Removing Locks From Switch
LOCK_F=0x4C4F434B;
CR_F=GPIO_PIN_0|GPIO_PIN_4;
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_0); // Configuring PD0 as ADC input (channel 1) CH7 ADC0
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC1_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH7);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_CH7);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_CH7);
ADCSequenceStepConfigure(ADC0_BASE, 1, 3, ADC_CTL_CH7 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC1_BASE, 1, 0, ADC_CTL_CH6);
ADCSequenceStepConfigure(ADC1_BASE, 1, 1, ADC_CTL_CH6);
ADCSequenceStepConfigure(ADC1_BASE, 1, 2, ADC_CTL_CH6);
ADCSequenceStepConfigure(ADC1_BASE, 1, 3, ADC_CTL_CH6 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
ADCSequenceEnable(ADC1_BASE, 1);
ADCIntClear(ADC0_BASE, 1);
ADCIntClear(ADC1_BASE, 1);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_6);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_3);
GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_5);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0);
//GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_4,0x10);
}
void initADCPorts(void) {
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);
ADCSequenceConfigure(ADC_BASE,0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC_BASE,1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC_BASE,2, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC_BASE,3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC_BASE, 0, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC_BASE, 1, 0, ADC_CTL_CH1 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC_BASE, 2, 0, ADC_CTL_CH2 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC_BASE, 3, 0, ADC_CTL_CH3 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC_BASE, 0);
ADCSequenceEnable(ADC_BASE, 1);
ADCSequenceEnable(ADC_BASE, 2);
ADCSequenceEnable(ADC_BASE, 3);
}
void SampleLightCO(void){
unsigned long ulADC0_Value[1];
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |
ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 3);
while(1){
ADCProcessorTrigger(ADC0_BASE, 3);
while(!ADCIntStatus(ADC0_BASE, 3, false)){
}
ADCIntClear(ADC0_BASE, 3);
ADCSequenceDataGet(ADC0_BASE, 3, ulADC0_Value);
Log("Breath Level = ");
LogD(ulADC0_Value[0]);
Log("\r");
SysCtlDelay(SysCtlClockGet() / 12);
}
}
/*
* 初始化ADC引脚和配置
* 其中ADC0的输入引脚配置为CH1，ADC1的输入引脚配置为CH2
*/
void Init_ADC()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_1);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_2);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH1 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 3);
ADCSequenceConfigure(ADC1_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC1_BASE, 3, 0, ADC_CTL_CH2 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC1_BASE, 3);
ADCIntClear(ADC1_BASE, 3);
}
int main(void) {
SysCtlClockSet(
SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
UARTStdioConfig(0, 115200, 16000000);
ADCSequenceDisable(ADC0_BASE, 1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 3,
ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
UARTprintf("This is ADC examlpe");
while (1) {
UARTprintf("Temperature is: %d \210 C\n", ADC_getVal());
SysCtlDelay(40000000 / 3);
}
}
//******************************************************************************
void initADC (void)
{
// The ADC0 peripheral must be enabled for configuration and use.
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
// Enable sample sequence 3 with a processor signal trigger. Sequence 3
// will do a single sample when the processor sends a signal to start the
// conversion.
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
// Configure step 0 on sequence 3. Sample channel 0 (ADC_CTL_CH0) in
// single-ended mode (default) and configure the interrupt flag
// (ADC_CTL_IE) to be set when the sample is done. Tell the ADC logic
// that this is the last conversion on sequence 3 (ADC_CTL_END). Sequence
// 3 has only one programmable step. Sequence 1 and 2 have 4 steps, and
// sequence 0 has 8 programmable steps. Since we are only doing a single
// conversion using sequence 3 we will only configure step 0. For more
// on the ADC sequences and steps, refer to the LM3S1968 datasheet.
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |
ADC_CTL_END);
// Since sample sequence 3 is now configured, it must be enabled.
ADCSequenceEnable(ADC0_BASE, 3);
// Register the interrupt handler
ADCIntRegister (ADC0_BASE, 3, HeightIntHandler);
// Enable interrupts for ADC0 sequence 3 (clears any outstanding interrupts)
ADCIntEnable(ADC0_BASE, 3);
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_SYSDIV_5| SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
ledPinConfig();
while (1)
{
Test2();
//print_temc();
SysCtlDelay(SysCtlClockGet()/3);
}
}
void adc_init_and_run(void){
// Тактирование выбранного модуля АЦП.
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADCx);
// Ожидание готовности выбранного модуля АЦП к настройке.
while(!SysCtlPeripheralReady(SYSCTL_PERIPH_ADCx)) { }
ADCHardwareOversampleConfigure(ADCx_BASE, 4);
// Установка триггера выбранного буфера АЦП.
ADCSequenceConfigure(ADCx_BASE, SSy, ADC_TRIGGER, 0);
ADCSequenceStepConfigure(ADCx_BASE, SSy, 0, ADC_CTL_CH0);
ADCSequenceStepConfigure(
ADCx_BASE, SSy, 1, ADC_CTL_CH1|ADC_CTL_IE|ADC_CTL_END
);
ADCIntClear(ADCx_BASE, SSy);
IntEnable(INT_ADCxSSy);
IntPrioritySet(INT_ADCxSSy, 1);
ADCSequenceEnable(ADCx_BASE, SSy);
ADCProcessorTrigger(ADCx_BASE, SSy);
}
unsigned long ADC_In(unsigned int channelNum){
unsigned long config;
unsigned long data;
// Configuring ADC to start by processor call instead of interrupt
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
// Determine input channel
switch(channelNum){
case 0: config = ADC_CTL_CH0; break;
case 1: config = ADC_CTL_CH1; break;
case 2: config = ADC_CTL_CH2; break;
case 3: config = ADC_CTL_CH3; break;
}
// Enable ADC interrupt and last step of sequence
config |= ADC_CTL_IE | ADC_CTL_END;
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, config);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 3);
// Start ADC conversion
ADCProcessorTrigger(ADC0_BASE, 3);
// Wait for ADC conversion to finish
while(!ADCIntStatus(ADC0_BASE, 3, false)){}
// Clear interrupt flag and read conversion data
ADCIntClear(ADC0_BASE, 3);
ADCSequenceDataGet(ADC0_BASE, 3, &data);
return data;
}
int main(void)
{
SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5);
ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH8);
ADCSequenceStepConfigure(ADC0_BASE, 2, 1, ADC_CTL_CH11 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 2);
ADCIntClear(ADC0_BASE, 2);
while(1)
{
ADCProcessorTrigger(ADC0_BASE, 2);
while(!ADCIntStatus(ADC0_BASE, 2, false));
ADCIntClear(ADC0_BASE, 2);
ADCSequenceDataGet(ADC0_BASE, 2, adcValue);
SysCtlDelay(SysCtlClockGet() / 12);
}
}
// ADC初始化
void
adc_init(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC); //使能ADC模块
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS); //设置ADC采样速率
ADCSequenceDisable(ADC_BASE, 0); // 配置前先禁止采样序列
ADCSequenceConfigure(ADC_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
//配置ADC采样序列的触发事件和优先级：ADC基址，采样序列编号，触发事件，采样优先级
ADCSequenceStepConfigure(ADC_BASE, 0, 0,
ADC_CTL_END | ADC_CTL_CH0 | ADC_CTL_IE);
//配置ADC采样序列发生器的步进 ：ADC基址，采样序列编号，步值，通道设置
intConnect(INT_ADC0, ADC_Sequence_0_ISR, 0u);
ADCIntEnable(ADC_BASE, 0); //使能ADC采样序列的中断
// IntEnable(INT_ADC0); // 使能ADC采样序列中断
intEnable(INT_ADC0);
IntMasterEnable(); // 使能处理器中断
ADCSequenceEnable(ADC_BASE, 0); // 使能一个ADC采样序列
the_lock = semBCreate(0);
// printf("%x\n", the_lock);
}
int main(void)
{
uint32_t ui32ADC0Value[4];
volatile uint32_t ui32TempAvg;
volatile uint32_t ui32TempValueC;
volatile uint32_t ui32TempValueF;
setup();
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
while(1)
{
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;
ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;
}
}
//模数转换初始化
void Init_ADC0(void)
{
//使能ADC0模块
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
//配置前先关闭序列0
//ADCSequenceDisable (unsigned long ulBase, unsigned long ulSequenceNum)
ADCSequenceDisable(ADC0_BASE,0);
//配置SS0:由CPU软件触发,优先级0(最高)
//ADCSequenceConfigure(unsigned long ulBase,unsigned long ulSequenceNum, unsigned long ulTrigger, unsigned long ulPriority)
ADCSequenceConfigure(ADC0_BASE,0,ADC_TRIGGER_PROCESSOR,0);
//配置序列里面的每一个成员配置输入通道,是否中断,是否最后采样.本例序列中只有一个采样:ulstep=0,来自内置温度传感器TS
//ADCSequenceStepConfigure(unsigned long ulBase,unsigned long ulSequenceNum,unsigned long ulStep,unsigned long ulConfig)
ADCSequenceStepConfigure(ADC0_BASE,0,0,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
//使能模块中断
//ADCIntEnable (unsigned long ulBase, unsigned long ulSequenceNum)
ADCIntEnable(ADC0_BASE,0);
//在NVIC中使能ADC中断
IntEnable(INT_ADC0);
//使能序列0
//ADCSequenceEnable (unsigned long ulBase, unsigned long ulSequenceNum)
ADCSequenceEnable(ADC0_BASE,0);
}
//*****************************************************************************
//
//! Initializes the ADC control routines.
//!
//! This function initializes the ADC module and the control routines,
//! preparing them to monitor currents and voltages on the motor drive.
//!
//! \return None.
//
//*****************************************************************************
void
ADCInit(void)
{
//
// Set the speed of the ADC to 1 million samples per second.
//
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_1MSPS);
//
// Configure sample sequence zero to capture all three motor phase
// currents, the DC bus voltage, and the internal junction temperature.
// The sample sequence is triggered by the signal from the PWM module.
//
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PWM0, 0);
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, PIN_I_PHASEU);
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, PIN_I_PHASEV);
ADCSequenceStepConfigure(ADC0_BASE, 0, 2, PIN_I_PHASEW);
ADCSequenceStepConfigure(ADC0_BASE, 0, 3, PIN_VSENSE);
ADCSequenceStepConfigure(ADC0_BASE, 0, 4,
ADC_CTL_END | ADC_CTL_IE | ADC_CTL_TS);
//
// Enable sample sequence zero and its interrupt.
//
ADCSequenceEnable(ADC0_BASE,0);
ADCIntEnable(ADC0_BASE, 0);
IntEnable(INT_ADC0SS0);
}
/**
* Do a processor A/D conversion sequence.
*/
static void scan_proc_adc(void)
{
int samples;
/*
* We occasionally get too many or too few samples because
* the extra (missing) samples will show up on the next read
* operation. Just do it again if this happens.
*/
for (samples = 0; samples != ADC_SAMPLES; ) {
ADCSequenceEnable(ADC0_BASE, 0);
ADCProcessorTrigger(ADC0_BASE, 0);
/*
* Wait until the sample sequence has completed.
*/
while(!ADCIntStatus(ADC0_BASE, 0, false))
;
/*
* Read the values from the ADC. The whole sequence
* gets converted and stored in one fell swoop.
*/
if (xSemaphoreTake(io_mutex, IO_TIMEOUT)) {
samples = ADCSequenceDataGet(ADC0_BASE, 0,
(unsigned long *)adc_val);
xSemaphoreGive(io_mutex);
}
#if (DEBUG > 0)
if (samples != ADC_SAMPLES) {
lprintf("A/D samples: is %d, "
"should be %d.\r\n",
samples, ADC_SAMPLES);
}
#endif
}
}
void adc_init(void)
{
unsigned long ulDummy = 0;
// Enable the ADC hardware
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
// Configure the pin as analog input
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1); // PIN D3/2/1 as ADC.
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5); // PIN E5 as ADC.
//GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5 | GPIO_PIN_4); // U_AN{0..1}
// for 6 ADCs
// use Sample Sequencer 0 since it is the only one able to handle more than four ADCs
ADCSequenceDisable(ADC0_BASE, 0);
// configure Sequencer to trigger from processor with priority 0
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
// do NOT use TRIGGER_TIMER because of malfunction in the touch screen handler
//ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_TIMER, 0);
// configure the steps of the Sequencer
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH4); //CH4 = PD3
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH5); //CH5 = PD2
ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH6); //CH6 = PD1
ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH8 | ADC_CTL_IE | ADC_CTL_END);//CH8 = PE5
//ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH11); // U_AN1
//ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH4); // U_AN2
//ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH5); // U_AN3
//ADCSequenceStepConfigure(ADC0_BASE, 0, 4, ADC_CTL_CH6); // U_AN4
//ADCSequenceStepConfigure(ADC0_BASE, 0, 5, ADC_CTL_CH7 | ADC_CTL_IE | ADC_CTL_END); // U_AN5
ADCSequenceEnable(ADC0_BASE, 0);
// flush the ADC
ADCSequenceDataGet(ADC0_BASE, 0, &ulDummy);
// Enable Interrupt for ADC0 Sequencer 0
ADCIntEnable(ADC0_BASE, 0);
IntEnable(INT_ADC0);
/*
for (int i=0; i < 4; i++) {
for (int j=0; j < ADC_BUFF_SIZE; j++) {
adcBuff[i][j] = 50; //give the buffers a half decent starting value.
}
}
adcBuffCnt = 0;
*/
}
void Init_ADC() {
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);
ADCSequenceConfigure(ADC_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC_BASE, 0, 0, ADC_CTL_IE | ADC_CTL_END | ADC_CTL_CH0);
ADCSequenceEnable(ADC_BASE, 0);
ADCProcessorTrigger(ADC_BASE, 0);
}
void ADCInit() {
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0,
ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 3);
}
void adc_read() {
ADCProcessorTrigger(ADC0_BASE, 0);
while(!ADCIntStatus(ADC0_BASE, 0, false));
ADCIntClear(ADC0_BASE, 0);
ADCSequenceDataGet(ADC0_BASE, 0, ulADC0_Value);
ADCSequenceEnable(ADC0_BASE, 0);
}
// *******************************************************
// Initializes the ADC pins and their ISRs.
void heightInit(void)
{
// using code from WEEK-2_ADC, my_adc.c written by Dr. Steve Weddell
//SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
// SYSCTL_XTAL_8MHZ);
//
// The ADC0 peripheral must be enabled for use.
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
//
// For this example ADC0 is used with AIN0 on port B1. This
// was given by the LM3S1968 data sheet.
// Therefore, GPIO port B needs to be enabled
// so these pins can be used.
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
// Select the analog ADC function for these pins.
// The LM3S1968 data sheet was consulted to see which functions are
// allocated per pin.
GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_1);
// Enable sample sequence 3 with a processor signal trigger. Sequence 3
// will do a single sample when the processor sends a signal to start the
// conversion. Each ADC module has 4 programmable sequences, sequence 0
// to sequence 3. This example is arbitrarily using sequence 3.
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
//
// Configure step 0 on sequence 3. Sample channel 0 (ADC_CTL_CH0) in
// single-ended mode (default) and configure the interrupt flag
// (ADC_CTL_IE) to be set when the sample is done. Tell the ADC logic
// that this is the last conversion on sequence 3 (ADC_CTL_END). Sequence
// 3 has only one programmable step. Sequence 1 and 2 have 4 steps, and
// sequence 0 has 8 programmable steps. Since we are only doing a single
// conversion using sequence 3 we will only configure step 0. For more
// information on the ADC sequences and steps, reference the datasheet.
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |
ADC_CTL_END);
//
// Since sample sequence 3 is now configured, it must be enabled.
ADCSequenceEnable(ADC0_BASE, 3);
//
// Clear the interrupt status flag. This is done to make sure the
// interrupt flag is cleared before we sample.
ADCIntClear(ADC0_BASE, 3);
initCircBuf (&g_heightBuf, CIRCBUF_SIZE);
}
int main(void) {
settemp = 25;
uint32_t ui32ADC0Value[4];
SysCtlClockSet(
SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN
| SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
IntMasterEnable();
IntEnable(INT_UART0);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
while(1){
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;
ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;
char m[] = "Current Temperature is *C, Set Temperature is *C";
m[23]=(ui32TempValueC/10 % 10) + '0';
m[24]=(ui32TempValueC%10) + '0';
m[49]=(settemp/10 % 10) + '0';
m[50]=(settemp%10) + '0';
int i;
for(i=0;m[i];i++){
UARTCharPut(UART0_BASE, m[i]);
}
if(ui32TempValueC < settemp){
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,8);
}
else{
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,2);
}
UARTCharPut(UART0_BASE, '\r');
UARTCharPut(UART0_BASE, '\n');
SysCtlDelay(1000000);
}
}
void RMBD01Init( void )
{
//
// Configure the ADC for Pitch and Roll
// sequence 3 means a single sample
// sequence 1, 2 means up to 4 samples
// sequence 0 means up to 8 samples
// we use sequence 1
//
if (SysCtlPeripheralPresent(SYSCTL_PERIPH_ADC0))
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_TIMER, 0); // 1 captures up to 4 samples
//
// Select the external reference for greatest accuracy.
//
ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ENCODER_CHANNEL_PITCH); // sample pitch
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ENCODER_CHANNEL_ROLL | ADC_CTL_IE | ADC_CTL_END); // sample roll
ADCIntRegister(ADC0_BASE,1,ADCIntHandler);
ADCSequenceEnable(ADC0_BASE, 1);
ADCIntEnable(ADC0_BASE, 1);
//
// Setup timer for ADC_TRIGGER_TIMER
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
//
// Configure the second timer to generate triggers to the ADC
//
TimerConfigure(TIMER1_BASE, TIMER_CFG_32_BIT_PER);
TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet() / 1000); // 2 ms
TimerControlStall(TIMER1_BASE, TIMER_A, true);
TimerControlTrigger(TIMER1_BASE, TIMER_A, true);
//
// Enable the timers.
//
TimerEnable(TIMER1_BASE, TIMER_A);
new_adc = false;
//
}
//
// Clear outstanding ADC interrupt and enable
//
ADCIntClear(ADC0_BASE, 1);
IntEnable(INT_ADC0);
} // InitADC
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! \param ui32SysClock is the frequency of the system clock.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC 0 sample sequence 3
//! - Timer 5 subtimer B
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(uint32_t ui32SysClock)
{
//
// Set the initial state of the touch screen driver's state machine.
//
g_ui32TSState = TS_STATE_INIT;
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Enable the peripherals used by the touch screen interface.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER5);
//
// Configure the ADC sample sequence used to read the touch screen reading.
//
ADCHardwareOversampleConfigure(ADC0_BASE, 4);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0,
TS_YP_ADC | ADC_CTL_END | ADC_CTL_IE);
ADCSequenceEnable(ADC0_BASE, 3);
//
// Enable the ADC sample sequence interrupt.
//
ADCIntEnable(ADC0_BASE, 3);
IntEnable(INT_ADC0SS3);
//
// Configure the timer to trigger the sampling of the touch screen
// every 2.5 milliseconds.
//
if((HWREG(TIMER5_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0)
{
TimerConfigure(TIMER5_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PWM |
TIMER_CFG_B_PERIODIC));
}
TimerPrescaleSet(TIMER5_BASE, TIMER_B, 255);
TimerLoadSet(TIMER5_BASE, TIMER_B, ((ui32SysClock / 256) / 400) - 1);
TimerControlTrigger(TIMER5_BASE, TIMER_B, true);
//
// Enable the timer. At this point, the touch screen state machine will
// sample and run every 2.5 ms.
//
TimerEnable(TIMER5_BASE, TIMER_B);
}
int ADC_Collect(unsigned int channelNum, unsigned int fs,
unsigned long buffer[], unsigned int numberOfSamples){
int i;
unsigned long config;
// Setting global pointer to point at array passed by funciton
Buffer = buffer;
// Determine input channel
switch(channelNum){
case 0: config = ADC_CTL_CH0; break;
case 1: config = ADC_CTL_CH1; break;
case 2: config = ADC_CTL_CH2; break;
case 3: config = ADC_CTL_CH3; break;
}
// Enable the ADC0 for interrupt Sequence 0 with lower priority then single shot
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_TIMER, 1);
// Configuring steps of sequence, last step contains ADC_CTL_END and ADC_CTL_IE config paramter
for(i = 0; i < (numberOfSamples - 1); i++){
ADCSequenceStepConfigure(ADC0_BASE, 0, i, config);
}
ADCSequenceStepConfigure(ADC0_BASE, 0, numberOfSamples - 1, config | ADC_CTL_END | ADC_CTL_IE);
ADCIntRegister(ADC0_BASE, 0, ADC0_Handler);
ADCSequenceEnable(ADC0_BASE, 0);
// Disabling Timer0A for configuration
TimerDisable(TIMER0_BASE, TIMER_A);
// Configure as 16 bit timer and trigger ADC conversion
TimerConfigure(TIMER0_BASE, TIMER_CFG_16_BIT_PAIR | TIMER_CFG_A_PERIODIC);
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
//
//
// TODO: configure this to calculate load value based on frequency inputed
//
//
TimerLoadSet(TIMER0_BASE, TIMER_A, 1000);
TimerEnable(TIMER0_BASE, TIMER_A);
ADCIntClear(ADC0_BASE, 0);
TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ADCIntEnable(ADC0_BASE, 0);
TimerIntEnable(TIMER0_BASE, TIMER_A);
// Claering Status flag
Status = FALSE;
return 1;
}
//---------------------------------------------------------------------------
// hardware_init()
//
// inits GPIO pins for toggling the LED
//---------------------------------------------------------------------------
void hardware_init(void)
{
//Set CPU Clock to 40MHz. 400MHz PLL/2 = 200 DIV 5 = 40MHz
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_0); // Configuring PD0 as ADC input (channel 1) CH7 ADC0
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC1_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH7);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_CH7);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_CH7);
ADCSequenceStepConfigure(ADC0_BASE, 1, 3, ADC_CTL_CH7 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC1_BASE, 1, 0, ADC_CTL_CH6);
ADCSequenceStepConfigure(ADC1_BASE, 1, 1, ADC_CTL_CH6);
ADCSequenceStepConfigure(ADC1_BASE, 1, 2, ADC_CTL_CH6);
ADCSequenceStepConfigure(ADC1_BASE, 1, 3, ADC_CTL_CH6 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
ADCSequenceEnable(ADC1_BASE, 1);
ADCIntClear(ADC0_BASE, 1);
ADCIntClear(ADC1_BASE, 1);
/* Configure Buzzer pin as output */
GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_4);
GPIODirModeSet(GPIO_PORTC_BASE,GPIO_PIN_4,GPIO_DIR_MODE_OUT);
/* Send a high output on buzzer to turn it off(inverted logic, refer
schematic) */
GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_4,0x10);
}
void CapacitorTask(void* pvParameter)
{
unsigned long ulValue=0;
int i=0;
cqueue = xQueueCreate(100,sizeof(unsigned long));
//SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_1, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_OD);
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_1, 0x02);//Setting the Pin 0 to "high"
//Initialize the ADC using functions from the Stellaris API
//SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceConfigure(ADC_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_IE|ADC_CTL_END|ADC_CTL_CH1);
ADCSequenceEnable(ADC0_BASE, 1);
//ADCIntEnable(ADC0_BASE, 1);
ADCIntClear(ADC0_BASE, 1);
//Trigger from the Processor
while(true)
{
if(flagcap==1)
{
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_1, 0x00);//Setting the Pin 0 to "high"
vTaskDelay(TICK_R*0.5);
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_1, 0x02);//Setting the Pin 0 to "high"
i=0;
flagcap = 0;
//ADCIntClear(ADC0_BASE, 1);
while(i<100)
{
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
ADCSequenceDataGet(ADC0_BASE, 1, &ulValue);//Enable ADC sequence 0
ADCIntClear(ADC0_BASE, 1);
xQueueSend(cqueue, &ulValue, 0);
i++;
vTaskDelay(TICK_R*1.0)
; }
flagUART = 1;
}
vTaskDelay(TICK_R*10);
}
}
int main(void)
{
uint32_t ui32ADC0Value[4];
uint32_t ui32Period;
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
//Configure ADC to read temperature values
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCHardwareOversampleConfigure(ADC0_BASE, 64);
//ESpecify the sampler and configure its various stages
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
//Enable peripheral of UART
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
///Configure pins for UART
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
//Set period of timer interrupts
ui32Period = (SysCtlClockGet() / 1) / 2;
TimerLoadSet(TIMER0_BASE, TIMER_A, ui32Period -1);
IntEnable(INT_TIMER0A);
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
IntMasterEnable();
TimerEnable(TIMER0_BASE, TIMER_A);
while(1)
{
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
//Update the value of temperature based on readings of ADC
ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;
ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;
}
}
void Init_ADC() {
/**** ADC0 ***/
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);
ADCSequenceConfigure(ADC_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC_BASE, 0, 0, ADC_CTL_IE | ADC_CTL_END | ADC_CTL_CH0);
ADCSequenceEnable(ADC_BASE, 0);
ADCProcessorTrigger(ADC_BASE, 0);
//값읽기
ADCProcessorTrigger(ADC_BASE, 0);
while (!ADCIntStatus(ADC_BASE, 0, false))
;
ADCSequenceDataGet(ADC_BASE, 0, &ADC_resultValue0);
/**** ADC1 ***/
ADCSequenceConfigure(ADC_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC_BASE, 1, 0, ADC_CTL_IE | ADC_CTL_END | ADC_CTL_CH1);
ADCSequenceEnable(ADC_BASE, 1);
ADCProcessorTrigger(ADC_BASE, 1);
//값 읽기
ADCProcessorTrigger(ADC_BASE, 1);
while (!ADCIntStatus(ADC_BASE, 1, false))
;
ADCSequenceDataGet(ADC_BASE, 1, &ADC_resultValue1);
/**** ADC2 ***/
ADCSequenceConfigure(ADC_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC_BASE, 2, 0, ADC_CTL_IE | ADC_CTL_END | ADC_CTL_CH2);
ADCSequenceEnable(ADC_BASE, 2);
ADCProcessorTrigger(ADC_BASE, 2);
//값 읽기
ADCProcessorTrigger(ADC_BASE, 2);
while (!ADCIntStatus(ADC_BASE, 2, false))
;
ADCSequenceDataGet(ADC_BASE, 2, &ADC_resultValue2);
}
void SensorInit(void){
uint32_t sensorSetFlag;
SENSOR_VERSION.word = 0x14081000LU;
SubsystemInit(SENSOR, MESSAGE, "SENSOR", SENSOR_VERSION);
//Enable register access to ADC0
SysCtlPeripheralEnable( SYSCTL_PERIPH_ADC0 );
//Enable register access to GPIO Port B
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
// Set the sensor outputs as outputs
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_5 | GPIO_PIN_7);
// Select the analog ADC function for these pins.
GPIOPinTypeADC( GPIO_PORTB_BASE, GPIO_PIN_4); //Sensor 1 In
GPIOPinTypeADC( GPIO_PORTB_BASE, GPIO_PIN_6); //Sensor 2 In
//Set up the ADC sequencer
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_ALWAYS, 3);
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH10|ADC_CTL_CMP0);
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH10|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 0);
// Read from EEPROM to see if this is the first time this is being setup
EEPROMRead(&sensorSetFlag, EE_ADDR_SENSOR_SETUP, sizeof(sensorSetFlag));
if(sensorSetFlag == EE_SENSOR_SET){
EEPROMRead(&sensorTimeout, EE_ADDR_SENSOR_TIMEOUT, sizeof(sensorTimeout));
EEPROMRead(&sensorThreshold, EE_ADDR_SENSOR_THRESHOLD, sizeof(sensorThreshold));
LogMsg(SENSOR, MESSAGE, "Sensor Timeout Restored : %k seconds", sensorTimeout/1000);
LogMsg(SENSOR, MESSAGE, "Sensor Threshold Restored To : %k", sensorThreshold);
} else {
sensorSetFlag = EE_SENSOR_SET;
EEPROMProgram(&sensorTimeout, EE_ADDR_SENSOR_TIMEOUT, sizeof(sensorTimeout));
EEPROMProgram(&sensorThreshold, EE_ADDR_SENSOR_THRESHOLD, sizeof(sensorThreshold));
EEPROMProgram(&sensorSetFlag, EE_ADDR_SENSOR_SETUP, sizeof(sensorSetFlag));
LogMsg(SENSOR, MESSAGE, "No sensor values saved, default values used. Threshold: %k, Timeout: %k", sensorThreshold, sensorTimeout);
}
//Set up the comparator
ADCComparatorConfigure(ADC0_BASE, 0, ADC_COMP_TRIG_NONE|ADC_COMP_INT_LOW_HONCE );
ADCComparatorRegionSet(ADC0_BASE, 0, sensorThreshold - SENSOR_HYST_WINDOW, sensorThreshold + SENSOR_HYST_WINDOW);
ADCComparatorReset(ADC0_BASE, 0, true, true);
ADCComparatorIntEnable(ADC0_BASE, 0);
ADCIntRegister(ADC0_BASE, 0, Sensor1ISR);
ADCIntEnable(ADC0_BASE, 0);
}
