ATNEL tech-forum

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-15T21:35:34+01:00

Witam ponownie,
Jado, robiłem tak jak pisałeś i wyszło, że... inicjacja USB wszystko wiesza... Wziąłem dla pewności "surowy" przykład z ST, dodałem zwykłe miganie diody - Set,Reset GPIO + for jako delay - i tnie automatycznie diode. Nie chce się już z tym grzebać bo straciłem już na tą transmisje ponad miesiąc :/ Przerobiłem kod, dodałem obsługe USART i kod wygląda następująco:
[syntax=c]// *Used on STM32F3-Discovery
// Free pins located in STM32F3-Discovery manual, UM1570

// ADC1/2 Trigger EXT3 TIM2_CC2
// ADC3/4 Trigger EXT1 TIM2_CC3

// Pins for this example PA1, PA4, PB1, PB12

/**************************************************************************************/

#include "stm32f30x.h"
#include "stm32f30x_rcc.h"
#include "stm32f30x_gpio.h"
#include "stm32f30x_tim.h"
#include "stm32f30x_dma.h"
#include "stm32f30x_adc.h"

#include "stm32303c_eval.h"

/**************************************************************************************/

#define SAMPLES 25

#define ADC12_CDR_ADDRESS ((uint32_t)0x5000030C)

volatile uint16_t ADC12DualConvertedValue[SAMPLES * 2];
volatile uint8_t m_sym;
volatile uint8_t l_sym;

volatile uint16_t testowy=2100;

/**************************************************************************************/

void ADC_GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;

/* Enable GPIOA and GPIOB Periph clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB, ENABLE);

/* ADC Channels configuration */
/* Configure as analog input */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_4;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_12;
// GPIO_Init(GPIOB, &GPIO_InitStructure);

}

void USART_GPIO_Conf(void)
{
GPIO_InitTypeDef GPIO_InitStructure;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Pin= GPIO_Pin_9;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_7);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_7);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
}

/**************************************************************************************/

void ADC12_DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;

/* Enable DMA1 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

/* DMA configuration */
/* DMA1 Channel1 Init Test */
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC12_CDR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADC12DualConvertedValue[0];
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = SAMPLES;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

DMA_Init(DMA1_Channel1, &DMA_InitStructure); // ADC1
}

/**************************************************************************************/

/**************************************************************************************/

void ADC_Configuration(void)
{
ADC_InitTypeDef ADC_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
volatile int i;
uint16_t CalibrationValue[4];

/* Configure the ADC clocks */
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1);

/* Enable ADC1/2/3/4 clocks */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);

/* ADC GPIO configuration */
ADC_GPIO_Configuration();

/* ADC DMA Channel configuration */
ADC12_DMA_Configuration();

/* ADC Calibration procedure */
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
// ADC_VoltageRegulatorCmd(ADC2, ENABLE);

/* Insert delay equal to 10 µs */
//Delay(10);
for(i=0; i<10000; i++);

ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);

// ADC_SelectCalibrationMode(ADC2, ADC_CalibrationMode_Single);
// ADC_StartCalibration(ADC2);

while(ADC_GetCalibrationStatus(ADC1) != RESET );
CalibrationValue[0] = ADC_GetCalibrationValue(ADC1);

// while(ADC_GetCalibrationStatus(ADC2) != RESET );
// CalibrationValue[1] = ADC_GetCalibrationValue(ADC2);

/* ADC Dual mode configuration */
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_RegSimul;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1; // 12-bit
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 10;

ADC_CommonInit(ADC1, &ADC_CommonInitStructure);

/* */
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable; // Triggered
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_RisingEdge;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;

ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_3; // ADC1/2 EXT3 TIM2_CC2

ADC_Init(ADC1, &ADC_InitStructure);
// ADC_Init(ADC2, &ADC_InitStructure);

/* ADC1 regular configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 1, ADC_SampleTime_7Cycles5); // PA1
/* ADC2 regular configuration */
// ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SampleTime_7Cycles5); // PA4

/* Configures the ADC DMA */
ADC_DMAConfig(ADC1, ADC_DMAMode_Circular);

/* Enable the ADC DMA */
ADC_DMACmd(ADC1, ENABLE);

/* Enable ADC[1..4] */
ADC_Cmd(ADC1, ENABLE);
// ADC_Cmd(ADC2, ENABLE);

/* wait for ADC1 ADRDY */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));

/* wait for ADC2 ADRDY */
// while(!ADC_GetFlagStatus(ADC2, ADC_FLAG_RDY));

/* Enable the DMA channel */
DMA_Cmd(DMA1_Channel1, ENABLE);
// DMA_Cmd(DMA2_Channel5, ENABLE);

/* Start ADC1 Software Conversion */
ADC_StartConversion(ADC1);
}

/**************************************************************************************/

void TIM2_Configuration(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;

/* Enable ADC1/2/3/4 clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_Period = (SystemCoreClock / 50) - 1; // 50 Hz Sample Rate
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

/* PWM1 Mode configuration: Channel2 & 3 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 10; // Some arbitary width
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

TIM_OC2Init(TIM2, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);

TIM_OC3Init(TIM2, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Enable);

TIM_Cmd(TIM2, ENABLE);
}

/**************************************************************************************/

void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

/* Enable DMA1 channel1 IRQ Channel */
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;
NVIC_Init(&NVIC_InitStructure);
}

/**************************************************************************************/

void DMA1_Channel1_IRQHandler(void) // 2 Hz
{
/* Test on DMA1 Channel1 Transfer Complete interrupt */
if (DMA_GetITStatus(DMA1_IT_TC1))
{
/* Clear DMA1 Channel1 Half Transfer, Transfer Complete and Global interrupt pending bits */
DMA_ClearITPendingBit(DMA1_IT_GL1);

STM_EVAL_LEDToggle(LED3); // 1 Hz
}
}

void USART_Conf(void)
{
USART_InitTypeDef USART_InitStructure;

USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
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_Init(USART1, &USART_InitStructure);
USART_Cmd(USART1, ENABLE);
}

/**************************************************************************************/

/**************************************************************************************/

int main(void)
{

int i;
/* Initialize LEDs available on STM32F3-Discovery board */
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);

/* Turn on LD3 */
STM_EVAL_LEDOn(LED3);
/* Turn off LD4 */
STM_EVAL_LEDOff(LED4);

TIM2_Configuration();

ADC_Configuration();

/* Use LED's to confirm sample periodicity */
NVIC_Configuration();

/* Enable DMA1 Channel1 Transfer Complete interrupt */
DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE);

USART_GPIO_Conf();
USART_Conf();

while(1)
{
m_sym = (uint8_t)(testowy & 0xFF);
l_sym = (uint8_t)(testowy >> 8);

USART_SendData(USART1, l_sym);
for(i=0; i<100000; i++);
USART_SendData(USART1, m_sym);
// USART_SendData(USART1, ADC12DualConvertedValue[20]);
}
}[/syntax]

Przesyła wybraną próbke do PC (ADC w 100% działa bo sprawdzałem za pomocą potencjometru). Z racji że chciałem mieć 12 bitowe próbki zrobiłem sobie "rozdzielanie" 16bitowej wartości na 2 bajty - młodsza i starsza część próbki. Działa - tylko, że... nie potrafię zsynchronizować wysyłania naprzemiennego (raz leci odpowiednia sekwencja 16 bitów, raz lecą pod rząd same bity mniej znaczącej części, a innym razem bardziej znaczącej). Pierwsza myśl - wprowadze opóźnienie, ale czy to najlepszy sposób ? Wątpie... Kolejna sprawa, że chce osiągnąć częstotliwość próbkowania na poziomie 200-500kHz więc...wysyłanie na bieżąco nie spełni sie za bardzo. Są jakieś inne koncepcje na wysyłanie 12 bitowych wartości za pomocą USART w miare składny sposób ? Tak, wiem np opcja z funkcją ITOA, ale konwersja na char też swoje trwa.... docelowo chce wysyłać do komputera ok 1024-2048 próbek.
Pozdrawiam.

Statystyki: Napisane przez Forfiter — 15 maja 2014, o 21:35

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-14T18:27:01+01:00

Niestety, ale często własnie tak bywa, że oddzielnie każdy fragment kodu działa, a razem poskładane "do kupy" nie chcą.
Kody te mogą współzawodniczyć ze sobą o dostęp do zasobów mikrokontrolera, a wreszcie o sam czas procesora, który jest przecież ograniczony.
Wystarczy, że któryś z kodów będzie miał w sobie wbudowaną pętlę oczekiwania na jakiś warunek i już będzie blokował pozostałe części programu, które oczywiście nie będą działać poprawnie.
Dlatego między innymi stosuje się róźnego rodzaju RTOS'y, maszyny stanów, itp., żeby zapewnić współbieżność działania tych wszystkich programów.
Jeśli każdy z fragmentów programu Ci działa, a razem nie chcą, to zastanów się, w jaki sposób każdy z nich może oddziaływać na inny.
Który z nich powinien mieć największy priorytet działania, a który może poczekać. Czasami wystarczy zmienić priorytety przerwań i program zaczyna działać.
Niestety są to "najwredniejsze" z możliwych błędów, bo generalnie nie ma błędu programowego jako takiego, są tylko niespełnione warunki czasowe działania programu.
Może warto byłoby wprowadzić flagi informujące pozostałe części programu o uruchomieniu innego jego fragmentu - i w tym czasie wstrzymać się z uruchamianiem jednocześnie innych funkcji.
Spróbuj uruchamiać kod po kolei - najpierw jedną część, tą która działa bezproblemowo, potem dodawaj kolejne fragmenty i patrz czy to dodanie zakłóciło działanie tego pierwszego kodu.
Potem spróbuj przeanalizować co w danym kodzie może mieć wpływ na zaburzenie działania tego pierwszego działającego programu.
Trzeba rozbić problem na mniejsze części.
Dobrze jest też robić regularne backupy-snapshoty pisanego kodu, bo czasami "trąci się jakiś klawisz, bo klawiatura spada ze stołu" i to potrafi we wredny sposób niepostrzeżenie zmienić kod, który nagle przestaje działać. Wtedy odtworzenie kopii z backupu ratuje nas przed wielogodzinnym szukaniem niewiadomego błędu.

Statystyki: Napisane przez Jado — 14 maja 2014, o 18:27

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-14T15:20:44+01:00

Zero pomysłów ?

Statystyki: Napisane przez Forfiter — 14 maja 2014, o 15:20

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-13T18:06:11+01:00

Masakra po całości... dzięki uprzejmości pewnego Pana z ST otrzymałem sprawnie działający program ADC+TIM+DMA. USB mi działało, więc postanowiłem je zestawic do kupy... wyszło mi coś takiego:
[syntax=c]// STM32 ADC Quad Mode STM32F3-Discovery - sourcer32@gmail.com

/**************************************************************************************/

// ADC1 ADC2 ADC3 ADC4
// IN1 PA0* PA4 PB1 PE14*
// IN2 PA1 PA5* PE9* PE15*
// IN3 PA2 PA6* PE13* PB12
// IN4 PA3 PA7* --- PB14
// IN5 PF4 PC4 PB13 PB15
//
// *Used on STM32F3-Discovery
// Free pins located in STM32F3-Discovery manual, UM1570

// ADC1/2 Trigger EXT3 TIM2_CC2
// ADC3/4 Trigger EXT1 TIM2_CC3

// Pins for this example PA1, PA4, PB1, PB12

/**************************************************************************************/

#include "stm32f30x.h"
#include "stm32f30x_flash.h"
#include "stm32f30x_misc.h"
#include "stm32f30x_rcc.h"
#include "stm32f30x_exti.h"
#include "stm32f30x_gpio.h"
#include "stm32f30x_dma.h"
#include "stm32f30x_tim.h"
#include "stm32f30x_adc.h"
#include "hw_config.h"
#include "usb_lib.h"
#include "usb_desc.h"
#include "usb_pwr.h"

//#include "stm32303c_eval.h"

/**************************************************************************************/

#define SAMPLES 25

#define ADC12_CDR_ADDRESS ((uint32_t)0x5000030C)
#define ADC34_CDR_ADDRESS ((uint32_t)0x5000070C)

extern __IO uint8_t Receive_Buffer[64];
extern __IO uint32_t Receive_length ;
extern __IO uint32_t Send_length ;
extern __IO uint32_t length ;
uint16_t Send_Buffer[60];
uint32_t packet_sent=1;
uint32_t packet_receive=1;

volatile uint16_t ADC12DualConvertedValue[SAMPLES * 2];
volatile uint16_t ADC34DualConvertedValue[SAMPLES * 2];

/**************************************************************************************/

void ADC_GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;

/* Enable GPIOA and GPIOB Periph clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOE, ENABLE);
/* ADC Channels configuration */
/* Configure as analog input */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_4;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_12;
GPIO_Init(GPIOB, &GPIO_InitStructure);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOE, &GPIO_InitStructure);
}

/**************************************************************************************/

void ADC12_DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;

/* Enable DMA1 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

/* DMA configuration */
/* DMA1 Channel1 Init Test */
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC12_CDR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADC12DualConvertedValue[0];
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = SAMPLES;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

DMA_Init(DMA1_Channel1, &DMA_InitStructure); // ADC1
}

/**************************************************************************************/

void ADC34_DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;

/* Enable DMA2 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);

/* DMA configuration */
/* DMA2 Channel5 Init Test */
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC34_CDR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADC34DualConvertedValue[0];
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = SAMPLES;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

DMA_Init(DMA2_Channel5, &DMA_InitStructure); // ADC3
}

/**************************************************************************************/

void ADC_Configuration(void)
{
ADC_InitTypeDef ADC_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
volatile int i;
uint16_t CalibrationValue[4];

/* Configure the ADC clocks */
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1);
RCC_ADCCLKConfig(RCC_ADC34PLLCLK_Div1);

/* Enable ADC1/2/3/4 clocks */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12 | RCC_AHBPeriph_ADC34, ENABLE);

/* ADC GPIO configuration */
ADC_GPIO_Configuration();

/* ADC DMA Channel configuration */
ADC12_DMA_Configuration();
ADC34_DMA_Configuration();

/* ADC Calibration procedure */
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
ADC_VoltageRegulatorCmd(ADC2, ENABLE);
ADC_VoltageRegulatorCmd(ADC3, ENABLE);
ADC_VoltageRegulatorCmd(ADC4, ENABLE);

/* Insert delay equal to 10 µs */
//Delay(10);
for(i=0; i<10000; i++);

ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);

ADC_SelectCalibrationMode(ADC2, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC2);

ADC_SelectCalibrationMode(ADC3, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC3);

ADC_SelectCalibrationMode(ADC4, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC4);

while(ADC_GetCalibrationStatus(ADC1) != RESET );
CalibrationValue[0] = ADC_GetCalibrationValue(ADC1);

while(ADC_GetCalibrationStatus(ADC2) != RESET );
CalibrationValue[1] = ADC_GetCalibrationValue(ADC2);

while(ADC_GetCalibrationStatus(ADC3) != RESET );
CalibrationValue[2] = ADC_GetCalibrationValue(ADC3);

while(ADC_GetCalibrationStatus(ADC4) != RESET );
CalibrationValue[3] = ADC_GetCalibrationValue(ADC4);

/* ADC Dual mode configuration */
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_RegSimul;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1; // 12-bit
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 10;

ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
ADC_CommonInit(ADC3, &ADC_CommonInitStructure);

/* */
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable; // Triggered
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_RisingEdge;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;

ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_3; // ADC1/2 EXT3 TIM2_CC2

ADC_Init(ADC1, &ADC_InitStructure);
ADC_Init(ADC2, &ADC_InitStructure);

ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_1; // ADC3/4 EXT1 TIM2_CC3

ADC_Init(ADC3, &ADC_InitStructure);
ADC_Init(ADC4, &ADC_InitStructure);

/* ADC1 regular configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 1, ADC_SampleTime_7Cycles5); // PA1
/* ADC2 regular configuration */
ADC_RegularChannelConfig(ADC2, ADC_Channel_1, 1, ADC_SampleTime_7Cycles5); // PA4
/* ADC3 regular configuration */
ADC_RegularChannelConfig(ADC3, ADC_Channel_1, 1, ADC_SampleTime_7Cycles5); // PB1
/* ADC4 regular configuration */
ADC_RegularChannelConfig(ADC4, ADC_Channel_3, 1, ADC_SampleTime_7Cycles5); // PB12

/* Configures the ADC DMA */
ADC_DMAConfig(ADC1, ADC_DMAMode_Circular);
ADC_DMAConfig(ADC3, ADC_DMAMode_Circular);

/* Enable the ADC DMA */
ADC_DMACmd(ADC1, ENABLE);
ADC_DMACmd(ADC3, ENABLE);

/* Enable ADC[1..4] */
ADC_Cmd(ADC1, ENABLE);
ADC_Cmd(ADC2, ENABLE);
ADC_Cmd(ADC3, ENABLE);
ADC_Cmd(ADC4, ENABLE);

/* wait for ADC1 ADRDY */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));

/* wait for ADC2 ADRDY */
while(!ADC_GetFlagStatus(ADC2, ADC_FLAG_RDY));

/* wait for ADC3 ADRDY */
while(!ADC_GetFlagStatus(ADC3, ADC_FLAG_RDY));

/* wait for ADC4 ADRDY */
while(!ADC_GetFlagStatus(ADC4, ADC_FLAG_RDY));

/* Enable the DMA channel */
DMA_Cmd(DMA1_Channel1, ENABLE);
DMA_Cmd(DMA2_Channel5, ENABLE);

/* Start ADC1 Software Conversion */
ADC_StartConversion(ADC1);
ADC_StartConversion(ADC3);
}

/**************************************************************************************/

void TIM2_Configuration(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;

/* Enable ADC1/2/3/4 clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

TIM_TimeBaseStructure.TIM_Prescaler = 7200;
TIM_TimeBaseStructure.TIM_Period = 100; // 50 Hz Sample Rate
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

/* PWM1 Mode configuration: Channel2 & 3 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 10; // Some arbitary width
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

TIM_OC2Init(TIM2, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);

TIM_OC3Init(TIM2, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Enable);

TIM_Cmd(TIM2, ENABLE);
}

/**************************************************************************************/

void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

/* Enable DMA1 channel1 IRQ Channel */
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;
NVIC_Init(&NVIC_InitStructure);
/* Enable DMA2 channel5 IRQ Channel */
NVIC_InitStructure.NVIC_IRQChannel = DMA2_Channel5_IRQn;
NVIC_Init(&NVIC_InitStructure);
}

/**************************************************************************************/

void DMA1_Channel1_IRQHandler(void) // 2 Hz
{
/* Test on DMA1 Channel1 Transfer Complete interrupt */
if (DMA_GetITStatus(DMA1_IT_TC1))
{
/* Clear DMA1 Channel1 Half Transfer, Transfer Complete and Global interrupt pending bits */
DMA_ClearITPendingBit(DMA1_IT_GL1);

// GPIO_ResetBits(GPIOE, GPIO_Pin_9);// 1 Hz
}
}

/**************************************************************************************/

void DMA2_Channel5_IRQHandler(void) // 2 Hz
{
/* Test on DMA2 Channel5 Transfer Complete interrupt */
if (DMA_GetITStatus(DMA2_IT_TC5))
{
/* Clear DMA2 Channel5 Half Transfer, Transfer Complete and Global interrupt pending bits */
DMA_ClearITPendingBit(DMA2_IT_GL5);

// GPIO_SetBits(GPIOE,GPIO_Pin_9); // 1 Hz
}
}

/**************************************************************************************/

void main(void)
{
/* Initialize LEDs available on STM32F3-Discovery board */
//GPIO_SetBits(GPIOE, GPIO_Pin_10);
// GPIO_SetBits(GPIOE, GPIO_Pin_11);
// STM_EVAL_LEDInit(LED4);

/* Turn on LD3 */
// GPIO_SetBits(GPIOE,GPIO_Pin_10);
// GPIO_SetBits(GPIOE, GPIO_Pin_11);
/* Turn off LD4 */
// STM_EVAL_LEDOff(LED4);

long int j=0;

TIM2_Configuration();

ADC_Configuration();

Set_System();
Set_USBClock();
USB_Interrupts_Config();
USB_Init();
/* Use LED's to confirm sample periodicity */
NVIC_Configuration();

/* Enable DMA1 Channel1 Transfer Complete interrupt */
DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE);

/* Enable DMA2 Channel5 Transfer Complete interrupt */
DMA_ITConfig(DMA2_Channel5, DMA_IT_TC, ENABLE);

GPIO_SetBits(GPIOE,GPIO_Pin_9);

if (bDeviceState == CONFIGURED)
{

if (Receive_length != 0)
{
if (packet_sent == 1)
{
GPIO_SetBits(GPIOE, GPIO_Pin_11);
CDC_Send_DATA ((unsigned char*)Send_Buffer,60);

}
packet_sent = 1;
for(j=0; j<2000; j++);
}
Receive_length = 0;
}
while(1); // Don't want to exit
}[/syntax]

Wszystko fajnie, dioda się świeci - czyli void main jest 'widzialny' ale... na terminalu cisza... w dodatku stm32 mi go zawiesza :/

Statystyki: Napisane przez Forfiter — 13 maja 2014, o 18:06

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-13T15:14:15+01:00

Aktywowałem ale dalej nic ehh...

Statystyki: Napisane przez Forfiter — 13 maja 2014, o 15:14

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-13T05:38:58+01:00

No to jeszcze aktywuj zegar dla portu E, bo nie widzę tego w RCC_Config().

Statystyki: Napisane przez PJS — 13 maja 2014, o 05:38

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-12T21:51:00+01:00

To nic nie dało :/ Dałem świecenie diody do funkcji main - zero reakcji...

Statystyki: Napisane przez Forfiter — 12 maja 2014, o 21:51

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-12T21:36:16+01:00

Widzę, że masz coś takiego:
[syntax=c]NVIC_InitStructure.NVIC_IRQChannel = ENABLE;

NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;[/syntax]

To pierwsze chyba powinno być:

[syntax=c]NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;[/syntax]

Statystyki: Napisane przez PJS — 12 maja 2014, o 21:36

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-12T20:41:36+01:00

Źle to określiłem - z tym miganiem Ogólnie chciałem zobaczyć czy wchodzi w przerwanie - zaświecenie diody. Nie jestem pewien czy nie trzeba dołączać jakiejś deklaracji związanej z aktywacją zegara dla przerwań, ale w notach od STM32f303 nic o tym nie ma :/

Statystyki: Napisane przez Forfiter — 12 maja 2014, o 20:41

Re: STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-12T20:39:47+01:00

[syntax=c]GPIO_SetBits(GPIOE, GPIO_Pin_11); // sprawdzenie czy wystepuje przerwanie od dma1[/syntax]

Ta funkcja ustawia wyjście w stan "1", a nie zmienia stanu naprzemiennie, więc dioda raczej nie będzie migać. To tak na szybko, co zwróciło moją uwagę.

Statystyki: Napisane przez PJS — 12 maja 2014, o 20:39

STM32F3 - próbkowanie [ADC, DMA, TIM, USB]

2014-05-12T18:40:43+01:00

Witam ponownie,
Chciałem zasięgnąć porady dotyczącej mojego kodu. USB ładnie sobie śmigało, więc postanowiłem dobudować pare klocków, które pozwalały by na próbkowanie sygnału i wysyłanie przez USB. Pokleiłem, pokleiłem... i wyszedł mi poniższy kod (zamieszczam zawartość pliku main.c). Pierwsze uruchomienie - w terminalu widze 20 zer. Poprawki, korekty - nic. Zapuściłem sobie miganie diody w przerwaniu od DMA - nie miga, czyli przerwanie takowe w ogóle nie występuje. Mógłby ktoś zerknąć na kod i sprawdzić czego brakuje ?
Pozdrawiam.

[syntax=c]#include "stm32f30x_flash.h"
#include "stm32f30x_rcc.h"
#include "stm32f30x_gpio.h"
#include "stm32f30x_tim.h"
#include "stm32f30x_dma.h"
#include "stm32f30x_adc.h"
#include "hw_config.h"
#include "usb_lib.h"
#include "usb_desc.h"
#include "usb_pwr.h"
#include "itoa.h"
#include

volatile uint16_t FFT_buffer[120];
extern __IO uint8_t Receive_Buffer[64];
extern __IO uint32_t Receive_length ;
extern __IO uint32_t Send_length ;
extern __IO uint32_t length ;
uint16_t Send_Buffer[60];
uint32_t packet_sent=1;
uint32_t packet_receive=1;

void RCC_Config(void);
void GPIO_Config(void);
void NVIC_Config(void);
void DMA_Config(void);
void ADC_Config(void);
void TIM1_Config(void);

int main(void)
{

int j;
GPIO_Config();
RCC_Config();
NVIC_Config();
DMA_Config();
ADC_Config();
TIM1_Config();
DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE);

Set_System();
Set_USBClock();
USB_Interrupts_Config();
USB_Init();

while (1)
{
if (bDeviceState == CONFIGURED)
{
CDC_Receive_DATA();
/*Check to see if we have data yet */
if (Receive_length != 0)
{
if (packet_sent == 1)
{
CDC_Send_DATA ((unsigned char*)Send_Buffer,20);
}
packet_sent = 1;
for(j=0; j<2000; j++);
}
Receive_length = 0;
}
}
}

//------------------------------------------------------------------------------------//

void RCC_Config(void)
{
ErrorStatus HSEStartUpStatus;
RCC_DeInit();
RCC_HSEConfig(RCC_HSE_ON);
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if(HSEStartUpStatus == SUCCESS)
{
FLASH_PrefetchBufferCmd(FLASH_ACR_PRFTBE);
FLASH_SetLatency(FLASH_Latency_2);
RCC_HCLKConfig(RCC_SYSCLK_Div1);
RCC_PCLK2Config(RCC_HCLK_Div1);
RCC_PCLK1Config(RCC_HCLK_Div2);
RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9); // Czestotliwosc PLL
RCC_PLLCmd(ENABLE);
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
while(RCC_GetSYSCLKSource() != 0X08);

RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); // Aktywacja zegara dla portu GPIOA
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // Aktywacja zegara dla DMA1
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1); // Dzielnik zegara dla ADC1
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); // Aktywacja zegara dla ADC1
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // Aktywacja zegara TIM2
}
else{}
}

//------------------------------------------------------------------------------------//

void GPIO_Config(void)
{
//--------------------------------------ADC1--------------------------------------//
GPIO_InitTypeDef GPIO_InitStructure;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOE, &GPIO_InitStructure);
}

//------------------------------------------------------------------------------------//

void DMA_Config(void)
{
DMA_InitTypeDef DMA_InitStructure;

DMA_InitStructure.DMA_PeripheralBaseAddr = ((uint32_t)0x5000030C);
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&FFT_buffer[0];
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 60; // wielkosc bufora;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

DMA_Init(DMA1_Channel1, &DMA_InitStructure);
}

//------------------------------------------------------------------------------------//

void TIM1_Config(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

TIM_TimeBaseStructure.TIM_Prescaler = 72; //dzielnik czestotliwosci 72MHz/72=1MHz -> 1us
TIM_TimeBaseStructure.TIM_Period = 5; // częstotliwosc probkowania
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

TIM_OCInitTypeDef TIM_OCInitStructure;

TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 10;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

TIM_OC2Init(TIM2, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_Cmd(TIM2, ENABLE);
}

//------------------------------------------------------------------------------------//

void ADC_Config(void)
{
//------------------------------------zmienne-----------------------------------------//
volatile int delay;
uint16_t CalibrationValue[4];
//-----------------------------------kalibracja---------------------------------------//
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
for(delay=0; delay < 10000; delay++);
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1) != RESET);
CalibrationValue[0] = ADC_GetCalibrationValue(ADC1);

//----------------------------------deklaracje----------------------------------------//
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_InitTypeDef ADC_InitStructure;

ADC_CommonInitStructure.ADC_Mode = ADC_Mode_RegSimul;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 10;

ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_3;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_RisingEdge;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;

ADC_Init(ADC1, &ADC_InitStructure);

ADC_RegularChannelConfig(ADC1, ADC_Channel_4, 1, ADC_SampleTime_1Cycles5);
ADC_DMAConfig(ADC1, ADC_DMAMode_Circular);
ADC_Cmd(ADC1, ENABLE);

while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
DMA_Cmd(DMA1_Channel1, ENABLE);
ADC_StartConversion(ADC1);
}

//----------------------------------------------------------------------------------------//

void NVIC_Config(void)
{
NVIC_InitTypeDef NVIC_InitStructure;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannel = ENABLE;

NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;
NVIC_Init(&NVIC_InitStructure);
}

void DMA1_Channel1_IRQHandler(void)
{
if(DMA_GetITStatus(DMA1_IT_TC1))
{
Send_Buffer[60]=FFT_buffer[120];
GPIO_SetBits(GPIOE, GPIO_Pin_11); // sprawdzenie czy wystepuje przerwanie od dma1
DMA_ClearITPendingBit(DMA1_IT_GL1);
}
}[/syntax]

P.S.
Sam ciągle to sprawdzam jednak może ktoś bardziej doświadczony po rzuceniu okiem na problem rozwieje wątpliwości w znacznie krótszym czasie.

Statystyki: Napisane przez Forfiter — 12 maja 2014, o 18:40