int main2(void)
{
#if PROFILING == 1
volatile unsigned long delay;
#endif
/* Initialize 8MHz clock */
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_8MHZ | SYSCTL_OSC_MAIN);
OLED_Init(15);
ADC_Init(1000);
ADC_Open(0);
ADC_Open(1);
SH_Init();
OS_Init();
OS_MailBox_Init();
SH_Init();
//********initialize communication channels
OS_MailBox_Init();
OS_Fifo_Init(32);
NumCreated = 0;
NumSamples = 0;
MaxJitter = 0; // OS_Time in 20ns units
MinJitter = 10000000;
#if PROFILING
// intialize port b pins as specified by PINS mask
// for digital output for use in profiling threads
SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOB;
delay = SYSCTL_RCGC2_R;
GPIO_PORTB_DIR_R |= PINS;
GPIO_PORTB_DEN_R |= PINS;
GPIO_PORTB_DATA_R &= ~PINS;
#endif
// testing/debugging stuff
OS_Add_Periodic_Thread(&DAS,2,1);
// OS_AddButtonTask(&dummyButtonTask, 1);
OS_AddButtonTask(&ButtonPush, 1);
OS_AddDownTask(&ButtonPush, 1);
// NumCreated += OS_AddThread(&jerkTask, 0, 6);
// NumCreated += OS_AddThread(&dummyTask3, 0, 7);
// NumCreated += OS_AddThread(&dummyTask1, 0, 2);
NumCreated += OS_AddThread(&PID, 128, 5);
// NumCreated += OS_AddThread(&dummyTask2, 0, 2);
NumCreated += OS_AddThread(&Consumer, 128, 0);
NumCreated += OS_AddThread(&SH_Shell, 128, 6);
OS_Launch(TIMESLICE);
/* Loop indefinitely */
while(1);
}
ADC_ContinuousScan (void)
{
/* Init System, IP clock and multi-function I/O
In the end of SYS_Init() will issue SYS_LockReg()
to lock protected register. If user want to write
protected register, please issue SYS_UnlockReg()
to unlock protected register if necessary */
SysInit();
/* Init UART0 for printf */
UART0_Init();
printf("\nThis sample code demonstrate ADC continuous scan conversion\n");
printf("It convert channel 0,1,2 continuously and print conversion result\n");
// Enable channel 0,1,2
ADC_Open(ADC, ADC_INPUT_MODE_SINGLE_END, ADC_OPERATION_MODE_CONTINUOUS, (ADC_CH_0_MASK | ADC_CH_1_MASK | ADC_CH_2_MASK));
// Power on ADC
ADC_POWER_ON(ADC);
// Enable ADC ADC_IF interrupt
ADC_EnableInt(ADC, ADC_ADF_INT);
NVIC_EnableIRQ(ADC_IRQn);
ADC_START_CONV(ADC);
while(1);
}
int ADC_Collect(unsigned int channelNum, unsigned int period,unsigned short buffer[], unsigned int numberOfSamples){
int sampleCounter = 0;
ADC_Open(channelNum);
TIMER0_CTL_R = 0x00000000; // disable timer0A during setup
TIMER0_TAILR_R = period-1; // start value for trigger
TIMER0_CTL_R |= 0x00000001; // enable timer0A 16-b, periodic, no interrupts
//ask if this is correct setup. what about timer value? roll over
while(sampleCounter < numberOfSamples)
{
buffer[sampleCounter++] = ADC_In();
}
return 0;
}
void initialize()
{
IO::pinMode(MUX_ADR0_PIN, OUTPUT);
IO::pinMode(MUX_ADR1_PIN, OUTPUT);
IO::pinMode(MUX_ADR2_PIN, OUTPUT);
IO::pinMode(V_IN_PIN, ANALOG_INPUT);
IO::pinMode(OUTPUT_VOLTAGE_MINUS_PIN, ANALOG_INPUT);
IO::pinMode(SMPS_CURRENT_PIN, ANALOG_INPUT);
IO::pinMode(OUTPUT_VOLTAGE_PLUS_PIN, ANALOG_INPUT);
IO::pinMode(DISCHARGE_CURRENT_PIN, ANALOG_INPUT);
IO::pinMode(MUX0_Z_D_PIN, ANALOG_INPUT_DISCHARGE);
IO::digitalWrite(MUX0_Z_D_PIN, 0);
//initialize internal temperature sensor
SYS->TEMPCR |= 1;
//initialize TIMER 1 (mux ADC capacitor discharge)
CLK_EnableModuleClock(TMR1_MODULE);
CLK_SetModuleClock(TMR1_MODULE,CLK_CLKSEL1_TMR1_S_HCLK,CLK_CLKDIV_UART(1));
//TODO: 50kHz ??
TIMER_Open(TIMER1, TIMER_ONESHOT_MODE, 1000000 / ADC_CAPACITOR_DISCHARGE_DELAY_US);
TIMER_EnableInt(TIMER1);
NVIC_EnableIRQ(TMR1_IRQn);
NVIC_SetPriority(TMR1_IRQn, ADC_C_DISCHARGE_IRQ_PRIORITY);
//initialize ADC
//init clock
CLK_EnableModuleClock(ADC_MODULE);
CLK_SetModuleClock(ADC_MODULE, CLK_CLKSEL1_ADC_S_HCLK, CLK_CLKDIV_ADC(CLK_GetHCLKFreq()/ADC_CLOCK_FREQUENCY));
//__HXT/ADC_CLOCK_FREQUENCY));
/* Set the ADC operation mode as burst, input mode as single-end and enable the analog input channel 2 */
ADC_Open(ADC, ADC_ADCR_DIFFEN_SINGLE_END, ADC_ADCR_ADMD_BURST, 0x1 << 2);
ADC_SET_DMOF(ADC, ADC_ADCR_DMOF_UNSIGNED_OUTPUT);
/* Power on ADC module */
ADC_POWER_ON(ADC);
/* clear the A/D interrupt flag for safe */
ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);
/* Enable the ADC interrupt */
ADC_EnableInt(ADC, ADC_ADF_INT);
NVIC_EnableIRQ(ADC_IRQn);
NVIC_SetPriority(ADC_IRQn, ADC_IRQ_PRIORITY);
current_input_ = 0;
startConversion();
}
int32_t main (void)
{
uint32_t u32Result;
/* Init System, IP clock and multi-function I/O
In the end of SYS_Init() will issue SYS_LockReg()
to lock protected register. If user want to write
protected register, please issue SYS_UnlockReg()
to unlock protected register if necessary */
SYS_Init();
/* Init UART0 for printf */
UART0_Init();
printf("\n\nCPU @ %dHz\n", SystemCoreClock);
printf("\nThis sample code demonstrate ADC single mode conversion\n");
printf("It convert channel 0 and print conversion result\n");
// Enable channel 0
ADC_Open(ADC, 0, ADC_OPERATION_MODE_SINGLE, ADC_CH_0_MASK);
// Set reference voltage to AVDD
ADC_SET_REF_VOLTAGE(ADC, ADC_REFSEL_POWER);
// Power on ADC
ADC_POWER_ON(ADC);
// Enable ADC ADC_IF interrupt
ADC_EnableInt(ADC, ADC_ADF_INT);
NVIC_EnableIRQ(ADC_IRQn);
u8ADF = 0;
ADC_START_CONV(ADC);
while (u8ADF == 0);
u32Result = ADC_GET_CONVERSION_DATA(ADC, 0);
printf("Channel 0 conversion result is 0x%x\n",u32Result);
ADC_DisableInt(ADC, ADC_ADF_INT);
while(1);
}
int32_t main (void)
{
/* Init System, IP clock and multi-function I/O
In the end of SYS_Init() will issue SYS_LockReg()
to lock protected register. If user want to write
protected register, please issue SYS_UnlockReg()
to unlock protected register if necessary */
SYS_Init();
/* Init UART to 115200-8n1 for print message */
UART_Open(UART0, 115200);
printf("\nThis sample code demonstrate PWM channel 0 trigger ADC function\n");
/* Enable channel 5 */
ADC_Open(ADC, 0, 0, 0x01 << 5);
/* Power on ADC */
ADC_POWER_ON(ADC);
/* Enable PWM trigger */
ADC_EnableHWTrigger(ADC, ADC_TRIGGER_BY_PWM, ADC_FALLING_EDGE_TRIGGER);
/* Enable ADC convert complete interrupt */
ADC_EnableInt(ADC, ADC_ADIF_INT);
NVIC_EnableIRQ(ADC_IRQn);
/* PWM frequency is 100Hz, duty 30% */
PWM_ConfigOutputChannel(PWM, 0, 100, 30);
/* Enable output PWM channel 0 */
PWM_EnableOutput(PWM, 0x1);
/* Set PWM channel 0 to center-aligned mode */
PWM_SET_ALIGNED_TYPE(PWM, 0, PWM_CENTER_ALIGNED);
/* Enable PWM channel 0 center-triggered ADC */
PWM_EnableADCTrigger(PWM, 0, PWM_TRIGGER_ADC_CNTR_IS_CNR);
/* PWM Start */
PWM_Start(PWM, 0x1);
while(1);
}
//*******************lab 5 main **********
int main(void){ // lab 5 real main
OS_Init(); // initialize, disable interrupts
Running = 0; // robot not running
DataLost = 0; // lost data between producer and consumer
NumSamples = 0;
//********initialize communication channels
OS_Fifo_Init(512); // ***note*** 4 is not big enough*****
ADC_Open();
ADC_Collect(0, 1000, &Producer); // start ADC sampling, channel 0, 1000 Hz
//*******attach background tasks***********
OS_AddButtonTask(&ButtonPush,2);
OS_AddDownTask(&DownPush,3);
OS_AddPeriodicThread(disk_timerproc,TIME_1MS,5);
NumCreated = 0 ;
// create initial foreground threads
NumCreated += OS_AddThread(&Interpreter,128,2);
// NumCreated += OS_AddThread(&IdleTask,128,7); // runs when nothing useful to do
OS_Launch(TIMESLICE); // doesn't return, interrupts enabled in here
return 0; // this never executes
}
// ************ OS_Init ******************
// initialize operating system, disable interrupts until OS_Launch
// initialize OS controlled I/O: serial, ADC, systick, select switch and timer2
// input: none
// output: non
void OS_Init(void) {
int i; // Used for indexing
// Disable interrupts
OS_DisableInterrupts();
// Setting the clock to 50 MHz
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
// Initialze peripherals
UART0_Init();
ADC_Open();
Output_Init();
// Select switch
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_RISING_EDGE);
GPIOPinIntClear(GPIO_PORTF_BASE, GPIO_PIN_1);
// Down switch
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1);
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_RISING_EDGE);
GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_1);
// Initialize Timer2A and Timer2B: Periodic Background Threads
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
TimerDisable(TIMER2_BASE, TIMER_A | TIMER_B);
TimerConfigure(TIMER2_BASE, TIMER_CFG_16_BIT_PAIR | TIMER_CFG_A_PERIODIC | TIMER_CFG_B_PERIODIC);
// Initialize Timer0B: Used for time keeping
TimerDisable(TIMER0_BASE, TIMER_B);
TimerConfigure(TIMER0_BASE, TIMER_CFG_16_BIT_PAIR | TIMER_CFG_A_PERIODIC | TIMER_CFG_B_PERIODIC);
TimerIntDisable(TIMER0_BASE, TIMER_TIMB_TIMEOUT);
TimerLoadSet(TIMER0_BASE, TIMER_B, 65535);
TimerPrescaleSet(TIMER0_BASE, TIMER_B, 5); // One unit is 100ns
TimerEnable(TIMER0_BASE, TIMER_B);
// Initialize Timer1A: Used for sleep decrementing
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
TimerDisable(TIMER1_BASE, TIMER_A);
TimerConfigure(TIMER1_BASE, TIMER_CFG_16_BIT_PAIR | TIMER_CFG_A_PERIODIC | TIMER_CFG_B_PERIODIC);
TimerIntDisable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
TimerLoadSet(TIMER1_BASE, TIMER_A, 50000); // Every interrupt is 1ms
// Setting priorities for all interrupts
// To add more, look up correct names in inc\hw_ints.h
IntPrioritySet(FAULT_PENDSV, (0x07 << 5));
IntPrioritySet(FAULT_SYSTICK, (0x06 << 5));
IntPrioritySet(INT_TIMER1A, (0x02 << 5));
IntPrioritySet(INT_UART0, (0x03 << 5));
IntPrioritySet(INT_ADC0SS0, (0x01 << 5));
IntPrioritySet(INT_ADC0SS3, (0x01 << 5));
// Initializing TCBs
for(i = 0; i < MAXTHREADS; i++) {
tcbs[i].valid = INVALID;
tcbs[i].blockedState = '\0';
}
RunPt = &tcbs[0]; // Thread 0 will run first
}
int32_t main (void)
{
uint32_t u32DataCount;
uint32_t u32ErrorCount;
/* Init System, IP clock and multi-function I/O
In the end of SYS_Init() will issue SYS_LockReg()
to lock protected register. If user want to write
protected register, please issue SYS_UnlockReg()
to unlock protected register if necessary */
SYS_Init();
/* Init UART0 for printf */
UART0_Init();
printf("\n\nCPU @ %dHz\n", SystemCoreClock);
printf("\nThis sample code demonstrates ADC PDMA function.\n");
printf("Set ADC operation mode to single cycle scan mode, and enable channel 0,1,2,3\n");
printf("Enable ADC PDMA function, and trigger ADC conversion.\n");
printf("Compare the log of ADC conversion data register with the content of PDMA target buffer.\n");
printf("Finally, print the test result.\n\n");
// Enable channel 0,1,2,3
ADC_Open(ADC, 0, ADC_OPERATION_MODE_SINGLE_CYCLE, ADC_CH_0_MASK | ADC_CH_1_MASK | ADC_CH_2_MASK | ADC_CH_3_MASK);
// Set reference voltage to AVDD
ADC_SET_REF_VOLTAGE(ADC, ADC_REFSEL_POWER);
// Power on ADC
ADC_POWER_ON(ADC);
/* Enable ADC PDMA */
ADC_ENABLE_PDMA(ADC);
/* Configure PDMA channel 1 */
PDMA_INIT();
/* Enable PDMA IRQ */
NVIC_EnableIRQ(PDMA_IRQn);
/* Clear destination buffer */
for(u32DataCount = 0; u32DataCount < ADC_TEST_COUNT; u32DataCount++)
g_au32RxPDMADestination[u32DataCount] = 0;
u32DataCount = 0;
u32ErrorCount = 0;
ADC_START_CONV(ADC);
while(1)
{
uint32_t u32Ch;
if(ADC_GET_INT_FLAG(ADC,ADC_ADF_INT) == 1)
{
ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);
for (u32Ch = 0; u32Ch < 4; u32Ch++)
{
au32AdcData[u32DataCount++] = ADC_GET_CONVERSION_DATA(ADC, u32Ch);
if(u32DataCount >= ADC_TEST_COUNT)
break;
}
if (u32DataCount < ADC_TEST_COUNT)
ADC_START_CONV(ADC);
else
break;
}
}
/* Wait for PDMA transfer down */
while(g_u32PdmaTDoneInt == 0);
/* Compare the log of ADC conversion data register with the content of PDMA target buffer */
for(u32DataCount = 0; u32DataCount < ADC_TEST_COUNT; u32DataCount++)
{
if( au32AdcData[u32DataCount] != (g_au32RxPDMADestination[u32DataCount] & 0xFFF) )
{
printf("*** Count %d, conversion result: 0x%X, PDMA result: 0x%X.\n",
u32DataCount, au32AdcData[u32DataCount], g_au32RxPDMADestination[u32DataCount]);
u32ErrorCount++;
}
}
if (u32ErrorCount == 0)
printf("PASS!\n");
else
printf("FAIL!\n");
while (1);
}
//=============================================================================
// Program entry point
// ~~~~~~~~~~~~~~~~~~~
int main(int argc, char *argv[])
{
int err = 0;
//DWORD dwStart;
//int state = 0;
//.............................................................................
//
// For tidy exit using kill -SIGABRT pid
signal(SIGABRT, &sighandler);
signal(SIGTERM, &sighandler);
signal(SIGINT, &sighandler);
//.............................................................................
//
// Display the compile date and time stamp
printf("adc_test version %d%02d%02d%02d%02d\n", GetCompileYear(),
GetCompileMonth(), GetCompileDay(), GetCompileHour(), GetCompileMinute());
if(ADC_Open() < 0)
{
printf("Failed to open ADC\n");
goto exit;
}
/*
//-------------------------------
// Debug - Kit leds :)
{
#define KIT_DLY 100 // uS
int x;
// Turn on the master ctrl
ADC_PowerSet(m_fd_mzio, CNx, 1);
for(x=0; x<20; x++)
{
ADC_PowerSet(m_fd_mzio, CN1, 1);
usleep(KIT_DLY);
ADC_PowerSet(m_fd_mzio, CN1, 0);
ADC_PowerSet(m_fd_mzio, CN2, 1);
usleep(KIT_DLY);
ADC_PowerSet(m_fd_mzio, CN2, 0);
ADC_PowerSet(m_fd_mzio, CN3, 1);
usleep(KIT_DLY);
ADC_PowerSet(m_fd_mzio, CN3, 0);
ADC_PowerSet(m_fd_mzio, CN2, 1);
usleep(KIT_DLY);
ADC_PowerSet(m_fd_mzio, CN2, 0);
}
// Turn off the master ctrl
ADC_PowerSet(m_fd_mzio, CNx, 1);
}
//-------------------------------
*/
{
int x;
WORD adc_raw = 0;
for(x=0; x<1; x++)
{
ADC_Write(ADC_SINGLE_ENDED_INPUT1 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH1 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT2 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH2 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT3 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH3 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT4 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH4 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT5 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH5 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT6 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH6 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT7 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH7 = 0x%x\n", adc_raw);
ADC_Write(ADC_SINGLE_ENDED_INPUT8 | ADC_5V_UNI);
ADC_Read(&adc_raw);
printf("CH8 = 0x%x\n", adc_raw);
}
}
//.............................................................................
//
/*
printf("Entering main loop\n");
while(mLoop)
{
if(state)
{
//ioctl(m_fd_mzio, MZIO_GPIO_SET_LOW, MZIO_MOD_RESET);
state=0;
}
else
{
//ioctl(m_fd_mzio, MZIO_GPIO_SET_HIGH, MZIO_MOD_RESET);
state=1;
}
// sleep(1); //Sleep for x seconds
}
printf("Exiting main loop\n");
*/
//.............................................................................
//
exit:
ADC_Close();
printf("exit code: %d\n", err);
return err;
}
