/* adc8 * * Returns a 8bit ADC value */ uint8_t adc8(void) { /* Set the result to left adjust (LSB at ADC:2) */ ADMUX |= (1<<ADLAR); adcStartConversion(); return ADCH; }
void convStart( void ) { /* pwmStart( &PWMD2, &pwmCfg ); palSetPadMode( GPIOA, 0, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); palSetPadMode( GPIOA, 1, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); //palSetPadMode( GPIOA, 2, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); pwmEnableChannel(&PWMD2, 0, PWM_PERCENTAGE_TO_WIDTH( &PWMD2, 9500 ) ); pwmEnableChannel(&PWMD2, 1, PWM_PERCENTAGE_TO_WIDTH( &PWMD2, 3030 ) ); //pwmEnableChannel(&PWMD2, 2, PWM_PERCENTAGE_TO_WIDTH( &PWMD2, 3030 ) ); */ // Start PWM peripherial. pwmStart( &CONV_PWM, &pwmCfg ); // Init PWM pins. palSetPadMode( CONV_PORT, CONV_BUCK_PIN, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); palSetPadMode( CONV_PORT, CONV_BOOST_PIN, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); // Set zero active period. pwmEnableChannel(&CONV_PWM, PWM_BOOST_CHAN, PWM_PERCENTAGE_TO_WIDTH( &CONV_PWM, 0000 ) ); pwmEnableChannel(&CONV_PWM, PWM_BUCK_CHAN, PWM_PERCENTAGE_TO_WIDTH( &CONV_PWM, 0000 ) ); // Init ADC. palSetGroupMode(CONV_ADC_PORT, PAL_PORT_BIT( CONV_BUCK_FB_PIN ) | PAL_PORT_BIT( CONV_BOOST_FB_PIN ) | PAL_PORT_BIT( CONV_INPUT_FB_PIN ), 0, PAL_MODE_INPUT_ANALOG); adcStart( &ADCD1, NULL ); adcStartConversion( &ADCD1, &adcGroup, adcSamples, ADC_BUF_DEPTH ); }
/* adc10 * * Returns a 10bit ADC value */ uint16_t adc10(void) { /* Set the result to right adjust (LSB at ADC:0) */ ADMUX &= ~(1<<ADLAR); adcStartConversion(); return ADC; }
static void startFirstAudioADC() { #if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(TEENSYDUINO) || defined(TEENSYDUINO) // teensy 3, 3.1 adc->startSingleRead(AUDIO_INPUT_PIN); // ADC lib converts pin/channel in startSingleRead #else adcStartConversion(adcPinToChannelNum(AUDIO_INPUT_PIN)); #endif }
void adcInit(void) { DDRC &= ~(3); ADMUX = 0; ADMUX |= (1 << REFS0); // Ref. Voltage: Vcc ADCSRA |= (1 << ADPS2) | (1 << ADPS0); // Prescaler 64 ADCSRA |= (1 << ADEN); // Enable adc adcStartConversion(0); adcGetResult(); }
void vexAdcInit() { // Init and start ADC1 adcInit(); adcStart(&ADCD1, &adccfg); // Start conversions adcStartConversion(&ADCD1, &adccg, &samples_buf[0], 1); }
/* ******************************************************************************* * EXPORTED FUNCTIONS ******************************************************************************* */ void ADCInit_local(void){ adcStart(&ADCD1, &adccfg); adcStartConversion(&ADCD1, &adccg, samples, ADC_BUF_DEPTH); chThdCreateStatic(PowerKeeperThreadWA, sizeof(PowerKeeperThreadWA), NORMALPRIO, PowerKeeperThread, NULL); }
void dma_storm_adc_start(void){ ints = 0; errors = 0; /* Activates the ADC1 driver and the temperature sensor.*/ adcStart(&ADCD1, NULL); adcSTM32EnableTSVREFE(); /* Starts an ADC continuous conversion.*/ adcStartConversion(&ADCD1, &adccg, samples, ADC_BUF_DEPTH); }
void adc_init() { // Following 3 functions use previously created configuration // to initialize ADC block, start ADC block and start conversion. // &ADCD1 is pointer to ADC driver structure, defined in the depths of HAL. // Other arguments defined ourself earlier. adcInit(); adcStart(&ADCD1, &adccfg); adcStartConversion(&ADCD1, &adccg, &samples_buf[0], ADC_BUF_DEPTH); // Thats all. Now your conversion run in background without assistance. }
/* * Application entry point. */ int main(void) { /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Activates the serial driver 1 using the driver default configuration. */ sdStart(&SD1, NULL); /* * Starting GPT4 driver, it is used for triggering the ADC. */ gptStart(&GPTD4, &gpt4cfg1); /* * Fixed an errata on the STM32F7xx, the DAC clock is required for ADC * triggering. */ rccEnableDAC1(false); /* * Activates the ADC1 driver and the temperature sensor. */ adcStart(&ADCD1, NULL); adcSTM32EnableTSVREFE(); /* * Starts an ADC continuous conversion triggered with a period of * 1/10000 second. */ adcStartConversion(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH); gptStartContinuous(&GPTD4, 100); /* * Creates the example thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing. */ while (true) { chThdSleepMilliseconds(500); } }
static void startFirstAudioADC() { #if IS_TEENSY3() adc->startSingleRead(AUDIO_INPUT_PIN); // ADC lib converts pin/channel in startSingleRead #elif IS_STM32() uint8_t dummy = AUDIO_INPUT_PIN; adc.setPins(&dummy, 1); adc.startConversion(); #else adcStartConversion(adcPinToChannelNum(AUDIO_INPUT_PIN)); #endif }
/** * @brief Starts the ADC and ICU input drivers. * @note ICU drivers used in the firmware are modified ChibiOS * drivers for extended input capture functionality. * @return none. */ void mixedInputStart(void) { /* Activates the ICU2 and ICU3 drivers. */ icuStart(&ICUD2, &icucfg2); icuStart(&ICUD3, &icucfg3); /* Starts continuous pulse width measurements. */ icuEnable(&ICUD2); icuEnable(&ICUD3); /* Activates the ADC1 driver. */ adcStart(&ADCD1, NULL); /* Starts an ADC continuous conversion. */ adcStartConversion(&ADCD1, &adcgrpcfg, adcBuf, ADC_GRP_BUF_DEPTH); }
/* * Application entry point. */ int main(void) { /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Setting up analog inputs used by the demo. */ palSetGroupMode(GPIOC, PAL_PORT_BIT(1) | PAL_PORT_BIT(2), 0, PAL_MODE_INPUT_ANALOG); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Activates the ADC1 driver and the temperature sensor. */ adcStart(&ADCD1, NULL); adcSTM32EnableTS(&ADCD1); adcSTM32EnableVBAT(&ADCD1); /* * Linear conversion. */ adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH); chThdSleepMilliseconds(1000); /* * Starts an ADC continuous conversion. */ adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH); /* * Normal main() thread activity, in this demo it does nothing. */ while (true) { if (palReadPad(GPIOA, GPIOA_BUTTON)) { adcStopConversion(&ADCD1); } chThdSleepMilliseconds(500); } }
adc_values_t readADC(void) { adc_values_t values; adcStart(&ADCD1, &adccfg); adcSTM32SetCCR(ADC_CCR_TSEN | ADC_CCR_VREFEN); adcStartConversion(&ADCD1, &adcgrpcfg, samples, 1); chThdSleepMilliseconds(500); adcStop(&ADCD1); values.vdda_voltage = get_vdda_voltage(samples[4]); values.supply_voltage = ((float)samples[0] / ADC_RES * values.vdda_voltage) / VSUPPMON_DIVIDER; values.batt_voltage = ((float)samples[2] / ADC_RES * values.vdda_voltage) / VBATTMON_DIVIDER; values.charge_current = ((float)samples[1] / ADC_RES * values.vdda_voltage) / ICHARGE_DIVIDER; values.internal_temp = get_temp(samples[3]); return values; }
void run_test(const char * test_msg, uint8_t num_channels, uint8_t depth, bool circular) { print(test_msg); cb_arg = 0; group.num_channels = num_channels; group.circular = circular; group.end_cb = adc_callback; if (depth > 1) cb_expect = 2; else cb_expect = 1; if (circular) cb_expect *= 3; adcStartConversion(&ADCD1, &group, buffer, depth); while (ADCD1.state == ADC_ACTIVE) ; int index = 0; for (int j = 0; j < depth; j++) { for (int i = 0; i < group.num_channels; i++) { index = i + (j * group.num_channels); sniprintf(out_string, 128, chn_fmt_string, group.channels[i]); print(out_string); sniprintf(out_string, 128, raw_fmt_string, buffer[index]); print(out_string); if (group.channels[i] == 30) { /* internal temp sensor */ buffer[index] = adcMSP430XAdjustTemp(&group, buffer[index]); } else { buffer[index] = adcMSP430XAdjustResult(&group, buffer[index]); } sniprintf(out_string, 128, cooked_fmt_string, buffer[index]); print(out_string); } } if (cb_arg == cb_expect) { print(success_string); } else { print(fail_string); } }
/* * Application entry point. */ int main(void) { /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Activates the ADC1 driver, the temperature sensor and the VBat * measurement. */ adcStart(&ADCD1, NULL); adcSTM32Calibrate(&ADCD1); adcSTM32EnableTSVREFE(); adcSTM32EnableVBATE(); /* * Linear conversion. */ adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH); chThdSleepMilliseconds(1000); /* * Starts an ADC continuous conversion. */ adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH); /* * Normal main() thread activity, in this demo it does nothing. */ while (TRUE) { if (palReadPad(GPIOA, GPIOA_WKUP_BUTTON)) { adcStopConversion(&ADCD1); } chThdSleepMilliseconds(500); } }
static msg_t sensorRead (void*Arg) { if (dip2 == 1) { while (true) { adcStartConversion (&ADCD1, &adcGrpCfg, irSamples, ADC_BUF_DEPTH); chprintf ((BaseChannel *)&SD2, "adc = \n\r", irSamples); } } int i = 255; while (i >= 0) { chprintf((BaseChannel *)&SD2, "%d ", i); move (FWD, i); chThdSleepMilliseconds (100); --i; } i = 0; while (i >= 0) { chprintf((BaseChannel *)&SD2, "%d ", i); move (LEFT, i); chThdSleepMilliseconds (100); --i; } i = 0; while (i >= 0) { chprintf((BaseChannel *)&SD2, "%d ", i); move (RIGHT, i); chThdSleepMilliseconds (100); --i; } i = 0; while (i >= 0) { chprintf((BaseChannel *)&SD2, "%d ", i); move (REV, i); chThdSleepMilliseconds (100); --i; } }
void bus_voltage_adc_conversion(void) { // read bus voltage adcStartConversion(&ADCD1, &adcgrpcfg, adc_samples, ADC_BUF_DEPTH); chBSemWait(&adc_wait); // set LED float voltage = bus_voltage_get(); if (voltage > 4.5f && voltage < 5.5f) { led_set(CAN1_PWR_LED); } else if (voltage > 0.5f || voltage > 5.5f) { // voltage warning led_toggle(CAN1_PWR_LED); } else { led_clear(CAN1_PWR_LED); } }
static void adctodac(void *arg) { uint16_t temp = 0; adcStart(&ADCD1, &adccfg); dacStart(&DACD1, &dac1cfg1); gptStart(&GPTD6, &gpt6cfg1); while(!0) { adcStartConversion(&ADCD1, &adccg, samples_buf, ADC_BUF_DEPTH); temp = samples_buf[0]; //dacPutChannelX(&DACD1, 1U, temp); dacStartConversion(&DACD1, &dacgrpcfg1, samples_buf, ADC_BUF_DEPTH); gptStartContinuous(&GPTD6, 2U); chThdSleepMilliseconds(1); } }
/** * @brief get the ADC sampled data of the Diagnostic Pin. * * @description todo * * @image html todo * @image rtf todo * @image latex todo * * @param [in] *u16Data received data pointe.After the execution of the API this will hold the sampled data. * * @return TRUE : no errors * FALSE: Errors in execution * * Example Usage: * @code * todo * @endcode * * @entrymode todo * @exitmode todo * * @seealso todo * * **Note: todo** * * @destag todo * @reqtag todo */ boolean TPSDiagosticPinSampledData(uint16* u16Data) { adcData_t adcdata; uint32 count; boolean blRetVal = TRUE; adcStartConversion(Adc_Param_Handle->ADC_TPS, Adc_Param_Handle->group); while(!adcIsConversionComplete(Adc_Param_Handle->ADC_TPS, Adc_Param_Handle->group)); count = adcGetData(Adc_Param_Handle->ADC_TPS, Adc_Param_Handle->group, &adcdata); if((1U == count)&&(0U == adcdata.id)) { *u16Data = adcdata.value; blRetVal = TRUE; } else { blRetVal = FALSE; } return blRetVal;; }
/* Thread used for read data from sonar */ static msg_t irThread(void *arg) { (void) arg; char buf[40]; /* * Activates the ADC1 driver. */ adcStart(&ADCD1, NULL); adcStartConversion(&ADCD1, &adc_grpcfg, (adcsample_t *)&ir_data, ADC_BUF_DEPTH); while (TRUE) { chsprintf(buf, "[IR] N:%d,S:%d,W:%d,E:%d", ir_data.north, ir_data.south, ir_data.west, ir_data.east); bufferPutString(&outputBuffer, buf); chThdSleepMilliseconds(50); } return 0; }
int main( void ) { //disable interrupts cli(); //INITS hwInit(); // uartInit(); pwmInit(); // adcInit(); // WdInit(); // WdDisable(); adcStartConversion(); //enable interrupt Init_TWI(); sei(); //calibration des vitesses // adcCalibSeq(); //attend que la sw Start soit appuyer //pour lancer le reste du programme SLWaitForTheStartSw(); // WD_RESTART_WATCHDOG; while(1) { if(flag5ms) { count5ms++; if(count5ms>=10) { count5ms=0; Ping_sensor(); } } SLCheckSwStatus(); //verifie la switch d'arret cPMainCmdParser(); //Machine à état communication CalculMoteur(); //calculPWM et autre } }
void readVoltage(void) { uint8_t thisTemp; uint32_t i; char Result2[6]; adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH); sum=0; for (i=0;i<=ADC_GRP2_BUF_DEPTH;i++){ sum += samples2[i]; } sum /= ADC_GRP2_BUF_DEPTH; thisTemp = (((int64_t)sum)*VREFINT*400/VREFMeasured-30400)+2500; chprintf((BaseSequentialStream *)&SD2, "\r\nTemperature: %d.%2U°C", thisTemp/100,thisTemp%100); sprintf(Result, "%d", (uint8_t)thisTemp/100); sprintf(Result2, ".%iC", (uint8_t)thisTemp%100); strncat(Result, Result2, 6); gwinSetText(ADCvalue2, Result, TRUE); }
/** * Adc init * * Initialize ADC drivers, buffers and start conversion in the background */ void adc_init(void) { /* Init GPIO ports for ADC operation */ #if USE_ADC_1 PRINT_CONFIG_MSG("Info: Using ADC_1"); gpio_setup_pin_analog(ADC_1_GPIO_PORT, ADC_1_GPIO_PIN); #endif #if USE_ADC_2 PRINT_CONFIG_MSG("Info: Using ADC_2"); gpio_setup_pin_analog(ADC_2_GPIO_PORT, ADC_2_GPIO_PIN); #endif #if USE_ADC_3 PRINT_CONFIG_MSG("Info: Using ADC_3"); gpio_setup_pin_analog(ADC_3_GPIO_PORT, ADC_3_GPIO_PIN); #endif #if USE_ADC_4 PRINT_CONFIG_MSG("Info: Using ADC_4"); gpio_setup_pin_analog(ADC_4_GPIO_PORT, ADC_4_GPIO_PIN); #endif #if USE_ADC_5 PRINT_CONFIG_MSG("Info: Using ADC_5"); gpio_setup_pin_analog(ADC_5_GPIO_PORT, ADC_5_GPIO_PIN); #endif #if USE_ADC_6 PRINT_CONFIG_MSG("Info: Using ADC_6"); gpio_setup_pin_analog(ADC_6_GPIO_PORT, ADC_6_GPIO_PIN); #endif #if USE_ADC_7 PRINT_CONFIG_MSG("Info: Using ADC_7"); gpio_setup_pin_analog(ADC_7_GPIO_PORT, ADC_7_GPIO_PIN); #endif #if USE_ADC_8 PRINT_CONFIG_MSG("Info: Using ADC_8"); gpio_setup_pin_analog(ADC_8_GPIO_PORT, ADC_8_GPIO_PIN); #endif #if USE_ADC_9 PRINT_CONFIG_MSG("Info: Using ADC_9"); gpio_setup_pin_analog(ADC_9_GPIO_PORT, ADC_9_GPIO_PIN); #endif // Configurtion register uint32_t sqr1, sqr2, sqr3; adc_regular_sequence(&sqr1, &sqr2, &sqr3, ADC_NUM_CHANNELS, adc_channel_map); #ifdef __STM32F10x_H uint32_t smpr1, smpr2; adc_sample_time_on_all_channels(&smpr1, &smpr2, ADC_SAMPLE_41P5); adcgrpcfg.cr2 = ADC_CR2_TSVREFE; #elif defined(__STM32F4xx_H) uint32_t smpr1, smpr2; adc_sample_time_on_all_channels(&smpr1, &smpr2, ADC_SAMPLE_480); adcgrpcfg.cr2 = ADC_CR2_SWSTART; #endif #if USE_ADC_WATCHDOG adc_watchdog.adc = NULL; adc_watchdog.cb = NULL; adc_watchdog.channel = 0; adc_watchdog.vmin = (1<<12)-1; // max adc #endif adcgrpcfg.circular = TRUE; adcgrpcfg.num_channels = ADC_NUM_CHANNELS; adcgrpcfg.end_cb = adc1callback; adcgrpcfg.error_cb = adcerrorcallback; adcgrpcfg.cr1 = 0; adcgrpcfg.smpr1 = smpr1; adcgrpcfg.smpr2 = smpr2; adcgrpcfg.sqr1 = sqr1; adcgrpcfg.sqr2 = sqr2; adcgrpcfg.sqr3 = sqr3; // Start ADC in continious conversion mode adcStart(&ADCD1, NULL); adcStartConversion(&ADCD1, &adcgrpcfg, adc_samples, ADC_BUF_DEPTH); }
static void pcbPwmAdcTrigger(PWMDriver *pwmp) { (void) pwmp; adcStartConversion(&ADCD1, &adcZeroSense, &zeroCrossing, 1); }
void adc_convert(void) { adcStopConversion(&ADCD1); adcStartConversion(&ADCD1, &adcgrpcfg1, adcvalues, ADC_GRP1_BUF_DEPTH); }
int main() { DDRB |= _BV(5); PORTB &= ~_BV(5); ///////////////////////////// // Set up the analogue input setupAdcOnPin(0); adcStartConversion(); // Start ADC measurement pulseSetFrameBuffer(frameBuffer, NUM_LEDS); const uint8_t pulseCount = 10; uint8_t pulseIdx = 0; struct cPulse pulses[pulseCount]; memset(pulses, 0, sizeof(struct cPulse) * pulseCount); for (int i = 0; i < pulseCount; i += 2) { pulses[i].direction = 1; } uint8_t sampleHistory[HISTORY_COUNT]; memset(sampleHistory, 0, HISTORY_COUNT); int8_t startingPosition = 0; while(1) { ++toggle; toggle = toggle % 50; setIndicator(toggle == 0); // Hist = = = = = // Wind - - // Copy - - for (int i = 0; i < (HISTORY_COUNT - WINDOW_SIZE); ++i) { sampleHistory[i] = sampleHistory[i + WINDOW_SIZE]; } for (int i = 0; i < WINDOW_SIZE; ++i) { adcStartConversion(); _delay_us(500); adcWaitReady(); sampleHistory[WINDOW_START + i] = ADCH; } uint8_t historicalPeak = findPeak(sampleHistory, 0, WINDOW_START); uint8_t currentPeak = findPeak(sampleHistory, WINDOW_START, WINDOW_SIZE); if (isPulseDetected(historicalPeak, currentPeak)) { // Generate a new pulse if (++pulseIdx >= pulseCount) pulseIdx = 0; pulses[pulseIdx].colour.h = rand() % MAX_HUE; pulses[pulseIdx].colour.s = (MAX_SAT / 2) + (rand() % (MAX_SAT / 2)); pulses[pulseIdx].colour.v = MAX_VAL; pulses[pulseIdx].position = startingPosition; startingPosition -= 3; if (startingPosition < 0) startingPosition += NUM_LEDS; } pulseClearFrameBuffer(); for (int i = 0; i < pulseCount; ++i) { pulseUpdate(pulses + i); pulseRender(pulses + i); } ws2812_setleds(frameBuffer, 40); // Blocks for ~1.2ms _delay_ms(2); // The sensor line will be noisy for a little while } }
/* * Application entry point. */ int main(void) { unsigned i; static uint8_t patterns1[4096], patterns2[4096], buf1[4096], buf2[4096]; /* System initializations. - HAL initialization, this also initializes the configured device drivers and performs the board-specific initializations. - Kernel initialization, the main() function becomes a thread and the RTOS is active.*/ halInit(); chSysInit(); /* Creates the blinker thread.*/ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO + 10, Thread1, NULL); /* Activates the ADC1 driver and the temperature sensor.*/ adcStart(&ADCD1, NULL); adcSTM32EnableTSVREFE(); /* Starts an ADC continuous conversion and its watchdog virtual timer.*/ chVTSet(&adcvt, MS2ST(10), tmo, (void *)"ADC timeout"); adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH); /* Activating SPI drivers.*/ spiStart(&SPID1, &hs_spicfg); spiStart(&SPID2, &hs_spicfg); spiStart(&SPID3, &hs_spicfg); /* Starting SPI threads instances.*/ chThdCreateStatic(waSPI1, sizeof(waSPI1), NORMALPRIO + 1, spi_thread, &SPID1); chThdCreateStatic(waSPI2, sizeof(waSPI2), NORMALPRIO + 1, spi_thread, &SPID2); chThdCreateStatic(waSPI3, sizeof(waSPI3), NORMALPRIO + 1, spi_thread, &SPID3); /* Allocating two DMA2 streams for memory copy operations.*/ if (dmaStreamAllocate(STM32_DMA2_STREAM6, 0, NULL, NULL)) chSysHalt("DMA already in use"); if (dmaStreamAllocate(STM32_DMA2_STREAM7, 0, NULL, NULL)) chSysHalt("DMA already in use"); for (i = 0; i < sizeof (patterns1); i++) patterns1[i] = (uint8_t)i; for (i = 0; i < sizeof (patterns2); i++) patterns2[i] = (uint8_t)(i ^ 0xAA); /* Normal main() thread activity, it does continues memory copy operations using 2 DMA streams at the lowest priority.*/ while (true) { virtual_timer_t vt; chVTObjectInit(&vt); /* Starts a VT working as watchdog to catch a malfunction in the DMA driver.*/ chVTSet(&vt, MS2ST(10), tmo, (void *)"copy timeout"); /* Copy pattern 1.*/ dmaStartMemCopy(STM32_DMA2_STREAM6, STM32_DMA_CR_PL(0) | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE, patterns1, buf1, sizeof (patterns1)); dmaStartMemCopy(STM32_DMA2_STREAM7, STM32_DMA_CR_PL(0) | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE, patterns1, buf2, sizeof (patterns1)); dmaWaitCompletion(STM32_DMA2_STREAM6); dmaWaitCompletion(STM32_DMA2_STREAM7); if (memcmp(patterns1, buf1, sizeof (patterns1))) chSysHalt("pattern error"); if (memcmp(patterns1, buf2, sizeof (patterns1))) chSysHalt("pattern error"); /* Copy pattern 2.*/ dmaStartMemCopy(STM32_DMA2_STREAM6, STM32_DMA_CR_PL(0) | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE, patterns2, buf1, sizeof (patterns2)); dmaStartMemCopy(STM32_DMA2_STREAM7, STM32_DMA_CR_PL(0) | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE, patterns2, buf2, sizeof (patterns2)); dmaWaitCompletion(STM32_DMA2_STREAM6); dmaWaitCompletion(STM32_DMA2_STREAM7); if (memcmp(patterns2, buf1, sizeof (patterns2))) chSysHalt("pattern error"); if (memcmp(patterns2, buf2, sizeof (patterns2))) chSysHalt("pattern error"); /* Stops the watchdog.*/ chVTReset(&vt); chThdSleepMilliseconds(2); } return 0; }
tfunc_t adcConversionThread(void) { adcStart(&ADCD1, NULL); adcStartConversion(&ADCD1, &adcSettings, &samples, 8); return (msg_t)0; }
void captureSamples() { if(adcConfigured) { //if(!sampleRun) { adcGetConversion(); switch (sampleBank) { case 0: samplesA[sampleIndex*2] = ((uhADCxConvertedValue - 2048.0f) / 4096.0f); // - 2048; samplesA[sampleIndex*2 + 1] = ((uhADCxConvertedValue2 - 2048.0f) / 4096.0f); // - 2048;//0.0; if(uhADCxConvertedValue > maxAmplitude) maxAmplitude = uhADCxConvertedValue; if(uhADCxConvertedValue2 > maxAmplitude) maxAmplitude = uhADCxConvertedValue2; if(samplesB[sampleIndex*2] > agcLevel) agcLevel = samplesB[sampleIndex*2]; if(samplesB[sampleIndex*2+1] > agcLevel) agcLevel = samplesB[sampleIndex*2+1]; // if(sampleIndex < filterKernelLength) // { // dac1SetValue(samplesB[sampleIndex*2] + samplesA[(FFT_SIZE - filterKernelLength) // + sampleIndex * 2] /*/ (agcLevel * agcScale)*/ * 4096 * gain + 2048); // dac2SetValue(samplesB[sampleIndex*2+1] + samplesA[(FFT_SIZE - filterKernelLength) // + sampleIndex * 2] /*/ (agcLevel * agcScale)*/ * 4096 * gain + 2048); // } else { dac1SetValue(samplesB[sampleIndex*2] /*/ (agcLevel * agcScale)*/ * 4096 * afGain + 2048); dac2SetValue(samplesB[sampleIndex*2+1] /*/ (agcLevel * agcScale)*/ * 4096 * afGain + 2048); // } if(sampleIndex > FFT_SIZE - filterKernelLength - 1) { samplesOverlap[(sampleIndex - (FFT_SIZE - filterKernelLength))*2] = samplesA[sampleIndex*2]; samplesOverlap[(sampleIndex - (FFT_SIZE - filterKernelLength)) * 2 +1] = samplesA[sampleIndex*2+1]; } break; case 1: samplesB[sampleIndex*2] = ((uhADCxConvertedValue - 2048.0f) / 4096.0f); // - 2048; samplesB[sampleIndex*2 + 1] = ((uhADCxConvertedValue2 - 2048.0f) / 4096.0f); // - 2048;//0.0; if(uhADCxConvertedValue > maxAmplitude) maxAmplitude = uhADCxConvertedValue; if(uhADCxConvertedValue2 > maxAmplitude) maxAmplitude = uhADCxConvertedValue2; if(samplesC[sampleIndex*2] > agcLevel) agcLevel =samplesC[sampleIndex*2]; if(samplesC[sampleIndex*2+1] > agcLevel) agcLevel = samplesC[sampleIndex*2+1]; // if(sampleIndex < filterKernelLength) // { // dac1SetValue(samplesC[sampleIndex*2] + samplesB[(FFT_SIZE - filterKernelLength) // + sampleIndex * 2] /*/ (agcLevel * agcScale)*/ * 4096 * gain + 2048); // dac2SetValue(samplesC[sampleIndex*2+1] + samplesB[(FFT_SIZE - filterKernelLength) // + sampleIndex * 2] /*/ (agcLevel * agcScale)*/ * 4096 * gain + 2048); // } else { dac1SetValue(samplesC[sampleIndex*2] /*/ (agcLevel * agcScale)*/ * 4096 * afGain + 2048); dac2SetValue(samplesC[sampleIndex*2+1] /*/ (agcLevel * agcScale)*/ * 4096 * afGain + 2048); // } if(sampleIndex > FFT_SIZE - filterKernelLength - 1) { samplesOverlap[(sampleIndex - (FFT_SIZE - filterKernelLength))*2] = samplesB[sampleIndex*2]; samplesOverlap[(sampleIndex - (FFT_SIZE - filterKernelLength)) * 2 +1] = samplesB[sampleIndex*2+1]; } break; case 2: samplesC[sampleIndex*2] = ((uhADCxConvertedValue - 2048.0f) / 4096.0f); // - 2048; samplesC[sampleIndex*2 + 1] = ((uhADCxConvertedValue2 - 2048.0f) / 4096.0f); // - 2048;//0.0; if(uhADCxConvertedValue > maxAmplitude) maxAmplitude = uhADCxConvertedValue; if(uhADCxConvertedValue2 > maxAmplitude) maxAmplitude = uhADCxConvertedValue2; if(samplesA[sampleIndex*2] > agcLevel) agcLevel = samplesA[sampleIndex*2]; if(samplesA[sampleIndex*2+1] > agcLevel) agcLevel = samplesA[sampleIndex*2+1]; // if(sampleIndex < filterKernelLength) // { // dac1SetValue(samplesA[sampleIndex*2] + samplesC[(FFT_SIZE - filterKernelLength) // + sampleIndex * 2] /*/ (agcLevel * agcScale)*/ * 4096 * gain + 2048); // dac2SetValue(samplesA[sampleIndex*2+1] + samplesC[(FFT_SIZE - filterKernelLength) // + sampleIndex * 2] /*/ (agcLevel * agcScale)*/ * 4096 * gain + 2048); // } else { dac1SetValue(samplesA[sampleIndex*2] /*/ (agcLevel * agcScale)*/ * 4096 * afGain + 2048); dac2SetValue(samplesA[sampleIndex*2+1] /*/ (agcLevel * agcScale)*/ * 4096 * afGain + 2048); // } if(sampleIndex > FFT_SIZE - filterKernelLength - 1) { samplesOverlap[(sampleIndex - (FFT_SIZE - filterKernelLength))*2] = samplesC[sampleIndex*2]; samplesOverlap[(sampleIndex - (FFT_SIZE - filterKernelLength)) * 2 +1] = samplesC[sampleIndex*2+1]; } break; } //dac1SetValue(outputSamplesA[sampleIndex*2]); agcLevel = agcLevel * (1.0f - 0.0001f); sampleIndex++; if(sampleIndex >= FFT_SIZE - (filterKernelLength/2)) { sampleRun = 1; sampleIndex = filterKernelLength/2; //0; switch(sampleBank) { case 0: sampleBankAReady = 1; sampleBank = 1; zeroSampleBank(samplesB); break; case 1: sampleBankBReady = 1; sampleBank = 2; zeroSampleBank(samplesC); break; case 2: sampleBankCReady = 1; sampleBank = 0; zeroSampleBank(samplesA); break; } //sampleBank = sampleBank++ % 3; // if(sampleBank == 0) // { // sampleBankAReady = 1; // sampleBank = 1; // // } else { // sampleBankBReady = 1; // sampleBank = 0; // } } adcStartConversion(); } } }