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);
}
//*****************************************************************************
//
//! \brief adc api interrupt state and data get test.
//!
//! \return None.
//
//*****************************************************************************
static void adcIntTest(void)
{
//
// Set the length of converter
//
// ADCConverLenSet(ADC1_BASE, 1, 1);
//
// Test ADC configure API
//
// ADCSequenceIndexSet(ADC1_BASE, ulAdcSeqNo, ulAdcSeqNo);
// ADCSampLenSet(ADC1_BASE, 14, ADC_SAMPTIME_7_5_CYCLE);
//
// A/D interrupt enable
//
ADCIntEnable(ADC_BASE, ADC_INT_END_CONVERSION);
xIntEnable(INT_ADC);
xADCIntCallbackInit(ADC_BASE, ADC0IntFucntion);
//
// A/D configure
//
ADCConfigure(ADC_BASE, ADC_INPUT_SINGLE, ADC_OP_CONTINUOUS, ADC_TRIGGER_PROCESSOR);
ADCProcessorTrigger(ADC_BASE);
TestAssertQBreak("T", "xadc interrupt function error!", 0xFFFFFFFF);
}
//*****************************************************************************
//
//! 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);
}
//模数转换初始化
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);
}
// 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);
}
//******************************************************************************
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);
}
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;
*/
}
//*****************************************************************************
//
//! Ininite the ADC
//!
//! \param None
//!
//! This function ininite the ADC including clock source and enable ADC
//!
//! \return none
//
//*****************************************************************************
void ADConvert(void)
{
unsigned long ulAdcSeqNo[] = {0};
xSysCtlClockSet(72000000, xSYSCTL_OSC_MAIN | xSYSCTL_XTAL_8MHZ);
xSysCtlDelay(10000);
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_GPIOA);
//
// configure GPIO pin as ADC function
//
xSPinTypeADC(ADC0, PA0);
//
// Reset ADC
//
xSysCtlPeripheralReset(xSYSCTL_PERIPH_ADC1);
//
// Set ADC clock source
//
xSysCtlPeripheralClockSourceSet(xSYSCTL_ADC0_MAIN, 4);
//
// Enable ADC clock
//
xSysCtlPeripheralEnable(xSYSCTL_PERIPH_ADC1);
//
// Set the length of converter
//
ADCConverLenSet(ADC1_BASE, 1, 1);
//
// Set the Index of converter Sequence
//
ADCSequenceIndexSet(ADC1_BASE, ulAdcSeqNo, ulAdcSeqNo);
ADCSampLenSet(ADC1_BASE, 0, 128);
//
// A/D interrupt enable
//
ADCIntEnable(ADC1_BASE, ADC_INT_END_CONVERSION);
xIntEnable(xINT_ADC0);
xADCIntCallbackInit(ADC1_BASE, ADC0IntFucntion);
//
// Software trigger enable
//
ADCProcessorTrigger(ADC1_BASE);
//
// A/D configure
//
ADCRegularConfigure(ADC1_BASE, ADC_OP_SINGLE, ADC_TRIGGER_PROCESSOR);
ADCDataRegularGet(ADC1_BASE, ADC_MODE_NORMAL);
}
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
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;
}
//*****************************************************************************
//
//! 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);
}
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);
}
void InitializeADC()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC); //Enable the clock to the ADC module
ADCSequenceDisable(ADC0_BASE, 3); //Disable Sequence 3 in order to safely configure ADC
//Configure Sequence 3: processor trigger, priority=0
ADCSequenceConfigure(ADC_BASE, 3, ADC_TRIGGER_TIMER, 0);
//Configure Sequence 3, step 0, analog input 0 | interrupt | end of sequence
ADCSequenceStepConfigure(ADC_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 3); //Enable sequence 3 and it's interrupt
ADCIntEnable(ADC0_BASE, 3); //Enable interrupt
}
void initHW_ADC(){
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
//SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ADCReferenceSet(ADC0_BASE, ADC_REF_INT); //Set reference to the internal reference ,You can set it to 1V or 3 V
//ADCReferenceSet(ADC1_BASE, ADC_REF_INT);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3); //Ain0
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_2); //Ain1
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_1); //Ain2
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0); //Ain3
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3); //Ain4
/// imposta il sequencer 0, che ha 8 letture
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
//i sensori vengono numerati da quello davanti in senso antiorario
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0);
/// PE.2
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH1);
// PE.1
ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH2 );
//GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0); //Ain3
// PE.0
ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH3 );
/// PD.3
ADCSequenceStepConfigure(ADC0_BASE, 0, 4, ADC_CTL_CH4 );
/// PD.2
ADCSequenceStepConfigure(ADC0_BASE, 0, 5, ADC_CTL_CH5 | ADC_CTL_IE | ADC_CTL_END);
/// abilita il sequencer 0
ADCSequenceEnable(ADC0_BASE, 0);
/// messaggio di benvenuto
PRINTF("Ciao: stai provando il converntitore AD!\n");
/// abilta l'interruzione del sequencer 0
ADCIntClear(ADC0_BASE, 0);
//
// Enable the ADC interrupt.
//
IntEnable(INT_ADC0SS0);
ADCIntEnable(ADC0_BASE, 0);
//
// Enable processor interrupts.
//
IntMasterEnable();
}
void InitADC3Transfer(void) {
// Set data as not ready to be processed
adcNode[0].g_ucDataReady = 0;
// Init buffers by setting them all to 0
// Should go from 0 to 2048
for (uIdx = 0; uIdx < NUM_SAMPLES ; uIdx++) {
g_ulADCValues[uIdx] = 0;
}
SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralReset(SYSCTL_PERIPH_ADC0);
IntEnable(INT_UDMAERR);
uDMAEnable();
uDMAControlBaseSet(ucControlTable);
//
// Configure the ADC to use PLL at 480 MHz divided by 24 to get an ADC
// clock of 20 MHz.
//
//ADCClockConfigSet(ADC0_BASE, ADC_CLOCK_SRC_PLL | ADC_CLOCK_RATE_FULL, 24);
ADCSequenceConfigure(ADC0_BASE, SEQUENCER, ADC_TRIGGER_TIMER, 0);
#ifdef test_w_internal_temp
ADCSequenceStepConfigure(ADC0_BASE, SEQUENCER, 0, ADC_CTL_TS |
ADC_CTL_IE | ADC_CTL_END); // internal temperator
#endif
#ifdef test_w_pe3
ADCSequenceStepConfigure(ADC0_BASE, SEQUENCER, 0, ADC_CTL_CH0 |
ADC_CTL_IE | ADC_CTL_END); //PE3
#endif
ADCSequenceEnable(ADC0_BASE, SEQUENCER);
ADCIntEnable(ADC0_BASE, SEQUENCER);
uDMAChannelAttributeDisable(UDMA_CHANNEL_ADC3,
UDMA_ATTR_ALTSELECT | UDMA_ATTR_USEBURST |
UDMA_ATTR_HIGH_PRIORITY |
UDMA_ATTR_REQMASK);
uDMAChannelControlSet(UDMA_CHANNEL_ADC3 | UDMA_PRI_SELECT,
UDMA_SIZE_16 | UDMA_SRC_INC_NONE |
UDMA_DST_INC_16 | UDMA_ARB_1);
uDMAChannelTransferSet(UDMA_CHANNEL_ADC3 | UDMA_PRI_SELECT,
UDMA_MODE_BASIC, (void *) (ADC0_BASE + ADC_O_SSFIFO3 + (0x20 * UDMA_ARB_1)),
g_ulADCValues, UDMA_XFER_MAX);
uDMAChannelEnable(UDMA_CHANNEL_ADC3);
}
void adc_init(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
//Set what the timer runs to
TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet() / FREQ );
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);
ADCSequenceDisable(ADC0_BASE, 1);
ADCSequenceConfigure(ADC_BASE, 1, ADC_TRIGGER_TIMER, 0);
ADCSequenceStepConfigure(ADC_BASE, 1, 0, ADC_CTL_CH0);
ADCSequenceStepConfigure(ADC_BASE, 1, 1, ADC_CTL_CH1);
ADCSequenceStepConfigure(ADC_BASE, 1, 2, ADC_CTL_CH2);
ADCSequenceStepConfigure(ADC_BASE, 1, 3, ADC_CTL_CH3 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
ADCIntEnable(ADC0_BASE, 1);
TimerEnable(TIMER1_BASE, TIMER_A);
//Set timer 1A to trigger the ADC
TimerControlTrigger(TIMER1_BASE, TIMER_A, 1);
//May be useful:
//SysCtlADCSpeedGet();
ADCIntClear(ADC0_BASE, 1);
ADCIntEnable(ADC0_BASE, 1);
IntEnable(INT_ADC0SS1);
}
//*****************************************************************************
//
//! \brief adc api configure test of Interrupt enable.
//!
//! \return None.
//
//*****************************************************************************
static void adcIntEnableTest(void)
{
unsigned long ulAdcIntFlags[] = {ADC_INT_END_CONVERSION, ADC_INT_COMP0};
unsigned long i, ulReadVal, ulTemp;
//
// Test ADC1 configure API
//
for(i=0; i<2; i++)
{
ADCIntEnable(ADC_BASE, ulAdcIntFlags[i]);
ulReadVal = (xHWREG(ADC_BASE + ADC0_SC1A) & ulAdcIntFlags[i]);
ulTemp = ulAdcIntFlags[i] & ulReadVal;
TestAssert(ulReadVal == ulTemp, "xadc API error!" );
}
}
//============================================================================//
//== ADC初始化函数 ==//
//============================================================================//
//==说明: 对于测试将方波滤波成为正弦波的测试,需要改变AD的采样频率 ==//
//== SYSCTL_ADCSPEED_1MSPS // 采样速率：1M次采样/秒 ==//
//== SYSCTL_ADCSPEED_500KSPS // 采样速率：500K次采样/秒 ==//
//== SYSCTL_ADCSPEED_250KSPS // 采样速率：250K次采样/秒 ==//
//== SYSCTL_ADCSPEED_125KSPS // 采样速率：125K次采样/秒 ==//
//== 频率高的方波AD采样频率应适当增加 ==//
//==入口参数: 无 ==//
//==出口参数: 无 ==//
//==返回值: 无 ==//
//============================================================================//
void ADCInit(void)
{
SysCtlPeriEnable(SYSCTL_PERIPH_ADC); // 使能ADC模块
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS); // 设置ADC采样速率
ADCSequDisable(ADC_BASE, 0); // 配置前先禁止采样序列
// 采样序列配置：ADC基址，采样序列编号，触发事件，采样优先级
ADCSequConfig(ADC_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
// 采样步进设置：ADC基址，采样序列编号，步值，通道设置(ADC0转换完后停止触发中断)
ADCSequStepConfig(ADC_BASE, 0, 0, ADC_CTL_CH0 |
ADC_CTL_END |
ADC_CTL_IE);
ADCIntEnable(ADC_BASE, 0); // 使能ADC中断
IntEnable(INT_ADC0); // 使能ADC采样序列中断
ADCIntRegister(ADC_BASE, 0, ADC_ISR);
IntMasterEnable( ); // 使能处理器中断
ADCSequEnable(ADC_BASE, 0); // 使能采样序列
}
int ADC_Collect(unsigned int channelNum, unsigned int fs,
void (*task)(unsigned short)){
unsigned long config;
ADCTask = task;
// 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;
}
ADCSequenceDisable(ADC0_BASE, 0);
// 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
config |= ADC_CTL_END | ADC_CTL_IE;
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, config);
// Disabling Timer0A for configuration
TimerDisable(TIMER0_BASE, TIMER_A);
// Configure as 16 bit timer and trigger ADC conversion
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet()/ fs);
TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ADCSequenceOverflowClear(ADC0_BASE, 0);
ADCSequenceUnderflowClear(ADC0_BASE, 0);
ADCIntClear(ADC0_BASE, 0);
ADCSequenceEnable(ADC0_BASE, 0);
TimerEnable(TIMER0_BASE, TIMER_A);
TimerIntEnable(TIMER0_BASE, TIMER_A);
ADCIntEnable(ADC0_BASE, 0);
IntEnable(INT_ADC0SS0);
return 1;
}
void adc_init(void) {
unsigned char i;
for (i=ROLLING_VALUES_COUNT; i--;) {
rolling_values[i] = 0;
}
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5);
GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_4);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceDisable(ADC0_BASE, 0);
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH11);
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH10 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 0);
ADCIntEnable(ADC0_BASE, 0);
ADCIntClear(ADC0_BASE, 0);
IntEnable(ADC_INT_SS0);
}
void init_7017(void) {
adc_mutex = xSemaphoreCreateMutex();
if (adc_mutex == NULL) {
return;
}
SysCtlPeripheralEnable(MODULE_ADC_PERIPH);
MODULE_CONFIG_GPIO();
ADCSequenceDisable(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
ADCSequenceConfigure(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, 0, MODULE_ADC_SEQUENCE_1_CONFIG);
ADCSequenceStepConfigure(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, 1, MODULE_ADC_SEQUENCE_1_CONFIG);
ADCIntRegister(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, ADCIntHandler);
ADCIntEnable(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
ADCSequenceEnable(ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
ADCIntClear(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
ADCProcessorTrigger(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
}
int main(void)
{
unsigned long adc_result[16];
unsigned long cnt;
float temperature;
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Configure low-level I/O to use printf()
//
llio_init(115200);
//
// Configure ADC
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC);
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);
// ADC sequence #0 - setup with 2 conversions
ADCSequenceDisable(ADC_BASE, 0);
ADCSequenceConfigure(ADC_BASE, 0, ADC_TRIGGER_TIMER, 0);
ADCIntRegister(ADC_BASE, 0, ADCIntHandler);
ADCIntEnable(ADC_BASE, 0);
// sequence step 0 - channel 0
ADCSequenceStepConfigure(ADC_BASE, 0, 0, ADC_CTL_CH0);
// sequence step 1 - internal temperature sensor. Generate Interrupt & End of Sequence
ADCSequenceStepConfigure(ADC_BASE, 0, 1, ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC_BASE, 0);
//
// Configure Timer to trigger ADC
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure( TIMER0_BASE, TIMER_CFG_32_BIT_PER );
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
TimerLoadSet( TIMER0_BASE, TIMER_A, SysCtlClockGet() / 2 ); // 2Hz trigger
TimerEnable( TIMER0_BASE, TIMER_A );
printf("\r\n\r\nADC 2 Channel Example\r\n");
//
// Loop forever.
//
while(1)
{
cnt = ADCSequenceDataGet(ADC_BASE, 0, adc_result);
if (cnt == 2)
{
// Calculate temperature
temperature = (2.7 - (float)adc_result[1] * 3.0 / 1024.) * 75. - 55.;
printf("%d,%d,%.1f\r\n", adc_result[0], adc_result[1], temperature);
}
SysCtlSleep();
}
}
void Startup(void) {
//STEP 1: OLED and PWM setup
unsigned long ulPeriod;
//SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
GPIOPinTypePWM(GPIO_PORTG_BASE, GPIO_PIN_1);
ulPeriod = SysCtlClockGet() / 400;
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,PWM_GEN_MODE_UP_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, ulPeriod);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_1, ulPeriod / 16);
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
//STEP 2: Timer setup
//SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
/*TimerState = 0;
TimerIntUnregister(TIMER1_BASE, TIMER_A);
TimerIntRegister(TIMER1_BASE, TIMER_A, IntTimer0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet());
IntEnable(INT_TIMER1A);
TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
TimerEnable(TIMER1_BASE, TIMER_A);*/
// SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
//STEP 3: Button pad setup
TrainState = 0;
GPIOPortIntUnregister(GPIO_PORTE_BASE);
GPIOPortIntRegister(GPIO_PORTE_BASE,IntGPIOe);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 );
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 , GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 , GPIO_FALLING_EDGE);
GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 );
IntEnable(INT_GPIOE);
IntPrioritySet( INT_GPIOE, configKERNEL_INTERRUPT_PRIORITY);
//STEP 4: Frequency count setup
tempCount = 0;
frequencyCount = 0;
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_3);
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
GPIOPortIntUnregister(GPIO_PORTF_BASE);
GPIOPortIntRegister(GPIO_PORTF_BASE,IntGPIOf);
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_RISING_EDGE);
GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_3);
IntEnable(INT_GPIOF);
//STEP 5: UART setup
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
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));
IntEnable(INT_UART0);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
IntPrioritySet( INT_UART0, configKERNEL_INTERRUPT_PRIORITY);
//STEP 6: pin setup
/*SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, PORT_DATA);*/
//STEP 7: ADC SETUP
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceDisable(ADC0_BASE,0);
ADCSequenceDisable(ADC0_BASE,1);
ADCSequenceDisable(ADC0_BASE,2);
ADCSequenceDisable(ADC0_BASE,3);
GPIOPinTypeADC(ADC0_BASE, 0xF);
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 0);
ADCSequenceEnable(ADC0_BASE, 1);
ADCSequenceEnable(ADC0_BASE, 2);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 0);
ADCIntClear(ADC0_BASE, 1);
ADCIntClear(ADC0_BASE, 2);
ADCIntClear(ADC0_BASE, 3);
ADCIntEnable(ADC0_BASE, 0);
ADCIntEnable(ADC0_BASE, 1);
ADCIntEnable(ADC0_BASE, 2);
ADCIntEnable(ADC0_BASE, 3);
//IntEnable(INT_ADC0);
//IntPrioritySet(INT_ADC, 50);
//IntEnable(INT_ADC0);
//ADCIntClear(ADC0_BASE, 0);
return;
}
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC sample sequence 3
//! - Timer 0 subtimer A
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(void)
{
unsigned short usController;
//
// Set the initial state of the touch screen driver's state machine.
//
g_ulTSState = TS_STATE_INIT;
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Determine which display controller is in use and, from this, determine
// what the sense of the Y axis must be. The -F03 version of the display
// containing an ILI9320 controller reverses the sense of the Y axis
// relative to the later -F05 and -F02 versions containing ILI9325 and
// ILI9328 controllers respectively.
//
usController = Formike240x320x16_ILI9320ControllerIdGet();
g_bReverseLongAxis = ((usController != 0x9320) ? true : false);
//
// Enable the peripherals used by the touch screen interface.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
//
// 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,
ADC_CTL_CH6 | 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 GPIOs used to drive the touch screen layers.
//
GPIOPinTypeGPIOOutput(TS_X_BASE, TS_XP_PIN | TS_XN_PIN);
GPIOPinTypeGPIOOutput(TS_Y_BASE, TS_YP_PIN | TS_YN_PIN);
GPIOPinWrite(TS_X_BASE, TS_XP_PIN | TS_XN_PIN, 0x00);
GPIOPinWrite(TS_Y_BASE, TS_YP_PIN | TS_YN_PIN, 0x00);
//
// See if the ADC trigger timer has been configured, and configure it only
// if it has not been configured yet.
//
if((HWREG(TIMER0_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0)
{
//
// Configure the timer to trigger the sampling of the touch screen
// every millisecond.
//
TimerConfigure(TIMER0_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PERIODIC |
TIMER_CFG_B_PERIODIC));
TimerLoadSet(TIMER0_BASE, TIMER_A, (SysCtlClockGet() / 1000) - 1);
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
//
// Enable the timer. At this point, the touch screen state machine
// will sample and run once per millisecond.
//
TimerEnable(TIMER0_BASE, TIMER_A);
}
}
//*****************************************************************************
//
//! ADC conversion Task.
//!
//! This task function do all the work related to the ADC conversion real
//!
//! \return None.
//
//*****************************************************************************
Void _task_ADC(UArg arg0, UArg arg1)
{
// initialize ADC
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_IE | ADC_CTL_CH0 | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 0);
ADCSoftwareOversampleConfigure(ADC0_BASE, 0, 64);
ADCIntClear(ADC0_BASE, 0);
ADCIntEnable(ADC0_BASE, 0);
// data from ADC
uint32_t AdcDataRaw = 0;
uint32_t AdcDataRaw2 = 0;
uint32_t AdcDataRaw3 = 0;
int32_t ReliableMeasure = 0;
uint32_t MeasureEnable = 0;
uint32_t EventPosted;
while(1)
{
EventPosted = Event_pend(FestoEvents,
Event_Id_NONE,
FESTO_EVENT_ADC_START,
0);
if (EventPosted & FESTO_EVENT_ADC_START)
{
MeasureEnable = 1;
ReliableMeasure = 99;
}
else
{
if (MeasureEnable == 1)
{
ADCProcessorTrigger(ADC0_BASE, 0);
while (ADCIntStatus(ADC0_BASE, 0, false) == false);
ADCSequenceDataGet(ADC0_BASE, 0, &AdcDataRaw);
ADCIntClear(ADC0_BASE, 0);
ADCProcessorTrigger(ADC0_BASE, 0);
while (ADCIntStatus(ADC0_BASE, 0, false) == false);
ADCSequenceDataGet(ADC0_BASE, 0, &AdcDataRaw2);
ADCIntClear(ADC0_BASE, 0);
AdcDataRaw3 = 0.5 * (AdcDataRaw + AdcDataRaw2);
MeasureEnable = 2;
}
else if (MeasureEnable == 2)
{
ADCProcessorTrigger(ADC0_BASE, 0);
while (ADCIntStatus(ADC0_BASE, 0, false) == false);
ADCSequenceDataGet(ADC0_BASE, 0, &AdcDataRaw);
ADCIntClear(ADC0_BASE, 0);
ADCProcessorTrigger(ADC0_BASE, 0);
while (ADCIntStatus(ADC0_BASE, 0, false) == false);
ADCSequenceDataGet(ADC0_BASE, 0, &AdcDataRaw2);
ADCIntClear(ADC0_BASE, 0);
AdcDataRaw = 0.5 * (0.5 * (AdcDataRaw + AdcDataRaw2) + AdcDataRaw3);
ReliableMeasure = AdcDataRaw - AdcDataRaw3;
if (ReliableMeasure > 3 || ReliableMeasure < -3)
{
MeasureEnable = 1;
}
else
{
Mailbox_post(ADCMailbox, &AdcDataRaw, BIOS_NO_WAIT);
MeasureEnable = 0;
System_printf("ADC data: %d\n", AdcDataRaw);
System_flush();
}
}
else
{
}
}
Task_sleep(100);
}
}
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);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
//
// Configure the pins to be used as analog inputs.
//
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_2 | GPIO_PIN_3);
//
// Select the external reference for greatest accuracy.
//
//ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V);
//
// Only for LM4F232 Apply workaround for erratum 6.1, in order to use the
// external reference.
//
//SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//HWREG(GPIO_PORTB_BASE + GPIO_O_AMSEL) |= GPIO_PIN_6;
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0); // 1 captures up to 4 samples
//ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); // 1 captures up to 4 samples
//ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ENCODER_CHANNEL_PITCH); // sample pitch
//ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ENCODER_CHANNEL_ROLL | ADC_CTL_IE | ADC_CTL_END); // sample roll
ADCHardwareOversampleConfigure(ADC0_BASE, 64);
//ADCSoftwareOversampleConfigure(ADC0_BASE, 0, 8);
//ADCSoftwareOversampleStepConfigure(ADC0_BASE, 0, 0, (ADC_CTL_CH1 | ADC_CTL_IE | ADC_CTL_END));
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_IE | ADC_CTL_END | ADC_CTL_CH0);
//ADCSoftwareOversampleStepConfigure(ADC0_BASE, 0, 0, (ADC_CTL_CH1 | ADC_CTL_IE | ADC_CTL_END));
//ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0); // sample roll
//ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH1 | ADC_CTL_IE | ADC_CTL_END); // sample roll
//ADCIntRegister(ADC0_BASE,0,ADCIntHandler);
//
// Enable the sequencer and interrupt
//
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntEnable(ADC0_BASE, 3);
IntEnable(INT_ADC3);
//
// Zero the oversample counter and the sum
//
g_ucOversampleCnt = 0;
g_ulSum = 0;
//ADCSequenceEnable(ADC0_BASE, 2);
//ADCIntEnable(ADC0_BASE, 2);
#if 0
//
// Enable the ADC sequencers
//
ADCSequenceEnable(ADC0_BASE, 0);
//
// Flush the ADC sequencers to be sure there is no lingering data.
//
ADCSequenceDataGet(ADC0_BASE, 0, PitchRollAmp);
//
// Enable ADC interrupts
//
ADCIntClear(ADC0_BASE, 0);
ADCIntEnable(ADC0_BASE, 0);
IntEnable(INT_ADC0SS0);
#else
//
// 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, ROM_SysCtlClockGet() / 20000); // 50 us == 20K
ulTimeSysClock = ROM_SysCtlClockGet()/20000;
TimerControlStall(TIMER1_BASE, TIMER_A, true);
TimerControlTrigger(TIMER1_BASE, TIMER_A, true);
//
// Enable the timers.
//
TimerEnable(TIMER1_BASE, TIMER_A);
#endif
new_adc = false;
//
}
//
// Clear outstanding ADC interrupt and enable
//
//ADCIntClear(ADC0_BASE, 2);
//ADCIntEnable(ADC0_BASE, 2);
//IntEnable(INT_ADC2);
//
// Set the zero current to indicate that the initial sampling has just
// begun.
//
g_usCurrentZero = 0xffff;
} // InitADC
//----------------------------------------------------------------------------
// Initialize the ADC
void Init_ADC(void)
{
int i;
// Init buffer
for(i=0; i < ADC_BUFFER_SIZE; i++)
{
// Initialize to approx 65 degrees F
adc_buffer[i] = 475.0;
}
// writes 0x00010000 to RCGC0
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
SysCtlPeripheralReset(SYSCTL_PERIPH_TIMER0);
// Setup timer, 32-bit periodic
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
// The prescaler is not available 32-bit mode
// Load timer value, approx 32Hz
TimerLoadSet(TIMER0_BASE, TIMER_A, 0x17D784);
//TimerLoadSet(TIMER0_BASE, TIMER_A, 0xBEBC);
// Configure timer to trigger ADC
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
// Setup ADC
ADCSequenceDisable(ADC0_BASE, ACTIVE_SS);
// Configure the ADC to trigger off a timer and priority 3 (default)
ADCSequenceConfigure(ADC0_BASE, ACTIVE_SS, ADC_TRIGGER_TIMER, 3);
//
// 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, ACTIVE_SS, 0, ADC_CTL_CH2 | ADC_CTL_IE |
ADC_CTL_END);
ADCHardwareOversampleConfigure(ADC0_BASE, 64);
//
// Since sample sequence 3 is now configured, it must be enabled.
//
ADCSequenceEnable(ADC0_BASE, ACTIVE_SS);
// Enable ADC interrupt
ADCIntEnable(ADC0_BASE, ACTIVE_SS);
IntEnable(INT_ADC0SS3);
// Enable timer
TimerEnable(TIMER0_BASE, TIMER_A);
}
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC sample sequence 3
//! - Timer 1 subtimer A
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(void)
{
//
// Set the initial state of the touch screen driver's state machine.
//
g_ulTSState = TS_STATE_INIT;
//
// Determine which calibration parameter set we will be using.
//
g_plParmSet = g_lTouchParameters[SET_NORMAL];
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Enable the peripherals used by the touch screen interface.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(TS_P_PERIPH);
SysCtlPeripheralEnable(TS_N_PERIPH);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
//
// 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,
ADC_CTL_CH_YP | ADC_CTL_END | ADC_CTL_IE);
ADCSequenceEnable(ADC0_BASE, 3);
//
// Enable the ADC sample sequence interrupt.
//
ADCIntEnable(ADC0_BASE, 3);
IntEnable(INT_ADC3);
//
// Configure the GPIOs used to drive the touch screen layers.
//
GPIOPinTypeGPIOOutput(TS_P_BASE, TS_XP_PIN | TS_YP_PIN);
//
// If no daughter board is installed, set up GPIOs to drive the XN and YN
// signals.
//
if(g_eDaughterType == DAUGHTER_NONE)
{
GPIOPinTypeGPIOOutput(TS_N_BASE, TS_XN_PIN | TS_YN_PIN);
}
GPIOPinWrite(TS_P_BASE, TS_XP_PIN | TS_YP_PIN, 0x00);
if(g_eDaughterType == DAUGHTER_NONE)
{
GPIOPinWrite(TS_N_BASE, TS_XN_PIN | TS_YN_PIN, 0x00);
}
//
// See if the ADC trigger timer has been configured, and configure it only
// if it has not been configured yet.
//
if((HWREG(TIMER1_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0)
{
//
// Configure the timer to trigger the sampling of the touch screen
// every millisecond.
//
TimerConfigure(TIMER1_BASE, (TIMER_CFG_16_BIT_PAIR |
TIMER_CFG_A_PERIODIC |
TIMER_CFG_B_PERIODIC));
TimerLoadSet(TIMER1_BASE, TIMER_A, (SysCtlClockGet() / 1000) - 1);
TimerControlTrigger(TIMER1_BASE, TIMER_A, true);
//
// Enable the timer. At this point, the touch screen state machine
// will sample and run once per millisecond.
//
TimerEnable(TIMER1_BASE, TIMER_A);
}
}
int main(void) {
unsigned long ulPeriod = 0; //Period for Timer0
//Enable all required peripherals
PortFunctionInit();
//Enable console communication with UART
UARTStdioInit(0);
//Set system clock to 40 MHz
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
/*
*
* Timer Configuration
*
*/
//Configure timer to be periodic (counts down and then resets)
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
//Calculate period for a pin toggle freq of 1MHz with 50% duty cycle
ulPeriod = (SysCtlClockGet() / 10) / 2;
TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod - 1);
/*
*
* ADC0 Configuration
*
*/
//Set the ADC sample rate to 500 KSPS
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);
//Disable ADC0 sequencer 3 (so that we can configure it)
ADCSequenceDisable(ADC0_BASE, 3);
//Disable ADC1 sequencer 3 (so that we can configure it)
ADCSequenceDisable(ADC1_BASE, 3);
//Configure ADC0 sequencer 3 to trigger based on TIMER0A
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
//Configure ADC1 sequencer 3 to trigger based on TIMER0A
ADCSequenceConfigure(ADC1_BASE, 3, ADC_TRIGGER_TIMER, 0);
//Configure the ADC0 to flag the interrupt flag when it finishes sampling
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0|ADC_CTL_END|ADC_CTL_IE);
//Configure the ADC1 to flag the interrupt flag when it finishes sampling
ADCSequenceStepConfigure(ADC1_BASE, 3, 0, ADC_CTL_CH1|ADC_CTL_END|ADC_CTL_IE);
//Enable ADC0 sequencer 3
ADCSequenceEnable(ADC0_BASE, 3);
//Enable ADC1 sequencer 3
ADCSequenceEnable(ADC1_BASE, 3);
//Enable ADC0 interrupt, it's redundant with line 80 but has to be done
ADCIntEnable(ADC0_BASE, 3);
//Enable ADC1 interrupt, it's redundant with line 89 but has to be done
ADCIntEnable(ADC1_BASE, 3);
//Enable timer
TimerEnable(TIMER0_BASE, TIMER_A);
//Configure TIMER0A to be the ADC sample trigger
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
//Clear any interrupts
ADCIntClear(ADC0_BASE, 3);
ADCIntClear(ADC1_BASE, 3);
//Begin sampling
ADCIntEnable(ADC0_BASE, 3);
ADCIntEnable(ADC1_BASE, 3);
//Turn on ADC0 sequence interrupts for sequence 3
IntEnable(INT_ADC0SS3);
//Turn on ADC1 sequence interrupts for sequence 3
IntEnable(INT_ADC1SS3);
UARTprintf("ADC0 Configured\n");
UARTprintf("ADC1 Configured\n");
//Enable all interrupts
IntMasterEnable();
while(1) {
}
}
void joystick_enable(void){
GPIOPinIntEnable(JOY_PORT, JOY_MASK);
ADCIntEnable(ADC0_BASE, 0);
ADCIntEnable(ADC0_BASE, 1);
// GPIOPinIntEnable(JOG_Z_PORT, JOG_Z_MASK);
}