Search the Community

Приветствую всех на этом форуме! Есть необходимость измерять сигнал при помощи данного АЦП. С помощью этого АЦП можно измерять 4 аналоговых не дифференциальных сигнала . Схема следующая: Schematic_Temp_opto_sens_V2_20190817124112.pdf Картинками с более низким разрешением: библиотеку за основу взял эту: https://github.com/nsaspook/nidaq700/blob/master/supermoon/example/ADS1220.c Путем незначительного допиливания, получилась такая библиотека: Поправил только эти функции: void ADS1220SendByte(unsigned char Byte) { unsigned char Result = 0x01, i=0, flg=0; MOSI_LO; Delay_us(1); for(i=0;i<8;i++) { SCK_LO; //ADC_CLK=0 Delay_us(4); if (flg) MOSI_LO; Delay_us(1); SCK_HI; //ADC_CLK=1 Delay_us(1); if (Byte&Result){ MOSI_HI; flg=1; } else MOSI_LO; Delay_us(4); Result<<=1; } SCK_LO; //ADC_CLK=0 } unsigned char ADS1220ReceiveByte(void) { unsigned char Result = 0, i=0; for(i=0;i<8;i++) { Result<<=1; SCK_LO; //ADC_CLK=0 Delay_us(5); //Delay_us(5); SCK_HI; //ADC_CLK=1 Delay_us(3); if (MISO) Result++; Delay_us(2); } SCK_LO; //ADC_CLK=0 return Result; } И добавил эту функцию: void ADS1220Config_MUX_GAIN(uint8_t mux, uint8_t gain) { unsigned Temp; ADS1220ReadRegister(ADS1220_0_REGISTER, 0x01, &Temp); // clear prev value; Temp &= 0x0f; Temp |= gain; Temp |= mux; // write the register value containing the new value back to the ADS ADS1220WriteRegister(ADS1220_0_REGISTER, 0x01, &Temp); ADS1220ReadRegister(ADS1220_1_REGISTER, 0x01, &Temp); // clear prev DataRate code; Temp &= 0x1f; Temp |= (ADS1220_DR_600 + ADS1220_CC); // Set default start mode to 600sps and continuous conversions // write the register value containing the new value back to the ADS ADS1220WriteRegister(ADS1220_1_REGISTER, 0x01, &Temp); } ADS1220.h : в результате получаю такую осциллограмму : То есть , постоянно считывается 0. А вот регистры конфигурации: Задаю номер входа MUX и усиление : Читаю данные так: ADS1220Config_MUX_GAIN(ADS1220_MUX_0_G, ADS1220_GAIN_1); HAL_Delay(10); temp_[0] = ADS1220ReadData(); Это для 0 канала. Пробовал и так: ADS1220SetChannel(ADS1220_MUX_0_G); ADS1220SetGain(ADS1220_GAIN_1); temp_[0] = ADS1220ReadData(); Результат аналогичный. Кто что подскажет? Может кто заметит какой косяк в коде? Уже голова дымит ..

Продам адаптеры USB-I2S. Возможности: стерео ввод/вывод PCM 16-32 бита, 44.1-384 кГц. Ввода DSD нет, как и драйверов для ввода DSD. вывод DSD в режиме DoP 64-128, в режиме Native 64-256. Native доступен в Linux без "хитрых" драйверов. Тактирование от платы ЦАП/АЦП, частоты 512 fs (22.5792/24.576 МГц). Теоретически возможно и 1024fs(скорости 768кГц и DSD512 Native), но это не опробовано. Гальваническая изоляция на Si8662/Si8640. Питание возможно как Self так и Bus Powered. В режиме Bus Powered необходимо самостоятельно позаботиться о мастерклоке, т.к. возможны сильные глюки при выключенном генераторе мастерклока. Тема: срок изготовления 3-5 недель (сильно зависит от поставок процессоров). На данный момент полностью реализован интерфейс Legacy. Для отладки Native режима пока нет платы ЦАП, в процессе разработки, будет не раньше осени. Цена 6000 + пересылка (в среднем 250 р.).

Доброго времени суток. Понадобилось разобраться с АЦП. Основной материал использовал Евстифеева (микроконтроллеры семейства мега) и учебный курс Di-Halt. На первый раз задача простая - обработать напряжение с переменного резистора и послать по UART в терминал. С терминалом уже кое-что делал, так что тут вряд ли косяк есть. Кратко опишу программу: каждую секунду в обработчике прерывания таймера (не совсем точно, прерывание по переполнению Т0) запускаю преобразование АЦП установкой в 1 бита ADSC. В обработчике прерывания АЦП читаю байт ADCH (выравнивание по левому краю ADLAR=1) и шлю по уарт. Но в терминал приходят одни FF независимо от положения движка потенциометра (подключен к PC1 средним контактом, крайними на землю и AVCC) ADC_test.zip

Дано: отладочная плата STM32F303VC, индукционный датчик. Доброго времени суток, суть моего проекта в детектировании вибраций(ударов) при помощи аналогового датчика. Код отслеживания удара написан, но я не пойму то ли я ошибся с алгоритмом его работы то ли не правильно сконфигурировал отладочную плату. Информация по датчику. Индукционный датчик удара, шок сенсор, Arduino может использоваться в проектах на микроконтроллерах (в т.ч. Arduino), в которых нужно следить за уровнем вибрации или подобных механических возмущений. Принцип действия датчика основан на электромагнитной индукции. Движущийся стальной, ферритовый или магнитный сердечник относительно катушки создает в катушке ЭДС, подходящую по амплитуде ударного воздействия на систему. Чувствительный элемент датчика установлен в прозрачный пластиковый параллелепипед для защиты от действий внешней среды. Для использования датчика нужно подключить его к Arduino контроллеру или другому микропроцессорному управляющему устройству, подать питание, создать программу для работы с датчиком или использовать готовое решение. На корпусе датчика есть два отверстия, с помощью которых можно жестко закрепить датчик на плоской поверхности. В состоянии покоя напряжение на выходе из датчика около 5 В, при возмущении напряжение на датчике падает пропорционально силе возмущения. Индукционный датчик удара, шок сенсор, Arduino имеет один 3-контактный разъем для подключения к контроллеру и питания: контакт обозначенный «–» – общий контакт; средний контакт – напряжение питания; контакт S – аналоговый выходной сигнал датчика. Датчик может питаться как от Arduino контроллера (другого микропроцессорного управляющего устройства), так и от внешнего источника питания. Напряжение питания 3,3 – 5 вольт постоянного тока. Характеристики: принцип действия: индукционный; выходной сигнал: аналоговый; напряжение питания: 3,3 – 5 вольт постоянного тока; размеры: 30 х 18 х 11; вес: 2 г. Shock.7z

Помогите передать данные ADC по SMS. UART.zip

Требуется высокоскоростной АЦП (80-125МГц) с минимальным потреблением. Вот нашёл такой https://www.maximintegrated.com/en/products/analog/data-converters/analog-to-digital-converters/MAX19516.html MAX19516, двухканальный, 57мВт на канал при 100МГц Есть ли ещё 8-12-битные АЦП с меньшим потреблением?

Есть чип NXP LPC1788. Есть пример программы где в начале происходит инициализация второго канала, далее в цикле происходит обращение к функции считывания (ADC) данных с порта, но при считывании номер канала не указывается(по умолчанию информация забирается из инициализированного канала), отсюда вопрос - можно ли одновременно работать с несколькими каналами или каждый раз придётся перенастраивать систему на новый канал? (хочется одновременно работать со всеми)

Доброе время суток. Имеется микроконтроллер STM32F103VBT6, на нём заведен ADC1 и используются 6 входных каналов на ножках PA0..PA5. Если в конфигурации установить оцифровку сигнала с пина PA0, то оцифровка проходит успешно, то же самое с пином PA1. Ситуация меняется, если пытаюсь оцифровать PA2..PA5. Считываются нули. Ниже привожу код. Просьба подсказать в чём может быть дело и как это исправить. Канал меняю в строчке ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_1Cycles5);. К примеру, ADC_Channel_2. #include "stm32f10x_rcc.h" #include "stm32f10x_adc.h" #include "stm32f10x_gpio.h" #include "stm32f10x_usart.h" #include "misc.h" #include "delay.h" void SetupUSART(void); void send_to_uart(uint8_t data); void ADC1_2_IRQHandler(void); void Get_Temp(void); uint8_t ind1_B; uint8_t ind2_B; uint8_t ind3_B; uint8_t ind4_B; uint8_t ind5_B; uint8_t ind1_C; uint8_t ind2_C; uint8_t ind3_C; uint8_t ind4_C; uint8_t ind5_C; uint8_t ind1_D; uint8_t ind2_D; uint8_t ind3_D; uint8_t ind4_D; uint8_t ind5_D; uint8_t ind_B; static volatile uint16_t temp=0; int main(void) { SysTick_Config(8000); RCC_APB2PeriphClockCmd(RCC_APB2ENR_AFIOEN, ENABLE); // ?? GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); //GPIO_PinRemapConfig(GPIO_Remap_SWJ_NoJTRST, ENABLE); //GPIO_PinRemapConfig(GPIO_Remap_USART2, DISABLE); //RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;// ?? //AFIO->MAPR |= AFIO_MAPR_SWJ_CFG_JTAGDISABLE; // ?? disable JTAG GPIO_InitTypeDef GPIO_InitStructure; // PORTA // input RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); GPIO_InitStructure.GPIO_Pin = /*GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 |*/ GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); // alternative GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); // PORTB // input RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_3 | GPIO_Pin_5 | GPIO_Pin_8; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOB, &GPIO_InitStructure); // output GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_4 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_9; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOB, &GPIO_InitStructure); // PORTC // input RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_4; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOC, &GPIO_InitStructure); // output GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_13; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOC, &GPIO_InitStructure); // PORTD // input RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOD, &GPIO_InitStructure); // alternative GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15); // PWM output pins GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOD, &GPIO_InitStructure); // PORTE // input RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOE, &GPIO_InitStructure); // output GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_5 | GPIO_Pin_8 | GPIO_Pin_9; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOE, &GPIO_InitStructure); SetupUSART(); // TIM4 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE); // Clock to PORTD for TIM4 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE); // Clock to TIM4 GPIO_PinRemapConfig(GPIO_Remap_TIM4, ENABLE); TIM4->CCER |= (TIM_CCER_CC1E|TIM_CCER_CC2E|TIM_CCER_CC3E|TIM_CCER_CC4E); // Enable all PWM outputs TIM4->CCMR1|= (TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2); //Forward PWM for ch1 TIM4 TIM4->CCMR1|= (TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2); //Forward PWM for ch2 TIM4 TIM4->CCMR2|= (TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2); //Forward PWM for ch3 TIM4 TIM4->CCMR2|= (TIM_CCMR2_OC4M_1 | TIM_CCMR2_OC4M_2); //Forward PWM for ch4 TIM4 TIM4->CR1 |= TIM_CR1_CEN; TIM4->CCR1 = 65536/5; // Duty cycle PWM1 (Avr voltage = 1.65 V) TIM4->CCR2 = 65536/4; // Duty cycle PWM2 TIM4->CCR3 = 65536/3; // Duty cycle PWM3 TIM4->CCR4 = 65536/2; // Duty cycle PWM4 // ADC RCC_ADCCLKConfig(RCC_PCLK2_Div8); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; ADC_DeInit(ADC1); ADC_InitTypeDef ADC_InitStructure; ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; ADC_InitStructure.ADC_ScanConvMode = DISABLE; ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = 1; ADC_Init(ADC1, &ADC_InitStructure); ADC_ITConfig(ADC1, ADC_IT_EOC, ENABLE); NVIC_Init(&NVIC_InitStructure); ADC_Cmd(ADC1, ENABLE); //ADC_TempSensorVrefintCmd(ENABLE); ADC_ResetCalibration(ADC1); while (ADC_GetResetCalibrationStatus(ADC1)) { }; ADC_StartCalibration(ADC1); while (ADC_GetCalibrationStatus(ADC1)) { }; GPIO_SetBits(GPIOE,GPIO_Pin_1); while(1) { GPIO_SetBits(GPIOC,GPIO_Pin_6); //uint8_t pa2 = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_2); //send_to_uart(pa2); //GPIO_SetBits(GPIOB,GPIO_Pin_4); // always 1 /*/chB GPIO_SetBits(GPIOB,GPIO_Pin_6); GPIO_SetBits(GPIOB,GPIO_Pin_4); GPIO_SetBits(GPIOB,GPIO_Pin_7); GPIO_SetBits(GPIOB,GPIO_Pin_9); GPIO_SetBits(GPIOE,GPIO_Pin_0); */ Delay_ms(500); GPIO_ResetBits(GPIOC,GPIO_Pin_6); //GPIO_ResetBits(GPIOB,GPIO_Pin_4); // always 1 /*/chB GPIO_ResetBits(GPIOB,GPIO_Pin_6); GPIO_ResetBits(GPIOB,GPIO_Pin_4); GPIO_ResetBits(GPIOB,GPIO_Pin_7); GPIO_ResetBits(GPIOB,GPIO_Pin_9); GPIO_ResetBits(GPIOE,GPIO_Pin_0); */ Delay_ms(500); ind1_B = GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_6); // ok ind2_B = GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_7); // ok ind3_B = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_3); // ok //(?) always 0 ind4_B = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_5); // ok ind5_B = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_8); // ok ind1_C = GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_2); // ok ind2_C = GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_3); // ok ind3_C = GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_4); // ok ind4_C = GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_6); // ok ind5_C = GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1); // ok ind1_D = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_6); // ok ind2_D = GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_7); // ok ind3_D = GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_4); // ok ind4_D = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_0); // ok ind5_D = GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_7); // ok //send_to_uart(ind1_; //send_to_uart(ind2_; //send_to_uart(ind3_; //send_to_uart(ind4_; //send_to_uart(ind5_; ind_B = 5-(ind1_B+ind2_B+ind3_B+ind4_B+ind5_; switch (ind_ { case 0: GPIO_ResetBits(GPIOB,GPIO_Pin_6); // sel1_B GPIO_ResetBits(GPIOB,GPIO_Pin_4); // sel2_B GPIO_ResetBits(GPIOB,GPIO_Pin_7); // sel3_B GPIO_ResetBits(GPIOB,GPIO_Pin_9); // sel4_B GPIO_ResetBits(GPIOE,GPIO_Pin_0); // sel5_B break; case 1: GPIO_SetBits(GPIOB,GPIO_Pin_6); // sel1_B GPIO_ResetBits(GPIOB,GPIO_Pin_4); // sel2_B GPIO_ResetBits(GPIOB,GPIO_Pin_7); // sel3_B GPIO_ResetBits(GPIOB,GPIO_Pin_9); // sel4_B GPIO_ResetBits(GPIOE,GPIO_Pin_0); // sel5_B break; case 2: GPIO_ResetBits(GPIOB,GPIO_Pin_6); // sel1_B GPIO_SetBits(GPIOB,GPIO_Pin_4); // sel2_B GPIO_ResetBits(GPIOB,GPIO_Pin_7); // sel3_B GPIO_ResetBits(GPIOB,GPIO_Pin_9); // sel4_B GPIO_ResetBits(GPIOE,GPIO_Pin_0); // sel5_B break; case 3: GPIO_ResetBits(GPIOB,GPIO_Pin_6); // sel1_B GPIO_ResetBits(GPIOB,GPIO_Pin_4); // sel2_B GPIO_SetBits(GPIOB,GPIO_Pin_7); // sel3_B GPIO_ResetBits(GPIOB,GPIO_Pin_9); // sel4_B GPIO_ResetBits(GPIOE,GPIO_Pin_0); // sel5_B break; case 4: GPIO_ResetBits(GPIOB,GPIO_Pin_6); // sel1_B GPIO_ResetBits(GPIOB,GPIO_Pin_4); // sel2_B GPIO_ResetBits(GPIOB,GPIO_Pin_7); // sel3_B GPIO_SetBits(GPIOB,GPIO_Pin_9); // sel4_B GPIO_ResetBits(GPIOE,GPIO_Pin_0); // sel5_B break; case 5: GPIO_ResetBits(GPIOB,GPIO_Pin_6); // sel1_B GPIO_ResetBits(GPIOB,GPIO_Pin_4); // sel2_B GPIO_ResetBits(GPIOB,GPIO_Pin_7); // sel3_B GPIO_ResetBits(GPIOB,GPIO_Pin_9); // sel4_B GPIO_SetBits(GPIOE,GPIO_Pin_0); // sel5_B break; } Get_Temp(); unsigned char a = temp>>4; send_to_uart(a); send_to_uart(0xFF); } } void ADC1_2_IRQHandler(void) { if (ADC_GetITStatus(ADC1, ADC_IT_EOC)) { ADC_ClearITPendingBit(ADC1, ADC_IT_EOC); temp = ADC_GetConversionValue(ADC1); } } void Get_Temp(void) { ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_1Cycles5); ADC_SoftwareStartConvCmd(ADC1, ENABLE); } void send_to_uart(uint8_t data) { while(!(USART1->SR & USART_SR_TC)); USART1->DR=data; } void SetupUSART() { RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); //RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,ENABLE); //RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; /* Configure USART1 Tx (PA.09) as alternate function push-pull */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Configure USART1 Rx (PA.10) as input floating */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); USART_InitStructure.USART_BaudRate = 115200; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_DeInit(USART1); USART_Init(USART1, &USART_InitStructure); USART_Cmd(USART1, ENABLE); }

В этой теме ждём всех интересующихся интерфейсами АВР. Например мне интересно как организовать USB.

Здравствуйте, подскажите пожалуйста где ошибка. Была написана простая программа для STM32F4DISCOVERY использующая АЦП для измерений, был подключён потенциометр на 10kOm средней точкой к выводу PA1 . #include <stm32f4xx.h> #include <stm32f4xx_rcc.h> #include <stm32f4xx_gpio.h> #include <stm32f4xx_adc.h> int ReadADC1() { ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_3Cycles); ADC_SoftwareStartConv(ADC1); while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); return ADC_GetConversionValue(ADC1); } void main(void) { // RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE); GPIO_InitTypeDef GPIO_STR; ADC_InitTypeDef ADC_STR; ADC_CommonInitTypeDef ADC_CSTR; GPIO_STR.GPIO_Mode=GPIO_Mode_AN; GPIO_STR.GPIO_Pin=GPIO_Pin_1; GPIO_Init(GPIOA,&GPIO_STR); ADC_DeInit(); ADC_CSTR.ADC_Mode=ADC_Mode_Independent; ADC_CSTR.ADC_Prescaler=ADC_Prescaler_Div2; ADC_CommonInit(&ADC_CSTR); ADC_STR.ADC_ContinuousConvMode=DISABLE; ADC_STR.ADC_DataAlign=ADC_DataAlign_Right; ADC_STR.ADC_ExternalTrigConv=ADC_ExternalTrigConvEdge_None; //ADC_STR.ADC_NbrOfConversion=ADC_N ADC_STR.ADC_Resolution=ADC_Resolution_12b; ADC_STR.ADC_ScanConvMode=DISABLE; ADC_Init(ADC1,&ADC_STR); ADC_Cmd(ADC1,ENABLE); int adc_temp=0,sum=0; while(1) { for (time = 0; time <= 1000; time++) { delay(300); adc_temp=ReadADC1(); sum+=adc_temp; } sum/=1000; } } . Сначала всё замечательно работало но спустя какое-то время без каких-либо изменений в коде и схеме перестала работать. Как выяснилось позже происходит зацикливание на одной из строк кода while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); . В одно включение программа работает без сбоев, ведутся нормальные замеры, в следующий же раз происходит зацикливание, даже без изменения кода. Даже при удалении участка кода где происходит зацикливание (что насколько я понимаю в корне не верно) приходят неверные данные. Прошу подскажите всё-ли верно в инициализации и использовании АЦП и что может приводить к таким проблемам?

Хочу выдавать на порт А мк числа от 0 до ~255 С помощью АЦП. Но почему то когда CH1 доходит до 12%, изменения перестают происходить. .include "m128def.inc" LDI R16,0xFF OUT DDRA,R16 LDI R16,(1<<ADEN) | (1<<ADSC) | (1<<ADFR) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) OUT ADCSRA,R16 LDI R16,(1<<ADLAR) | (0<<REFS0) OUT ADMUX,R16 LOOP: IN R16,ADCH OUT PORTA, R16 RJMP LOOP Заранее спасибо. ADC.rar

Здравствуйте, господа. Без лишней лирики перейду сразу к делу. Имеется задание на курсовой проект, где нужно принять два налоговых сигнала с амплитудой 0-5 В, пропустить их через АЦП, выполнить определенные операции и, пропустив через ЦАП, послать на выход получившиеся аналоговые сигналы. Имеется также ряд вопросов: 1. Скольки разрядный АЦП стоит использовать (а соответственно и МК)? Какая точность в данной ситуации не покажется абсурдно низкой? 2. Можете привести пример использования ЦАП в одном из МК вышеуказанной серии? В гугле достаточно много информации по АЦП, а вот по ЦАПу я так и не смог найти ничего. Нужно принимать во внимание то, что среди операций есть взятие корня, возведение в степень и деление, то есть, если отбрасывание дробной части результата не вариант, то нужно преобразование выполнять с числом немалой разрядности (кстати, как организована работа в МК с "дробными" числами). 3. Как организовать параллельный ввод двух сигналов и, соответственно, вывод? Оговорюсь, что знания в плане микроконтроллеров у меня поверхностные, но курсовой-то делать надо. Поэтому в своих вопросах мог нести ахинею, не обессудьте. Спасибо.

Подскажите, кто в курсе: На какой максимальной частоте сейчас могут работать 10-12 разрядные АЦП? Знаю, что на 200-250 МГц могут, а быстрее? Существуют ли вообще АЦП с частотой порядка 1-2 ГГц и какая у них максимальная разрядность?

Столкнулся с тем, что при использовании встроенного Uref (2.56 вольта) АЦП завирает где-то на 12-13% в меньшую сторону (т.е. как буд-то Uref равно 2,75 вольта, а не 2,56). Попробовал в качестве референса AVCC: все нормально. ADMUX = 0b10000110; (т.е. Uref = 2,56В отключен от ножки). Никто ни с чем подобным не сталкивался? Спасибо заранее!

Пардон, разобрался! Видимо, надо было считывать сначала ADCL, затем ADCH (причем именно в такой последовательности). Вот код (извиняюсь, что там много "лишнего", просто мало ли что на что косвенно или прямо влияет): #include <tiny26.h> #include <delay.h> #define setb_EORLOCK {PORTA.1=0;DDRA.1=1;} #define clrb_EORLOCK {DDRA.1=0;PORTA.1=1;} #define setb_START {PORTA.2=1;} #define clrb_START {PORTA.2=0;} #define setb_STOP {PORTA.3=0;DDRA.3=1;} #define clrb_STOP {DDRA.3=0;PORTA.3=1;} #define EOF ( (PINA&1<<3)) #define setb_VP_NORMA {PORTA.4=0;DDRA.4=1;} #define clrb_VP_NORMA {DDRA.4=0;PORTA.4=0;} #define BUT1 (!(PINA&1<<4)) #define setb_SAVE {PORTA.5=0;DDRA.5=1;} #define clrb_SAVE {DDRA.5=0;PORTA.5=0;} #define BUT2 (!(PINA&1<<5)) #define BUT3 (!(PINA&1<<6)) #define VPIN_pin PINA.7 #define BUT4 (!(PINA&1<<7)) #define DAC_DIN PORTB.0 #define clrb_LED5 {PORTB.1=1;DDRB.1=1;} #define setb_LED5 {PORTB.1=0;DDRB.1=1;} #define DAC_SCLK PORTB.2 #define DAC_SYNC PORTB.3 #define setb_LED3 {PORTB.4=0;DDRB.4=1;} #define clrb_LED3 {PORTB.4=1;DDRB.4=1;} #define setb_LED2 {PORTB.5=0;DDRB.5=1;} #define clrb_LED2 {PORTB.5=1;DDRB.5=1;} #define BUTR (!(PINB&1<<6)) #define BUTL (!(PINB&1<<7)) #define setb_LED1 {PORTB.7=0;DDRB.7=1;} #define clrb_LED1 {PORTB.7=1;DDRB.7=1;} #define _RESET #asm("cli");while(1){} #define _LOCK #asm("cli");while(1){#asm("wdr")} #define setb_ADSC ADCSR|=(1<<6) volatile unsigned int vp = 0; volatile unsigned int msec = 0; volatile unsigned char led_inp_mode = 0; volatile unsigned char led_inp = 0; void main( void ) { unsigned long int i; int led=0; int led2=0; // Declare your local variables here DDRA = 0b00000100; PORTA = 0b00000100; DDRB = 0b00111101; PORTB = 0b00000000; TCCR0 = 0b00000000; TCNT0 = 0; PLLCSR = 0b00000000; TCCR1A = 0b00000000; TCCR1B = 0b00000110; TCNT1 = 0; OCR1A = 0; OCR1B = 0; OCR1C = 0; GIMSK = 0b00000000; TIMSK = 0b00000100; MCUCR = 0b00000000; WDTCR=0b00001010; USICR = 0b00000000; ACSR = 0b10000000; ADMUX = 0b10000110; ADCSR = 0b11100111; #asm("sei"); while( msec<20 ) if( !EOF ) msec = 0; #asm("cli"); setb_STOP; setb_EORLOCK; delay_us( 10 ); clrb_STOP; for( i=0; i<8; i++ ) { delay_us( 330 ); setb_START; delay_us( 1 ); clrb_START; } clrb_EORLOCK; while (1) { #asm("wdr"); delay_us( 1000 ); msec++; if( msec >= ADCL ) {led = 1-led; msec = 0;} if( led ) setb_SAVE else clrb_SAVE; } } Никак не добьюсь зависимости частоты мигания от напряжения на ножке 11 (PORTA.7). При этом АЦП, вроде запускается и ADSC сбрасывается как пологается... 100 раз уже перепроверил мультиплексор, режим работы и пр. Попробовал и фри-ран и однократный режим. Все одно: частота не меняется. И похоже из ADCL считывается всегда 0. Может я что-то пропустил?

Как опросить 2 канала ацп котроллера, пример кода для одного канала АЦП как второй канал задействовать, третий и т.п. ? помогите кто чем может, давно уже ищю всю както не конкретно и не понятно, в гугль не отсылать был я там // Использование АЦП. Цифровой вольтметр 02. 03.#include <avr/io.h> 04.#include <avr/interrupt.h> 05.#include <util/delay.h> 06. 07.//------------------0-----1-----2-----3-----4-----5-----6-----7-----8------9----dp 08.char SEGMENTE[] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F, 0x80}; 09. 10.volatile unsigned char segcounter = 0; 11.volatile int display = 0; 12. 13.// Прерывание по переполнению T2, динамическая индикация 14.ISR (TIMER2_OVF_vect) 15.{ 16.PORTD = 0xFF; 17.PORTB = (1 << segcounter); 18. 19.switch (segcounter) 20.{ 21.case 0: 22.PORTD = ~(SEGMENTE[display % 10000 / 1000]); 23.break; 24.case 1: 25.PORTD = ~((SEGMENTE[display % 1000 / 100])|0x80); // добавляем десятичную точку 26.break; 27.case 2: 28.PORTD = ~(SEGMENTE[display % 100 / 10]); 29.break; 30.} 31.if ((segcounter++) > 2) segcounter = 0; 32.} 33. 34.volatile unsigned long value; 35.volatile unsigned int adc_counter; 36. 37.// Прерывание по окончанию преобразования АЦП 38.ISR (ADC_vect) 39.{ 40.value = value + (ADC*11/4); 41.adc_counter++; 42.} 43. 44.// Главная функция 45.int main (void) 46.{ 47.DDRD = 0xFF; 48.DDRB = (1 << PB0)|(1 << PB1)|(1 << PB2)|(1 << PB3); 49.PORTD = 0x00; 50.PORTB = 0x00; 51.DDRC = 0x00; 52. 53.TIMSK |= (1 << TOIE2); // разрешение прерывания по таймеру2 54.TCCR2 |= (1 << CS21); //предделитель на 8 55. 56.ADCSRA = (1 << ADEN) // разрешение АЦП 57.|(1 << ADSC) // запуск преобразования 58.|(1 << ADFR) // непрерывный режим работы АЦП 59.|(1 << ADPS2)|(1 << ADPS1)|(0 << ADPS0) // предделитель на 64 (частота АЦП 125kHz) 60.|(1 << ADIE); // разрешение прерывания 61. 62.ADMUX = (1 << REFS1)|(1 << REFS0) // внутренний ИОН 2,56V 63.|(0 << MUX3)|(0 << MUX2)|(0 << MUX1)|(0 << MUX0); // вход ADC0 64. 65._delay_ms(50); 66. 67.sei(); //глобально разрешаем прерывания 68. 69.while(1) 70.{ 71.if (adc_counter > 300) // вычисляем среднее значение АЦП 72.{ 73.display = value/adc_counter; 74.adc_counter = 0; 75.value = 0; 76.} 77._delay_ms(50); 78.} 79.}

Доброго времени суток! Есть необходимость измерять потенциал между двумя точками. Значения могут быть как положительные так и отрицательные. В даташите на ATMega2560 сказано, что у ADC есть режим дифференциальной работы, когда для измерения используется не земля и один из А-пинов, а два аналоговых канала. Как в Ардуино включить такой режим работы аналоговых входов? Или для измерений стоит использовать отдельный датчик?