AVR Freaks

Your code will go through main() once then drop off the edge of the earth. You need a while(1){} around your code to ensure it keeps on running.

why do you need PWM for an LED?

ryan2019 wrote:

However I did not get the output that I want.  I observe the following:

- The LED is not completely turned OFF when the input toggle switch is connected to GND.  It is dimly activated.

With AVR8 Fast PWM, you cannot get full-on AND full-off.  The usual approach is to use inverted PWM and invert the duty cycle value.  As you observe, you can see a 1/256 duty cycle, but you won't be able to detect 254/255 versus 255/255.

 

https://www.avrfreaks.net/comment/2792041#comment-2792041

https://www.avrfreaks.net/comment/2202081#comment-2202081

https://www.avrfreaks.net/comment/2091101#comment-2091101

https://www.avrfreaks.net/comment/2062056#comment-2062056 (and link)

...

ryan2019 wrote:

However when I toggled the switch back to GND the LED did not turn OFF.  It is still fully turned ON.  The LED does not change status anymore even after multiple input switch toggled.

Well that sounds completely expected, considering the code effectively breaks from the while loop after LED is turned on.

 

Also, the loop that runs only once (commented with "counter to execute ony once") makes no sense.

 

How about this code?

#include <avr/io.h>
#define F_CPU 16000000UL
#include <util/delay.h>

volatile uint16_t duty_cycle;

void Timer0_init(void)
{
    TCCR0A|=(1<<COM0B1)|(1<<WGM01)|(1<<WGM00);    //Clear OC0B on Compare Match, set OC0B at BOTTOM, (non-inverting mode).  Set to fast PWM.
    TCCR0B|=(1<<CS02)|(1<<CS00);                //set prescale to 1024
}

int main(void)
{                
    DDRD=0x20;        //set OC0B to output
    DDRC=0x00;      //set to input

    Timer0_init();
    
    // Wait until pin is high
    while (PINC&(1<<5) == 0)
    {
    }
        
    for(duty_cycle=0; duty_cycle<256; duty_cycle++)    //increase PWM
    {
        OCR0B=duty_cycle;        //increase duty cycle
        _delay_ms(100);            //delay of duty cycle change
    }
    
    // Wait until pin is low
    while (PINC&(1<<5) != 0)
    {
    }
    
    // Set PWM to 0
    OCR0B=0;
    
    // Do nothing
    while (1)
    {
    }
}

 

#include <avr/io.h>
#define F_CPU 16000000UL
#include <util/delay.h>

volatile uint16_t duty_cycle;

void Timer0_init(void)
{
    TCCR0A|=(1<<COM0B1)|(1<<WGM01)|(1<<WGM00);    //Clear OC0B on Compare Match, set OC0B at BOTTOM, (non-inverting mode).  Set to fast PWM.
    TCCR0B|=(1<<CS02)|(1<<CS00);                //set prescale to 1024
}

int main(void)
{
    DDRD=0x20;    //set OC0B to output
    DDRC=0x00;    //set to input

    Timer0_init();
    
    while (1)
    {
        // Wait until pin is high
        while (PINC&(1<<5) == 0)
        {
        }
        
        for(duty_cycle=0; duty_cycle<256; duty_cycle++)        //increase PWM
        {
            OCR0B=duty_cycle;    //increase duty cycle
            _delay_ms(100);        //delay of duty cycle change
        }
    
        // Wait until pin is low
        while (PINC&(1<<5) != 0)
        {
        }
    
        // Set PWM to 0
        OCR0B=0;
    
        // NB: probably need some debouncing here, for simplicity I inserted a delay
        _delay_ms(100);
    }
}

int main(void)
{
    DDRD=0x20;    //set OC0B to output
    DDRC=0x00;    //set to input
    PORTC |= (1<<5); //enable pullup on PORTC.5

Add the last line into the code. You've not shown us how you're controlling the port pin. If you leave it to float, then strange things will happen. Enabling the pullup feature stops this.

Are you sure that the MCU is not simply resetting? Is watchdog enabled? What are the fuses set to?

You might to check your schematic - I can't see a pullup resistor on the input.

 

You have a switch and a led - what do you want it to do? Don't talk in terms of implementation details.

if (PINC & (1 << 5)) {   break;   }

clawson wrote:

Presumably you want something more like:

        // Wait until pin is high
        while (PINC&(1<<5) == 0)
        {
        }
        
        for(duty_cycle=0; duty_cycle<256; duty_cycle++)        //increase PWM
        {
            OCR0B=duty_cycle;    //increase duty cycle
            _delay_ms(100);        //delay of duty cycle change
            if (PINC & (1 << 5)) {
               break;
            }
        }
    
        // Wait until pin is low
        while (PINC&(1<<5) != 0)
        {
        }

so the maximum it waits is 100ms before it next tests the state of PINC.5 and breaks out of the for() loop as soon as it sees it has gone low.

 

I think you have the wrong condition in the if-statement. The while-loop should break if pin goes low - not high.

 

I also never liked the implicit integer-to-bool conversion style so here is my attempt:

#include <avr/io.h>
#define F_CPU 16000000UL
#include <util/delay.h>

volatile uint16_t duty_cycle;

void Timer0_init(void)
{
	TCCR0A|=(1<<COM0B1)|(1<<WGM01)|(1<<WGM00);    //Clear OC0B on Compare Match, set OC0B at BOTTOM, (non-inverting mode).  Set to fast PWM.
	TCCR0B|=(1<<CS02)|(1<<CS00);                //set prescale to 1024
}

int main(void)
{
	DDRD=0x20;    //set OC0B to output
	DDRC=0x00;    //set to input

	Timer0_init();

	while (1)
	{
		// Wait until pin is high
		while ((PINC&(1<<5)) == 0)
		{
		}

		for(duty_cycle=0; duty_cycle<256; duty_cycle++)        //increase PWM
		{
			OCR0B=duty_cycle;    //increase duty cycle
			_delay_ms(100);        //delay of duty cycle change

			// Early break if pin goes low
			if ((PINC & (1 << 5)) == 0)
				break;
		}

		// Wait until pin is low
		while ((PINC&(1<<5)) != 0)
		{
		}

		// Set PWM to 0
		OCR0B=0;

		// NB: probably need some debouncing here, for simplicity I inserted a delay
		_delay_ms(100);
	}
}

 

ryan2019 wrote:

goto fade_in;

It's 2019 not 1969. The language may include "goto" but there's no real excuse for using it (except maybe in an exception handling situation).