AVR Freaks

Hi JC, thank a lot for the reply! ;)

I try to give you more information about my project.

This are the signals in my system:

• The current is in the range [~0,8] [A]
• The voltage is in the range [0,~8.4] [V]
• The thrust is in the range [0, ~1.5] [N]
• The speed is in the range [~400,~2300] [Hz]

This values are near at the nominal value that i expect from my system. This nominal values get out from the varius datasheets relative at the varius components in the system.

Note that this system is a university version of a professional system, so the board is a homemade version of a professional one. However i measure the thrust using a strain gauge with an instrument op-amp (ina125p). The circuit that i have done is on the datasheet of the ina125p. The other analog signals go out from an resistor divisor and an acs712 sensor, respectly the voltage signal and the current signal.

The resistor divisor and the acs712 are mounted to measure the power supply in input of the motor. This is a lipo battery @8.4[V]. The board have the pin out to drive the esc and the pin to drive the signal from the encoder to the micro. All this component have a common ground (ground plane).

Using this nominal data some signals in the graph above make sense becasue the second graph display a value about 5[V] that are correct because the battery is at ~8.4[V], and the last graph display a step signal that are near 2300[Hz]. The other values, the first and the tird are quite correct because the acs712 sensor give ~2.5[V] @ ~0[A] and the straing gauge measure only the weigth of the motor, so it value is valid because 0.4[V] are ~16[g].

The software is my actor framework. In practice i make two actors, and they communicate using a queue. One actor is responsible to the communication from world-micro and viceversa. The other actor contains the program logic so it handle the command and the interrupt, and send data to the world. The runtime is a loop that receive a message and send it to the receiver actor.

I have done some experiment after read your post and the data isn't reproducible, some time the spike appear before and some time the spike appear after the 0.75[s]. At this moment i haven't access to laboratory, monday i have an oscilloscope to measure and record all!

However at this instant, in the system nothing is happening. I give a step signal to the motor, and this start at 0.5[s]

However I have done some other experiment before this post. I obtained this:

I have done this experiment using the same software, the only two thing that i do in this case is comment out this line in my c++ routine that run when an ICP interrupt occours:

bool
Icp5::isr() volatile{
	curr = (unsigned int)ICR5;
	//period = curr-prev;  <-----
	prev = curr;
	if( ++i == 2 ){
		TCCR5B &= ~(1 << CS51);
		TIMSK5 &= ~(1 << ICIE5);
		return true;
	}
	else return false;
}

and send a costant value of one for all acquistion session for this value. Using this value and a timer resolution of 5e-7[s] (16[Mhz]/8) i obtain a value of 2[MHz].

My question at the end of my previous post are relative at this last experiment, so i'm confused a lot!

In this case the spike don't appear, but if i repeat the experiment some times the spike appear near at 0.75[s].

I have an homemade simulator that i use at home. It consist of an arduino board that generate a pulse. I have used this pulse to design and test the software for the encoder. 

However monday i try to build a most complete simulator in the laboratory.

Thanks a lot for the advice!!

Clawson, I'm sorry but your answer don't help and confuse me. I know from the datasheet that you told me. So if I have a fcpu of 16MHz and I use a prescaler of 64, my fadc is 16MHz/64=250KHz so the adc sampling rate is 250KHz/13=19.2KHz. Using this sampling rate I obtain a resolution that is lower than 10 bits. Ok, this is good for me. But now I have my signals that are sampled at 19.2KHz, right? And I 'resample' this signals every 10 ms. For resample, I mean that every 10 ms I start the adc for sampling the signals. When the adc finish, I wait the next tick to start the adc and acquire the next sample. Is this the correct way to acquire my signals at 100 Hz? This is my main question!
I realise that the adc has a maximum and a minimum sampling rate, but even if I change the fcpu so that the minimum fadc is 50KHz, I obtain a sampling rate that is 50KHz/13=3.8KHz, and this is too hight respect my 100 Hz. Again, if I need to acquire a signals @ 100 Hz, how I do with an avr microcontroller?

Only if you do "back to back" conversions - that is set ADSC again as soon as each conversion completes and you have collected the "previous" result.

Like free running?

But if you trigger on the 10,000us (10ms) boundaries then you will get a reading 52us later then you will wait 9,948us doing nothing until you trigger again at the next 10,000us boundary. 

This is my conception of sampling at 100 Hz (this is that my prof suggest me). Precisely i would acquire exactly one sample of each channels (3 channels in tot) every 10 ms.

After the acquisition session, I elaborate this data on the pc. The purpose of this acquisition is to collect some data for identifing some parameters of the dynamic model of the rotor. For do this, i use a matlab specific toolbox that handle all mathematical operation. In practice i give a matlab the vectors of data and matlab usign an optimization algorithms find the unknow parameter of the given dynamical model.

For do this, i need to collects the data in the 10 ms range. Is not a problem when this appens in the 10 ms range because the theory say that in the sampling process there is a lost of information ecc ecc...

However thank you so much Clawson, your answer help me a lot to clarifing this aspect on the avr adc. If i correct understand the adc sampling rate is the "speed" on how the avr mpu sample an analog signals. This really is the sampling rate only if the sampling process is fast enough ("back to back"), otherwise one can use the adc sampling rate, like a parameter to speed up/down and increase/decrease the resolution of the conversion process at given frequency, right?

However now i have redesigned the firmware such that all operation are like sequential and not in multithreading fashion. In this way, i think that i minimize the sync problem due to the use of the interrupts. 

I have read a lot about volatile, memory barrier and compiler optimization option. For me this kind of arguments are very hard to learn and uderstand because there is leak of learnig material! However i have read some your interesting post about this kind of arguments and i would to thank you so much to share your know how! :)

For this proposit, i have notice your signature faq#4, what is really mean?

For design my framework, i have used this setting on atmel studio:

• optimization level = -O0
• debug level = Maximum (-g3)
• enable the warning as error, pedantic and pedantic warning as error
• -std=c++11

I have obtained a big code, like 32 kb and it seem to work. Hovewer, i have done a version of the firmware that doesn't run at 100 Hz, but if i change the optimization level (-O1 and others), the firmware run at 100 Hz!

After this i understand the potential of the compiler optimizator, but i don't know how to use it correctly. Please can you give me some info or advice on how i can maximise the use of the optimizator?

Thank for reply dbrion0606!

In my framework i tried to minimize the use of the external library, so i can't use any of this kind of delay. When i need a delay, i send a delay message to the scheduler. In the scheduler loop, at every loop i check if there is some message to execute, if there aren't message, the loop restart, so recheck the message queue and so on. In this way i obtain a delay.. :)  Obviosly this is not an hard real time framework..

However i understand that you tell me and i used all kind of precaution that i know! Declare volatile the variables that can change in inaspected way and so on.

The problem is that i do all in c++, so i use object. With the object, the volatile keyword as the same mean as non object variable, but the semantics change a bit. In this case there is a leak in the licterature because all the c++ OOP books that i have read, don't give sufficient information about the object and the volatile keyword. There are some good article on internet that clarifing some aspect on the object and the volatile keyword in c++, but the leak of know how remains and however, a very limited number of this article is avr architecture friendly!

I have to read some other articles to tell you more about this argument.