/** * I/O task: reads and writes the I/O. */ static void io_task(void *params) { portTickType last_wake_time; int ticks=0; #if (PART != LM3S2110) adc_setup(); #endif #if (DEBUG > 0) lprintf("io_task() running.\r\n"); #endif /* Start our periodic time starting in 3. 2. 1. NOW! */ last_wake_time = xTaskGetTickCount(); while(1) { /* forever loop */ wdt_checkin[wdt_io] = 0; #if (PART != LM3S2110) scan_proc_adc(); #endif /* * Send a char out the serial port every 10 sec. */ if (ticks>=POLL_HZ*10) { lstr("."); ticks=0; } ticks++; vTaskDelayUntil(&last_wake_time, POLL_DELAY); } }
int main(void) { bano_info_t info; uint8_t i; uint8_t j; uint16_t x; info = bano_info_default; info.disable_mask = BANO_DISABLE_ALL; info.disable_mask &= ~BANO_DISABLE_ADC; bano_init(&info); nrf905_set_pa_pwr(3); nrf905_cmd_wc(); adc_setup(); adc_start_free_running(); for (j = 0; j != 4; ++j) { x = 0; for (i = 0; i != 8; ++i) x += adc_read(); x /= i; bano_send_set(0x2a2b, x); bano_send_set(0x2a2b, x); } bano_loop(); bano_fini(); return 0; }
int main(void) { adc_core ad9625_core; ad9625_setup(SPI_DEVICE_ID, 0); jesd204b_setup(AD9625_JESD_BASEADDR, jesd204b_st); jesd204b_gt_setup(gt_link); jesd204b_gt_en_sync_sysref(gt_link); ad9625_spi_write(0, AD9625_REG_TEST_CNTRL, 0x0F); ad9625_spi_write(0, AD9625_REG_OUTPUT_MODE, 0x00); ad9625_spi_write(0, AD9625_REG_TRANSFER, 0x01); ad9625_core.adc_baseaddr = AD9625_CORE_BASEADDR; ad9625_core.dmac_baseaddr = AD9625_DMA_BASEADDR; ad9625_core.no_of_channels = 1; ad9625_core.resolution = 12; adc_setup(ad9625_core); xil_printf("Start capturing data...\n\r"); adc_capture(ad9625_core, 16384, ADC_DDR_BASEADDR); xil_printf("Done.\n\r"); return 0; }
int main(void) { int i; int j = 0; clock_setup(); usart_setup(); printf("hi guys!\n"); adc_setup(); /* green led for ticking */ gpio_mode_setup(LED_DISCO_GREEN_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_DISCO_GREEN_PIN); while (1) { //uint16_t input_adc0 = read_adc_naiive(0); //uint16_t target = input_adc0 / 2; //uint16_t input_adc1 = ((uint16_t)((read_adc_naiive(18) - 760) / 25) + 25); int i; for (i = 0; i < 0x13; i++) { uint16_t input_adc1 = read_adc_naiive(i); printf("tick: %d: adc1_%02X=%d\n", j++, i, input_adc1); } uint32_t reg = ADC_CCR; printf("reg = 0x%08X\r\n", reg); /* LED on/off */ gpio_toggle(LED_DISCO_GREEN_PORT, LED_DISCO_GREEN_PIN); for (i = 0; i < 1000000; i++) { /* Wait a bit. */ __asm__("NOP"); } } return 0; }
int main(void) { int key; adc_setup(); draw_text(); char temp[5]; while (1) { for (i = 0; i < 4; i++) { if (adc_isdone(adcchannels[i]) == 1) adc_sample(adcchannels[i], 128); tsample = adc_getsample(adcchannels[i]); if (! tsample == 0) { sprintf(temp, "%d", adcchannels[i]); term_puts(1, i + 4, temp); sprintf(temp, "%d", adcsmoothing[i]); term_puts(5, i + 4, temp); sprintf(temp, "%d", tsample); term_puts(11, i + 4, temp); } } key = term_getchar(NOWAIT); if (key != -1) { if (handle_kbd((int)key)) break; } } term_clrscr(); term_moveto(1, 1); return 0; }
void hal_setup(){ adc_setup(); //buck_setup(); //usb_setup(); //pwm_setup(); hbridge_setup(); }
int main(void) { int i; int j = 0; clock_setup(); usart_setup(); printf("hi guys!\n"); adc_setup(); dac_setup(); gpio_set_mode(LED_DISCOVERY_USER_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, LED_DISCOVERY_USER_PIN); while (1) { uint16_t input_adc0 = read_adc_naiive(0); uint16_t target = input_adc0 / 2; dac_load_data_buffer_single(target, RIGHT12, CHANNEL_2); dac_software_trigger(CHANNEL_2); uint16_t input_adc1 = read_adc_naiive(1); printf("tick: %d: adc0= %u, target adc1=%d, adc1=%d\n", j++, input_adc0, target, input_adc1); gpio_toggle(LED_DISCOVERY_USER_PORT, LED_DISCOVERY_USER_PIN); /* LED on/off */ for (i = 0; i < 1000000; i++) /* Wait a bit. */ __asm__("NOP"); } return 0; }
int main(void) { m_red(ON); m_usb_init(); while(!m_usb_isconnected()); // wait for a serial msg m_red(OFF); m_clockdivide(0); // set clock frequency to 16MHz adc_setup(); m_disableJTAG(); set(ADCSRA,ADEN);//enable ADC sei();//enable global interrupts set(ADCSRA,ADSC);//start conversion while(1){ if(FLAG){ // compare readings and move motor accordingly m_green(TOGGLE); clear(ADCSRA,ADEN); // Disable ADC m_usb_tx_string("\nF0:"); m_usb_tx_int(ir[0]); m_usb_tx_string("\tF1: "); m_usb_tx_int(ir[1]); m_usb_tx_string("\tF4: "); m_usb_tx_int(ir[2]); FLAG = 0; set(ADCSRA,ADEN); // enable ADC again set(ADCSRA,ADSC);//start next conversion } } }
int main(void) { int i; int j = 0; clock_setup(); usart_setup(); printf("hi guys!\n"); adc_setup(); dac_setup(); /* green led for ticking */ gpio_mode_setup(LED_DISCO_GREEN_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_DISCO_GREEN_PIN); while (1) { uint16_t input_adc0 = read_adc_naiive(0); uint16_t target = input_adc0 / 2; dac_load_data_buffer_single(target, RIGHT12, CHANNEL_2); dac_software_trigger(CHANNEL_2); uint16_t input_adc1 = read_adc_naiive(1); printf("tick: %d: adc0= %u, target adc1=%d, adc1=%d\n", j++, input_adc0, target, input_adc1); /* LED on/off */ gpio_toggle(LED_DISCO_GREEN_PORT, LED_DISCO_GREEN_PIN); for (i = 0; i < 1000000; i++) { /* Wait a bit. */ __asm__("NOP"); } } return 0; }
/* HUVUDPROGRAM */ int main (void) { /* INITIERING */ sysclk_init(); // Systemklocka. board_init(); // Arduino-kort. configure_console(); // Konsoll-/terminalfönster. adc_setup(); // AD-omvandlare. pwm_setup(); // PWM-signal. motor_shield_setup(); // Motor-shield. /* PROCESS 1 - PID-REGLERING */ if (xTaskCreate(pid, (const signed char * const) "PID-reglering", 1024, NULL, 2, NULL) != pdPASS) { printf("Misslyckades med att skapa process för PID-reglering.\r\n"); } /* PROCESS 2 - KOMMUNIKATION MATLAB */ if (xTaskCreate(matlab, (const signed char * const) "Matlab-kommunikation", 1024, NULL, 1, NULL) != pdPASS) { printf("Misslyckades med att skapa process för kommunikation med Matlab.\r\n"); } // Schemaläggning startar. vTaskStartScheduler(); }
int main (void) { // Insert system clock initialization code here (sysclk_init()). board_init(); sysclk_init(); // Insert application code here, after the board has been initialized. //Initiera delay delay_init(); //Initiera LCD LCDInit(); //Initiera AD-omvandlare adc_setup(); //Starta upp LCD setupLCD(); //Initiera interupt configure_tc(); int delay_time = 200000; /* variable determining the length of a delay */ PIOB_init(27); for (;;) /* repeat blink in infinity */ { letterS(delay_time); paus(delay_time * 3); letterO(delay_time); paus(delay_time * 3); letterS(delay_time); paus(delay_time * 5); clearDisplay(); delay(delay_time); printNumber(result); } return 0; }
/***************************************************************************//** * @brief Main function. * * @return 0. *******************************************************************************/ int main(){ uint32_t mode; Xil_ICacheEnable(); Xil_DCacheEnable(); /* AD9467 Setup. */ ad9467_setup(SPI_DEVICE_ID, 0); /* AD9517 Setup. */ ad9517_setup(SPI_DEVICE_ID, 1); // Initialize device. ad9517_power_mode(3, 0); // Set channel 3 for normal operation ad9517_frequency(3, 250000000); // Set the channel 3 frequency to 250Mhz ad9517_update(); // Update registers /* Read the device ID for AD9467 and AD9517. */ xil_printf("\n\r********************************************************************\r\n"); xil_printf(" ADI AD9467-FMC-EBZ Reference Design\n\r"); xil_printf(" AD9467 CHIP ID: 0x%02x\n\r", ad9467_read(AD9467_REG_CHIP_ID)); xil_printf(" AD9467 CHIP GRADE: 0x%02x\n\r", ad9467_read(AD9467_REG_CHIP_GRADE)); xil_printf(" AD9517 CHIP ID: 0x%02x", ad9517_read(AD9517_REG_PART_ID)); xil_printf("\n\r********************************************************************\r\n"); /* AD9467 test. */ adc_setup(0); for (mode = MIDSCALE; mode <= ONE_ZERO_TOGGLE; mode++) // Data pattern checks { adc_test(mode, OFFSET_BINARY); // Data format is offset binary adc_test(mode, TWOS_COMPLEMENT); // Data format is twos complement } xil_printf("Testing done.\n\r"); /* AD9467 Setup for data acquisition */ ad9467_output_invert(0); // Output invert Off ad9467_transfer(); // Synchronously update registers ad9467_output_format(0); // Offset binary ad9467_transfer(); // Synchronously update registers ad9467_reset_PN9(0); // Clear PN9 bit ad9467_transfer(); // Synchronously update registers ad9467_reset_PN23(0); // Clear PN23 bit ad9467_transfer(); // Synchronously update registers ad9467_test_mode(0); // Test mode Off ad9467_transfer(); // Synchronously update registers xil_printf("Start capturing data...\n\r"); while(1) { adc_capture(1024, DDR_BASEADDR); } Xil_DCacheDisable(); Xil_ICacheDisable(); return 0; }
int main(void) { DDRB = 0xFF; // set portB as output adc_setup(); sei(); while(1){ ADCSRA |= (1 << ADSC); } }
// python function setup() static PyObject *py_setup_adc(PyObject *self, PyObject *args) { if (adc_setup()) Py_RETURN_NONE; PyErr_SetString(PyExc_RuntimeError, "Unable to setup ADC system. Possible causes are: \n" " - Module 'ti_am335x_adc' is not loaded \n" " - ADC channels are not enabled in the overlay \n"); return NULL; }
static void trigger_next_adc_job_if_any(struct pcf50633 *pcf) { struct pcf50633_adc *adc = __to_adc(pcf); int head; head = adc->queue_head; if (!adc->queue[head]) return; adc_setup(pcf, adc->queue[head]->mux, adc->queue[head]->avg); }
int main(void) { DDRB |= 0b1111111; DDRA |= 0b11100001; PORTB = 0; adc_setup(); task_setup(); task_start(); task_manager(); return 0; }
void main(void) { general_setup(); adc_setup(); uart_setup(); __enable_interrupt(); //__bis_SR_register(CPUOFF+GIE); while(1) { } }
int main(void) { uint8_t channel_array[16]; uint16_t temperature = 0; rcc_clock_setup_in_hse_12mhz_out_72mhz(); gpio_setup(); usart_setup(); timer_setup(); adc_setup(); gpio_set(GPIOA, GPIO8); /* LED1 on */ gpio_set(GPIOC, GPIO15); /* LED2 on */ /* Send a message on USART1. */ usart_send_blocking(USART2, 's'); usart_send_blocking(USART2, 't'); usart_send_blocking(USART2, 'm'); usart_send_blocking(USART2, '\r'); usart_send_blocking(USART2, '\n'); /* Select the channel we want to convert. 16=temperature_sensor. */ channel_array[0] = 16; /* Set the injected sequence here, with number of channels */ adc_set_injected_sequence(ADC1, 1, channel_array); /* Continously convert and poll the temperature ADC. */ while (1) { /* * Since the injected sampling is triggered by the timer, it gets * updated automatically, we just need to periodically read out the value. * It would be better to check if the JEOC bit is set, and clear it following * so that you do not read the same value twice, especially for a slower * sampling rate. */ temperature = adc_read_injected(ADC1,1); //get the result from ADC_JDR1 on ADC1 (only bottom 16bits) /* * That's actually not the real temperature - you have to compute it * as described in the datasheet. */ my_usart_print_int(USART2, temperature); gpio_toggle(GPIOA, GPIO8); /* LED2 on */ } return 0; }
int main(void) { u8 channel_array[16]; u16 temperature; rcc_clock_setup_in_hse_16mhz_out_72mhz(); gpio_setup(); usart_setup(); adc_setup(); gpio_clear(GPIOB, GPIO7); /* LED1 on */ gpio_set(GPIOB, GPIO6); /* LED2 off */ /* Send a message on USART1. */ usart_send(USART1, 's'); usart_send(USART1, 't'); usart_send(USART1, 'm'); usart_send(USART1, '\r'); usart_send(USART1, '\n'); /* Select the channel we want to convert. 16=temperature_sensor. */ channel_array[0] = 16; adc_set_regular_sequence(ADC1, 1, channel_array); /* * If the ADC_CR2_ON bit is already set -> setting it another time * starts the conversion. */ adc_on(ADC1); /* Wait for end of conversion. */ while (!(ADC_SR(ADC1) & ADC_SR_EOC)); temperature = ADC_DR(ADC1); /* * That's actually not the real temperature - you have to compute it * as described in the datasheet. */ my_usart_print_int(USART1, temperature); gpio_clear(GPIOB, GPIO6); /* LED2 on */ while(1); /* Halt. */ return 0; }
int main(void) { u8 channel_array[16]; rcc_clock_setup_in_hse_12mhz_out_72mhz(); gpio_setup(); usart_setup(); timer_setup(); irq_setup(); adc_setup(); gpio_set(GPIOA, GPIO8); /* LED1 on */ gpio_set(GPIOC, GPIO15); /* LED2 on */ /* Send a message on USART1. */ usart_send_blocking(USART2, 's'); usart_send_blocking(USART2, 't'); usart_send_blocking(USART2, 'm'); usart_send_blocking(USART2, '\r'); usart_send_blocking(USART2, '\n'); /* Select the channel we want to convert. 16=temperature_sensor. */ channel_array[0] = 16; /* Set the injected sequence here, with number of channels */ adc_set_injected_sequence(ADC1, 1, channel_array); /* Continously convert and poll the temperature ADC. */ while (1) { /* * Since sampling is triggered by the timer and copying the value * out of the data register is handled by the interrupt routine, * we just need to print the value and toggle the LED. It may be useful * to buffer the adc values in some cases. */ /* * That's actually not the real temperature - you have to compute it * as described in the datasheet. */ my_usart_print_int(USART2, temperature); gpio_toggle(GPIOA, GPIO8); /* LED2 on */ } return 0; }
int main(void) { uint8_t channel_array[16]; uint16_t temperature; rcc_clock_setup_in_hse_16mhz_out_72mhz(); gpio_setup(); usart_setup(); adc_setup(); gpio_clear(GPIOB, GPIO7); /* LED1 on */ gpio_set(GPIOB, GPIO6); /* LED2 off */ /* Send a message on USART1. */ usart_send(USART1, 's'); usart_send(USART1, 't'); usart_send(USART1, 'm'); usart_send(USART1, '\r'); usart_send(USART1, '\n'); /* Select the channel we want to convert. 16=temperature_sensor. */ channel_array[0] = 16; adc_set_regular_sequence(ADC1, 1, channel_array); /* * Start the conversion directly (not trigger mode). */ adc_start_conversion_direct(ADC1); /* Wait for end of conversion. */ while (!(ADC_SR(ADC1) & ADC_SR_EOC)); temperature = ADC_DR(ADC1); /* * That's actually not the real temperature - you have to compute it * as described in the datasheet. */ my_usart_print_int(USART1, temperature); gpio_clear(GPIOB, GPIO6); /* LED2 on */ while(1); /* Halt. */ return 0; }
int main(void) { rcc_clock_setup_in_hse_12mhz_out_72mhz(); gpio_setup(); usart_setup(); timer_setup(); irq_setup(); adc_setup(); gpio_set(GPIOA, GPIO8); /* LED1 off */ gpio_set(GPIOC, GPIO15); /* LED5 off */ /* Send a message on USART1. */ usart_send_blocking(USART2, 's'); usart_send_blocking(USART2, 't'); usart_send_blocking(USART2, 'm'); usart_send_blocking(USART2, '\r'); usart_send_blocking(USART2, '\n'); /* Moved the channel selection and sequence init to adc_setup() */ /* Continously convert and poll the temperature ADC. */ while (1) { /* * Since sampling is triggered by the timer and copying the values * out of the data registers is handled by the interrupt routine, * we just need to print the values and toggle the LED. It may be useful * to buffer the adc values in some cases. */ my_usart_print_int(USART2, temperature); usart_send_blocking(USART2, ' '); my_usart_print_int(USART2, v_refint); usart_send_blocking(USART2, ' '); my_usart_print_int(USART2, lisam_adc1); usart_send_blocking(USART2, ' '); my_usart_print_int(USART2, lisam_adc2); usart_send_blocking(USART2, '\r'); gpio_toggle(GPIOA, GPIO8); /* LED2 on */ } return 0; }
/***************************************************************************//** * @brief Main function. * * @return 0. *******************************************************************************/ int main(){ u32 mode; Xil_ICacheEnable(); Xil_DCacheEnable(); /* AD9467 Setup. */ ad9467_setup(XPAR_AXI_SPI_0_BASEADDR, 1); /* AD9517 Setup. */ ad9517_setup(XPAR_AXI_SPI_0_BASEADDR, 2); // Initialize device. ad9517_power_mode(3, 0); // Set channel 3 for normal operation ad9517_frequency(3, 250000000); // Set the channel 3 frequency to 250Mhz ad9517_update(); // Update registers /* Read the device ID for AD9467 and AD9517. */ xil_printf("AD9467[REG_CHIP_ID]: %02x\n\r", ad9467_read(AD9467_REG_CHIP_ID)); xil_printf("AD9467[REG_CHIP_GRADE]: %02x\n\r", ad9467_read(AD9467_REG_CHIP_GRADE)); xil_printf("AD9517[REG_PART_ID]: %02x\n\r", ad9517_read(AD9517_REG_PART_ID)); /* AD9467 test. */ adc_setup(0); for (mode = 0x01; mode <= 0x07; mode++) // Data pattern checks { adc_test(mode, 0x0); // Data format is offset binary adc_test(mode, 0x1); // Data format is twos complement } ad9467_output_invert(0); // Output invert Off ad9467_output_format(0); // Offset binary ad9467_reset_PN9(0); // Clear PN9 bit ad9467_reset_PN23(0); // Clear PN23 bit ad9467_test_mode(0); // Test mode Off ad9467_transfer(); // Synchronously update registers xil_printf("done\n\r"); Xil_DCacheDisable(); Xil_ICacheDisable(); return 0; }
int main(void) { WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer P2DIR = 0x00; adc_setup(); SPI_setup(); int count = 0; volatile int freq = adc_value(); while(1) { if (count == 24) { freq = adc_value(); count = 0; } count++; toggle_waves(freq); } return 0; }
int main(void) { uint16_t temp; clock_setup(); gpio_setup(); adc_setup(); usart_setup(); while (1) { adc_start_conversion_regular(ADC1); while (!(adc_eoc(ADC1))); temp=adc_read_regular(ADC1); gpio_port_write(GPIOE, temp << 4); my_usart_print_int(USART2, temp); } return 0; }
/***************************************************************************//** * @brief main *******************************************************************************/ int main(void) { spi_device ad9434_device; adc_core ad9434_core; dmac_core ad9434_dma; dmac_xfer rx_xfer; uint8_t nr_of_lanes = 12; uint8_t over_range_signal = 1; ad_platform_init(); ad9434_core.base_address = XPAR_AXI_AD9434_BASEADDR; ad9434_core.no_of_channels = 1; ad9434_core.resolution = 12; ad9434_dma.base_address = XPAR_AXI_AD9434_DMA_BASEADDR; ad_spi_init(&ad9434_device); ad9434_device.chip_select = SPI_CHIP_SELECT(0); #ifdef ZYNQ rx_xfer.start_address = XPAR_DDR_MEM_BASEADDR + 0x800000; #endif ad9434_dma.type = DMAC_RX; ad9434_dma.transfer = &rx_xfer; rx_xfer.id = 0; rx_xfer.no_of_samples = 32768; ad9434_setup(&ad9434_device); adc_setup(ad9434_core); ad9434_testmode_set(&ad9434_device, TESTMODE_PN9_SEQ); adc_delay_calibrate(ad9434_core, nr_of_lanes + over_range_signal, ADC_PN9); ad9434_testmode_set(&ad9434_device, TESTMODE_OFF); ad9434_outputmode_set(&ad9434_device, OUTPUT_MODE_TWOS_COMPLEMENT); if(!dmac_start_transaction(ad9434_dma)) { ad_printf("Capture done!\n"); }; ad_platform_close(); return 0; }
int main() { io_pins_setup(); module_setup(); adc_setup(); timer1_setup(); // enable global interrupts sei(); while (1) { comms_update(); if (adc_z_want_update) adc_buffer_update(); } return (0); }
/*--------------------------------------------------------------------*/ int main(void) { uint32_t i,j; cntr=4; clock_setup(); gpio_setup(); adc_setup(); dma_setup(); /* Start of the ADC. Should continue indefinitely with DMA in circular mode */ adc_start_conversion_regular(ADC1); while (1) { /* Blink the LED (PB8, PB9) on the board. */ uint32_t count = 500*v[1]; gpio_toggle(GPIOD, GPIO12); for (i = 0; i < count; i++) __asm__("nop"); gpio_toggle(GPIOD, GPIO13); for (i = 0; i < count; i++) __asm__("nop"); } return 0; }
int main(void) { uint16_t temp; adc_setup(); usart_setup(); while (1) { adc_start_conversion_regular(ADC1); while (!(adc_eoc(ADC1))); temp = adc_read_regular(ADC1); my_usart_print_int(USART1, temp); int i; for (i = 0; i < 800000; i++) { /* Wait a bit. */ __asm__("nop"); } } return 0; }
int main() { adc_struct ADC; adc_struct *HwMon = &ADC; adc_setup( HwMon, AD5324, SPI0, 7, // nCS 5, // SCK 6 // MOSI ); // Sawtooth function while (1) { uint16_t i; for (i=0; i<4095; i++) { adc_write(HwMon, ADC_OUT_A, i); adc_write(HwMon, ADC_OUT_B, i); adc_write(HwMon, ADC_OUT_C, i); adc_write(HwMon, ADC_OUT_D, i); } for (i=4095; i>0; i--) { adc_write(HwMon, ADC_OUT_A, i); adc_write(HwMon, ADC_OUT_B, i); adc_write(HwMon, ADC_OUT_C, i); adc_write(HwMon, ADC_OUT_D, i); } } return 0; }