Jump to content
Sign in to follow this  
Antidriver

Ацп На Stm32F103Vbt6, Работают 1 И 2 Каналы Adc1, Остальные

Recommended Posts

Доброе время суток.

Имеется микроконтроллер 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);
}

Share this post


Link to post
Share on other sites

Join the conversation

You are posting as a guest. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
Sign in to follow this  

  • Similar Content

    • By svd
      Предлагаю печатные платы для паяльной станции на STM32 и OLED дисплее 1,3" версии 2.1S
      Плата делалась под китайский алюминиевый корпус.
      Тема, где обсуждается данная станция T12 , опубликована на сайте radiokot.ru
      Фото платы


      Схема немного доработана:
      1) добавлены блокировочные конденсаторы 0,1 мкФ в цепях микроконтроллера;
      2) добавлен резистор в цепи буззера для возможности снижения громкости;
      3) есть возможность подключать жала JBC (для Т12 в разъеме паяльника запаивается перемычка)

      Большинство элементов типоразмера 0603. DC/DC преобразователь PSR-7805LF можно заменить на любой китайский аналог или микросхему 7805
      Ссылки на возможные замены:
      DC/DC аналог 7805 №1
      DC/DC аналог 7805 №2

      Во вложениях схема и расположение элементов на ПП, чертеж передней панели и прошивка под дисплей 1.3" с контроллером SH1106.

      Цена за одну плату 400 руб c учетом стоимости пересылки по РФ. Количество плат ограничено.
      По всем вопросам просьба обращаться в личку.
       
      STM32_T12_2.1S_SSH1106_1.3_v2_.pdf передняя панель.pdf T12_HW21S_Encryption-SH1106.zip
    • By ART_ME
      Здравствуйте.
      Рискну спросить: не завалялась ли у кого в хозяйстве для STM32F103xx: 
      - AC induction motor IFOC software library V1.0
      либо 
      - ACIM and PMSM motor control software libraries release 2.0
      ?
      Просьба поделиться если вдруг такой раритет найдется. 
       
    • By Илья Юрченко
      Добрый день, уважаемые форумчане! Для научной работы хотел собрать данные о том, насколько микроконтроллеры stm32 удовлетворяют нужды и требования программистов и разработчиков продуктов на нем. Если не сложно, ответьте, пожалуйста, важны данные)
      Разумеется "очень средне" неадекватная метрика, но в рамках работы нужна именно средняя удовлетворённость, и определение существует ли необходимость в создании другой серии универсальных плат на базе МК.
    • By n_angelo
      Привет, знатоки. Написал свою первую программу для контроллера STM8L152C6T6 (STM8L-Discovery). Это, собственно, моя первая программа для контроллеров вообще. Я многого не знаю и не понимаю. Возможно ваш ответ на мой вопрос будет банален.
      Используемая периферия: DAC, DMA, TIM4, CLK, GPIO
      Задача у программы такая:
      В EEPROM зашит один период синусоиды с дискретизацией 44100Гц. Период занимает ровно 101 байт, что по сути должно быть равно 2,29мс (1/44100*101). В коде программы только конфигурация периферии, одно прерывание на кнопке и пустой бесконечный цикл, который ничего не делает. Всю работу выполняет таймер, который настроен выдавать запрос к DMA на каждые 1/44100 (ядро тактируется 2мГц, таймер считает до 45). В свою очередь DMA забирает из EEPROM по одному байту на каждый запрос от таймера и передаёт его в DAC. Далее DAC выводит бесконечную синусоиду на ногу PF0. Прерывание на кнопке запускает весь этот механизм и зажигает светодиод.
      Проблема:
      Измеряя ногу PF0 осциллографом было замечено, что период синусоиды занимает около ≈4мс. Фото под катом.
      Меня это расстроило. Экспериментально выяснилось, что стоит только вписать в бесконечный цикл какую-нибудь проверку, например, [если значение текущего байта синусоиды = 0xFF, то зажечь светодиод, если 0x00, то потушить], то осциллограф показывает правильный тайминг в 2(с копейками)мс. В принципе в теле цикла может быть что угодно, кроме пустоты, и тайминг налаживается.
      Я не могу отдебажить дизассемблер, т.к. его не знаю. Это у меня в планах. Но я очень хочу понять, что происходит и почему пустой цикл рушит тайминг.
      Спасибо.
       
       
       
       
    • By n_angelo
      Привет. Хочу узнать ваше мнение. Я новичок в embedded. Можно сказать, что пришел с веба. Малость Python, JS, C. Меня, конечно, предупреждали начать с AVR, но я уверенный в себе решил сразу залезть на STM32. Вынашивая идею для проекта, параллельно курив Reference Manual и Data Sheet по STM32, я понял что его будет слишком жирно для проекта. Я перескочил на STM8L. И тут меня начал огорчать мир embedded. При переходе между stm8 и stm32 нужно менять IDE (TrueStudio на STVD). Во избежание таких курьёзов я пересаживаюсь на IAR. В процессе подключения родной библиотеки от ST, понимаю что библиотека от IAR для того же самого STM8L152C6T6 дико отличается (макросы, структуры). Привет веб-разработка. Как такое могло произойти, что под один и тот же контроллер ST даёт одну библиотеку, а IAR другую. И нигде в уроках тебя не предупредят об этом. Ну, ребят, у меня всего одна жизнь. Вы уже договоритесь там между собой? Придите к единому стандарту. Или они так решили новичков завендерлочить? Моё мнение (не претендует на правильное): пробираясь сквозь тернии популярной архитектуры ARM, инфраструктуры, инструментария, забываешь про бизнес-логику устройств. А еще просто пропасть между "я ничего не понимаю" и "господи, я зажег светодиод". Речь не о копипастерах с уроков, а действительно понимая что ты делаешь, в каком регистре, что меняешь. Это путь в 2000 (а то и больше) страниц на английском перечитанных по несколько раз, чтобы отоложилось. И в конце тебя ждут разные версии одной и той же библиотки в разных IDE. И сидишь вдупляешь... ну почему... я же в правильный регистр кладу правильную маску... ох, наболело. Такое ощущение что не для людей это всё делали, не для людей.
      Ваше мнение?
×
×
  • Create New...