AVR Freaks

I am using a "software" PMW, not hardware. That is why COMnx bits are keep at 0. That way I can generate PMW on any PORT's bit I want...

I have to change TCNT1 to control my period in that case...

Again, my PMW works very well if I remove the PCINT interrupt, so I don't think the problem is from the logic...

Thanks for the answer.

Something that I did not mention is that my PCINT ISR definition is : ISR(PCINT0_vect, ISR_NOBLOCK)

I use ISR_NOBLOCK so even if my PCINT routine is too long, I should go into the timer1 interrupt everytime I should, am I?

Here is the entire code, it could help you a bit more :

#include <avr/io.h>
#include <avr/interrupt.h>

//Convert microseconds to ticks
uint32_t usToTicks(uint32_t us);

//Convert ticks to microseconds
uint32_t ticksToUs(uint32_t ticks);

//Re-maps a number from one range to another
long map(long x, long in_min, long in_max, long out_min, long out_max);

//Constants
const float clockSourceMhz = 8.0f;
const uint8_t prescaler = 8; //Timer1 prescaler

//PMW Constants PMW in microseconds
const uint16_t rcMinUs = 1400;
const uint16_t rcMaxUs = 2000;
const uint16_t motorMinUs = 700;
const uint16_t motorMaxUs = 2300;

//Time in milliseconds since the program has begun
volatile uint32_t timeFromStartMs = 0;

//Initial motor speed (PMW high signal in microseconds)
volatile unsigned int servo[4] = {2300, 2300, 2300, 2300};
//Controlled motor ID number : 1, 2, 3 or 4
volatile int8_t channel = 1;

//Used to calculate the RC PMW lenght
volatile uint16_t previousThrottle = 0;
volatile uint8_t portbhistory = 0;

//RC commands
volatile int16_t throttleUs = 0; //Altitude control

int main(void){

	PCICR |= 1<<PCIE0; //Enable interrupt of PCINT7:0
	PCMSK0 |= 1<<PCINT3;
	
	TCCR1B |= 1<<CS11; //Prescaler of 8 because 8MHz clock source
	TIMSK1 |= (1<<OCIE1A); //Interrupt on OCR1A
	OCR1A = servo[0]; //Set the first interrupt to occur when the first pulse was ended
	
	DDRD |= 1<<DDD1 | 1<<DDD2 | 1<<DDD3 | 1<<DDD4; //Motors as output
	PORTD = 1<<channel; //Set first servo pin high
	
	sei(); //Enable global interrupts
	
	while(1){
		
		//ESC calibration
		if((timeFromStartMs > 2300) && (timeFromStartMs < 7000)){
			servo[0] = 700;
			servo[1] = 700;
			servo[2] = 700;
			servo[3] = 700;
		}
		
		//Motor controlled by RC command
		if(timeFromStartMs > 7000){
			int16_t computedThrottle = map(throttleUs, 1400, 2000, 700, 1400);
			servo[0] = computedThrottle;
			servo[1] = computedThrottle;
			servo[2] = computedThrottle;
			servo[3] = computedThrottle;
		}
	}

	return 0;
}

//PMW Building ISR
ISR(TIMER1_COMPA_vect)
{
	uint16_t timerValue = TCNT1;
	if(channel < 0){ //Every motors was pulsed, waiting for the next period
		if(timerValue >= usToTicks(20000)){
			TCNT1 = 0;
			channel = 1;
			PORTD |= 1<<channel;
			OCR1A = servo[0];
			timeFromStartMs += 20;
		}
		else{
			OCR1A = usToTicks(20000);
		}
	}
	else{
		if(channel < 4){
			OCR1A = timerValue + servo[channel];
			PORTD &= ~(1<<channel); //Clear actual motor pin
			PORTD |= 1<<(channel + 1); //Set the next one
			channel++;
		}
		else{
			PORTD &= ~(1<<channel); //Clear the last motor pin
			OCR1A = usToTicks(20000);
			channel = -1; //Wait for the next period
		}
	}
}


ISR(PCINT0_vect, ISR_NOBLOCK){
    
    uint16_t timerValue = TCNT1;
    	
	uint8_t changedbits;

	changedbits = PINB ^ portbhistory;
	portbhistory = PINB;
	
	//PCINT3 changed
	if( (changedbits & (1 << PB3)) )
	{
		//Is now high
		if(PINB & 1<<PORTB3){
			previousThrottle = timerValue;
		}
		//Is now low
		else{
			if(timerValue > previousThrottle){
				throttleUs = ticksToUs(timerValue - previousThrottle);
			}
			else{
				throttleUs = ticksToUs((usToTicks(20000) - previousThrottle) + timerValue);
			}
			
			//Constrain value between motorMaxUs and motorMinUs
			if(throttleUs > motorMaxUs){
				throttleUs = motorMaxUs;
			}
			else if(throttleUs < motorMinUs){
				throttleUs = motorMinUs;
			}
		}
	}
}


//Functions describe before

uint32_t usToTicks(uint32_t us){
	return (clockSourceMhz * us) / (float)prescaler;
}

uint32_t ticksToUs(uint32_t ticks){
	return ((ticks * (float)prescaler) / clockSourceMhz);
}


long map(long x, long in_min, long in_max, long out_min, long out_max)
{
	long result = (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
	
	if(result < out_min){
		result = out_min;
	}
	else if(result > out_max){
		result = out_max;
	}
  
	return result; 
}

Ok, so I am not familiar with that "atomic" thing... I understood that it means I clear the interrupt while the instruction is realised right? Two questions about it:

1) What is the better way of doing it?

2) If i clear the interrupt, then I could miss a timer1 interrupt and so my software PMW will still act weirdly, isn't it?

Thanks for all your comments. I partially find the problem.

Actually this is not from the atomicity missing, but from my map() function. If you look at the code I posted last time, I did this:

int16_t computedThrottle = map(throttleUs, 1400, 2000, 700, 1400);
servo[0] = computedThrottle;
servo[1] = computedThrottle;
servo[2] = computedThrottle;
servo[3] = computedThrottle;

If a directy code the map function like this:

servo[0] = ((float)throttleUs - 1400) * (1400 - 700) / (2000 - 1400) + 700;
servo[1] = ((float)throttleUs - 1400) * (1400 - 700) / (2000 - 1400) + 700;
servo[2] = ((float)throttleUs - 1400) * (1400 - 700) / (2000 - 1400) + 700;
servo[3] = ((float)throttleUs - 1400) * (1400 - 700) / (2000 - 1400) + 700;

Then it works... Notice that I need a float cast.

I still don't really know why, maybe somebody can help me. It is certainly about types...

Now I have a new thing that is weird. The code above works, but this one is not working:

ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{	
	int16_t computedThrottle = ((float)throttleUs - 1400) * (1400 - 700) / (2000 - 1400) + 700;
}

servo[0] = computedThrottle;
servo[1] = computedThrottle;
servo[2] = computedThrottle;
servo[3] = computedThrottle;

If I use this code, my motors are going at maximum speed whatever is the throttleUs value...

Here I really don't understand why... Can somebody help me on that?

Thanks.