Don't give special treatment of 0 and 255 in Arduino AVR Boards' analogWrite()

[Coding-Badly]

http://forum.arduino.cc/index.php?topic=303922.0

By using digitalWrite for analogWrite values of zero and 255 the AVR core creates a situation that can cause a glitch.

The solution is simple. Do not treat zero and 255 as special cases. digitalWrite disables PWM so the user can call digitalWrite in the rare circumstances when they want PWM turned off.

The only side-effect is with Fast PWM pins. Instead of a clean "off" there will be a narrow spike for zero.

[T-Kuhn]

Wow. Thanks for the Hint!
I changed the PWM resolution from 8 to 10 bits (via the TCCRXA & TCCRXB registers) and it worked beautifully (new scale 0 ~ 1024). Except that there was a strange peak at - yes, you guessed correctly - 255; Because that Number is for some reason treated as special case.

Since I don't see the reason behind the special treatment I support Coding-Badly's solution, for it would have saved me hours of debugging. Who would expect such special treatment for 0 and 255 in the analogWrite function?

[peabo7]

You would only know if you had previously read the library source code. (My condolences for your loss of time.) A general recommendation would be to rely on the datasheet and also the library source code before making a change.

As for why it was implemented this way, I suspect some awkward treatment of the edge cases for the original 8 bit PWM.

Peter Olson

[T-Kuhn]

Hello Peter Olson,
You are completely right. I also am aware of the fact, that my case (making the 8bit PWM 10bit and THEN experiencing some kind of malfunction of analogWrite) is very different from what Coding-Badly is talking about.

So - to get back to the actual topic - there might really be a problem with the way the function falls back to digitalWrite in the cases of 0 and 255. You can read Coding-Badly's findings here:
Coding-Badly/arduino-tiny#128

[elektor-labs]

I vote for the removal of at least the 255 check. Not only is the 255 check useless, it is also strange because the argument of analogWrite is an int and not an unit8_t and it hinders people wanting to use analogWrite with a higher resolution PWM signal from 16-bit timers.

The zero check is more involved due to the fact that timer0 is used in Fast PWM mode and all the others in Phase Correct PWM mode, which is why pins 5 & 6 behave differently at 0% duty-cycle compared to pins 3, 9, 10 & 11. (On the other hand, they also run at a higher frequency, so they might as well be treated as a different kind of PWM signals.)

To get past the zero check one could (for timer0 only) for the case of 0% invert the PWM and set it to 100%, like this:
if (val==0) { val=255; sbi(TCCR0A, COM0A0); } else cbi(TCCR0A, COM0A0);
right after the case TIMER0A: & case TIMER0B:
That will produce real 0% and 100% PWM on pins 5 & 6 without having to fiddle with the pin modes.

[vicnevicne]

Hi, I'm the guy who noticed this issue in the forum thread listed in the opening comment.

After nearly 10 years, I'm porting my project from AtTiny to Arduino Nano (I might port it to ESP8266 in 2035 ;-)), and sure enough, I'm facing the same issue.
The workaround is straightforward: create an alternate version of analogWrite (I called it pureAnalogWrite()) that does not make 0 and 255 special cases.
To make your life easier, here's the recipe:

1. replace your calls to analogWrite by pureAnalogWrite
2. paste the following in your sketch:

// This is a modified version of Arduino's analogWrite() that does not default 
// to digitalWrite() when value is 0 or 255.
// For details, see https://github.com/arduino/ArduinoCore-avr/issues/170
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
void pureAnalogWrite(uint8_t pin, int val)
{
  // Make sure the pin is in output mode
  // for consistenty with Wiring, which doesn't require a pinMode
  // call for the analog output pins.
  pinMode(pin, OUTPUT);
  switch(digitalPinToTimer(pin))
  {
    #if defined(TCCR0) && defined(COM00) && !defined(__AVR_ATmega8__)
    case TIMER0A:
      // connect pwm to pin on timer 0
      sbi(TCCR0, COM00);
      OCR0 = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR0A) && defined(COM0A1)
    case TIMER0A:
      // connect pwm to pin on timer 0, channel A
      sbi(TCCR0A, COM0A1);
      OCR0A = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR0A) && defined(COM0B1)
    case TIMER0B:
      // connect pwm to pin on timer 0, channel B
      sbi(TCCR0A, COM0B1);
      OCR0B = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR1A) && defined(COM1A1)
    case TIMER1A:
      // connect pwm to pin on timer 1, channel A
      sbi(TCCR1A, COM1A1);
      OCR1A = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR1A) && defined(COM1B1)
    case TIMER1B:
      // connect pwm to pin on timer 1, channel B
      sbi(TCCR1A, COM1B1);
      OCR1B = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR1A) && defined(COM1C1)
    case TIMER1C:
      // connect pwm to pin on timer 1, channel C
      sbi(TCCR1A, COM1C1);
      OCR1C = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR2) && defined(COM21)
    case TIMER2:
      // connect pwm to pin on timer 2
      sbi(TCCR2, COM21);
      OCR2 = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR2A) && defined(COM2A1)
    case TIMER2A:
      // connect pwm to pin on timer 2, channel A
      sbi(TCCR2A, COM2A1);
      OCR2A = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR2A) && defined(COM2B1)
    case TIMER2B:
      // connect pwm to pin on timer 2, channel B
      sbi(TCCR2A, COM2B1);
      OCR2B = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR3A) && defined(COM3A1)
    case TIMER3A:
      // connect pwm to pin on timer 3, channel A
      sbi(TCCR3A, COM3A1);
      OCR3A = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR3A) && defined(COM3B1)
    case TIMER3B:
      // connect pwm to pin on timer 3, channel B
      sbi(TCCR3A, COM3B1);
      OCR3B = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR3A) && defined(COM3C1)
    case TIMER3C:
      // connect pwm to pin on timer 3, channel C
      sbi(TCCR3A, COM3C1);
      OCR3C = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR4A)
    case TIMER4A:
      //connect pwm to pin on timer 4, channel A
      sbi(TCCR4A, COM4A1);
      #if defined(COM4A0)		// only used on 32U4
      cbi(TCCR4A, COM4A0);
      #endif
      OCR4A = val;	// set pwm duty
      break;
    #endif
    
    #if defined(TCCR4A) && defined(COM4B1)
    case TIMER4B:
      // connect pwm to pin on timer 4, channel B
      sbi(TCCR4A, COM4B1);
      OCR4B = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR4A) && defined(COM4C1)
    case TIMER4C:
      // connect pwm to pin on timer 4, channel C
      sbi(TCCR4A, COM4C1);
      OCR4C = val; // set pwm duty
      break;
    #endif
      
    #if defined(TCCR4C) && defined(COM4D1)
    case TIMER4D:				
      // connect pwm to pin on timer 4, channel D
      sbi(TCCR4C, COM4D1);
      #if defined(COM4D0)		// only used on 32U4
      cbi(TCCR4C, COM4D0);
      #endif
      OCR4D = val;	// set pwm duty
      break;
    #endif

            
    #if defined(TCCR5A) && defined(COM5A1)
    case TIMER5A:
      // connect pwm to pin on timer 5, channel A
      sbi(TCCR5A, COM5A1);
      OCR5A = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR5A) && defined(COM5B1)
    case TIMER5B:
      // connect pwm to pin on timer 5, channel B
      sbi(TCCR5A, COM5B1);
      OCR5B = val; // set pwm duty
      break;
    #endif

    #if defined(TCCR5A) && defined(COM5C1)
    case TIMER5C:
      // connect pwm to pin on timer 5, channel C
      sbi(TCCR5A, COM5C1);
      OCR5C = val; // set pwm duty
      break;
    #endif

    case NOT_ON_TIMER:
    default:
      if (val < 128) {
        digitalWrite(pin, LOW);
      } else {
        digitalWrite(pin, HIGH);
      }
  }
}