STM32L4 ADC+DMA how to get an interrupt when the buffer is filled?

DMA should generate HT and TC interrupts if it is working. You'd need to have the correctly named callback which the HAL would dispatch back to you. ie the main IRQ Handler from the vector table calls the HAL_DMA_IRQHandler(), and it in turn dispatches to your callbacks, and then clears sources and exits.

well, that was fast!

i named the callback : ADC_DMA_XferCpltCallback

i also added that statement

if(HAL_DMA_RegisterCallback(&DmaHandle, HAL_DMA_XFER_CPLT_CB_ID, ADC_DMA_XferCpltCallback) != HAL_OK) return;

right after the HAL DMA init, but for some reason it doesnt work, my own callback is never called.

But If add myself :

uint32_t flag_it = AdcHandle.DMA_Handle->DmaBaseAddress->ISR;
 uint32_t source_it = AdcHandle.DMA_Handle->Instance->CCR;
 if (((flag_it & (DMA_FLAG_TC1 << (AdcHandle.DMA_Handle->ChannelIndex & 0x1CU))) != 0U) && ((source_it & DMA_IT_TC) != 0U))
 {
	 HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
 }

in the DMA IRQ handler then the LED is toggled from there, so the TC flag works.

So something must be missing with the callback...

i can also see that this callback is actually not weakly defined, it is used in stm32l4xx_hal_adc.c line 3492

of course if i try to define it again the compiler complains about double definition.

void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)

 It is assigned line 2250, and this callback doesnt calls any user callback.

So I wonder how we can process datas in the case of continuous conversion to large buffer if there is no way to flip the buffer?

Because with a single buffer it will never be available for data processing (being constantly used) and we cannot even know that the buffer is filled :\ . I must be missing something.

One can easily make your own isrs. Look in the assembly file that contains the vector table and declare a void function with the correct name for the interrupt you want to use. When the compiler complains, simply delete the old one. You will need to test the flag bits in the isr to determine the cause of the interrupt and clear them before exiting. It's all in the data sheet.​

Also, use either the buffer half/full​ interrupt with a single 2x buffer or Double buffer with full interrupt and 2x single buffer. I think the results are the same.

It's all in the data sheet......​

Sorry, you misunderstood my comment. You need to get rid of all the hal crap and write your own ​low level isr. Look in startup_32xxxxx.s and find the name in the interrupt vector table that matches the dma and stream you are using.

In my code, i am using dma with adc multimode on an f730, so i use dma2_stream0 for adc1 ( table in dma description of RM ) and declare

​

void DMA2_Stream0_IRQHandler( void )

​

Function in main.c

​

In the isr you need to read LISR to find the cause of the interrupt ( either buffer half or full​ ) and then clear the bit by writing to LIFCR.

Again, the compiler or linker will complain about multiple definition of the isr, just delete/comment out the old one.

Also, write your own initialization code. It's the only way to know that it's done properly. Setting up a dma with double buffering and interrupt is only like 8 lines of simple code.​ study the RM and use the debugger, it will start to make sense.

so, there is no double buffering in the STM32L4 DMA, contrary to F4 and other series. So i guess the only way is to do it by hand. I noticed that HAL_ADC_ConvCpltCallback(hadc); was only weakly defined and not actually used by the HAL, so i declared it in my main, and indeed it is called at TC.

So i crudely used it to stop DMA, set the other buffer and restart DMA (the GPIO toggle is for debug, the incremented tc flag is for cycles counting). Of course there is quite an overhead to do that, with a 1024 buffer it cost about 1400 cycles (26550 with DB, 25125 without DB) or 28uS (331uS vs 313uS) . so some samples are lost in the process (sampling rate is 1.334MSPS). If anyone has a better idea it will be much appreaciated.

N.B i dont understand why the HAL has to use extensively ISRs internally for continuous ADC acquisition via DMA, what is the point of having DMA if the MCU is overwhelmed by ISRs?

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc){
 
	HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
	tc+=1;
	HAL_ADC_Stop_DMA(&AdcHandle);
	if(!bfr){bfr=1; HAL_ADC_Start_DMA(&AdcHandle, (uint32_t*) bfrA, 1024); }
	else{bfr=0; HAL_ADC_Start_DMA(&AdcHandle, (uint32_t*) bfrB, 1024); }
}

Does the l4 have half and buffer full interrupts? It's the same thing as double buffering, just use a buffer that is twice the required size, that way the buffer half or full​ interrupt is telling you that you can start processing the data in either lower or upper half of the buffer. Voila! Double buffering!

And once again, don't use hal. You are declaring the wrong isr. If you want a quick & lean isr you need to use the very lowest level and set/clear register bits yourself. I've just reexplained the same thing like 3 times in this thread. At some point you need to think for yourself. It's called learning.​

i am not so sure it is safe to access the same buffer as the DMA at the same time tho (even if it is not the samehalf). F4 serie (and others) have some specific DMA function for double buffering (one can provide two different buffers), if there is no difference between that and using the HC and TC flags with a single buffer then i wonder why they bothered to add such mecanism.

You are declaring the wrong isr

Not sure what you mean, HAL_ADC_ConvCpltCallback is defined weak and called from within ADC_DMAConvCplt, since it is not used by the HAL it is actually the callback for user (provided that ADC_DMAConvCplt is already used by the HAL). And indeed when declared it is called at the right time and does the job.

if I can actually transfer datas from first buffer half when the DMA is writing the second half, i then just use HAL_ADC_ConvHalfCpltCallback and dont switch buffers, no overhead, no samples lost.

To get rid of the HAL ISRs and use own ISR + direct register access one has to rewrite not only ISRs but the whole ADC+DMA implementation, because ADC, DMA and ISRs are tied together and a lot of things are configured / handled by the HAL. Here the problem was to get the callback with what is already in place, and the answer to that is : use HAL_ADC_ConvCpltCallback, quite simple. Using low level ISR may incidently adress the issue, but at the cost of reimplementing everything by hand, I dont see the need for that here.

Ok.

Do whatever you want, but if you are interested in writing fast & efficient embedded code you are going about it the wrong way.

Over & out.​