If you set the analogWriteResolution() value to a value higher than your board's capabilities, the Arduino will discard the extra bits.

If you set the analogWriteResolution() value to a value lower than your board's capabilities, the missing bits will be padded with zeros to fill the hardware required size.

analogWriteResolution() sets the resolution of the analogWrite() function. It defaults to 8 bits (values between 0-255) for backward compatibility with AVR based boards.

By setting the write resolution to 12, you can use analogWrite() with values between 0 and 4095 to exploit the full DAC resolution or to set the PWM signal without rolling over.

bits: determines the resolution (in bits) of the values used in the analogWrite() function. The value can range from 1 to 32. If you choose a resolution higher or lower than your board's hardware capabilities, the value used in analogWrite() will be either truncated if it's too high or padded with zeros if it's too low. See the note below for details.

analogWriteResolution() sets the resolution of the value that can be used by analogWrite(). It defaults to 8 bits (values between 0-255) for backward compatibility with AVR based boards.

The Due has the following hardare capabilities:

• 12 pins with 8-bit PWM (as the other AVR based boards)
• 2 pins with 12-bit DAC (Digital-to-Analog Converter)

By setting the write resolution to 12, we can use analogWrite() with values between 0 and 4095 to exploit the full DAC resolution or to set the PWM signal without rolling over.

bits: determines the resolution (in bits) of the values used in analogWrite() function. Valid arguments are between 1 and 32. If a resolution higher or lower than hardware capabilities is set, value used in analogWrite() will be respectively truncated or padded with zeros. See the note below for details.

If a resolution higher than the hardware capabilities is set, the Arduino will discard the extra bits. For example: using the Due with analogWriteResolution(16) on a 12-bit DAC pin, only the first 12 bits of the values passed to analogWrite() will be used and the last 4 bits will be discarded.

If a resolution lower than the hardware capabilities is set, the missing bits will be padded with zeros to fill the hardware required size. For example: using the Due with analogWriteResolution(8) on a 12-bit DAC pin, the Arduino will add 4 zero bits to the 8-bit value used in analogWrite() to obtain the 12 bits required.

  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);

  analogWrite(11, map(sensorVal, 0, 1023, 0 ,255));

  analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));

bits: determines the resolution (in bits) of the PWM functionality. Valid arguments are between 0 and 12. You can set the resolution larger than 12, but higher values are ignored. See the note below for details.

analogWriteResolution() sets the resolution of the value that can be used by analogWrite(). It defaults to 8 bits (returns values between 0-255) for backward compatibility with AVR based boards.

bits: bits: determines the resolution (in bits) of the PWM functionality. Valid arguments are between 0 and 12. You can set the resolution larger than 12, but higher values are ignored. See the note below for details.

analogWriteResolution() is an extension of the Analog API for the Arduino Due.

analogWriteResolution() sets the resolution of the value that can be used by analogWrite(). It defaults to 8 bits (returns values between 0-255) for backward compatibility.

If a resolution larger than the hardware capabilities is set, the Arduino will limit to highest supported resolution.

analogWriteResolution()

Syntax

analogWriteResolution(bits)

• map()

  // open a serial connection
  Serial.begin(9600); 
  // make our digital pin an output
  pinMode(11,OUTPUT);

  // read the input on A0 and map it to a PWM pin
  // with an attached LED
  int sensorVal = analogRead(A0);
  Serial.print("Analog Read) : ");
  Serial.print(sensorVal);

  // the default PWM resolution
  analogWriteResolution(8);
  analogWrite(13, map(sensorVal, 0, 1023, 0 ,255));
  Serial.print(" , 8-bit PWM value : ");
  Serial.print(map(sensorVal, 0, 1023, 0 ,255));

  // change the PWM resolution to 12 bits
  // the full 12 bit resolution is only supported
  // on the Due
  analogWriteResolution(12);
  analogWrite(13, map(sensorVal, 0, 1023, 0, 4095));
  Serial.print(" , 12-bit PWM value : ");
  Serial.print(map(sensorVal, 0, 1023, 0, 4095));

  // change the PWM resolution to 4 bits
  analogWriteResolution(4);
  analogWrite(13, map(sensorVal, 0, 1023, 0, 127));
  Serial.print(", 4-bit PWM value : ");
  Serial.println(map(sensorVal, 0, 1023, 0, 127));
  delay(5);

• analogWrite()

• map()

The Due has 12-bit PWM capabilities that can be accessed by changing the resolution. At 12 bits, analogWrite() can use values between 0 and 4095 without rolling over.

bits: determines the resolution (in bits) of the PWM functionality. You can set the resolution larger than 12 and less than 8, see the note below for how this is dealt with.

If a resolution larger than the hardware capabilities is set, the Arduino will limit to highest supported resolution. For example, using the Uno with analogWriteResolution(10) will only allow you to use an 8-bit number.

 // make our digital pin an output
 pinMode(11,OUTPUT);

 // read the input on A0 and map it to a PWM pin
 // with an attached LED
 int sensorVal = analogRead(A0);
 Serial.print("Analog Read) : ");
 Serial.print(sensorVal);

 // the default PWM resolution
 analogWriteResolution(8);
 analogWrite(13, map(sensorVal, 0, 1023, 0 ,255));
 Serial.print(" , 8-bit PWM value : ");
 Serial.print(map(sensorVal, 0, 1023, 0 ,255));

 // change the PWM resolution to 12 bits
 // the full 12 bit resolution is only supported
 // on the Due
 analogWriteResolution(12);
 analogWrite(13, map(sensorVal, 0, 1023, 0, 4095));
 Serial.print(" , 12-bit PWM value : ");
 Serial.print(map(sensorVal, 0, 1023, 0, 4095));

 // change the PWM resolution to 4 bits
 analogWriteResolution(4);
 analogWrite(13, map(sensorVal, 0, 1023, 0, 127));
 Serial.print(", 4-bit PWM value : ");
 Serial.print(map(sensorVal, 0, 1023, 0, 127));

analogWriteResolution(bits)

Description

Sets the resolution of the value that can be used by analogWrite(). It defaults to 8 bits (returns values between 0-255) for backward compatibility.

The Due has 12-bit DAC capabilities that can be accessed by changing the resolution. A 12 bits, analogWrite() can use values between 0 and 4095 without rolling over.

Parameters

bits: determines the resolution (in bits) of the ADC. You can set the reolution larger than 12 and less than 8, see the note below for how this is dealt with.

Returns

None.

Note

If a resolution larger than the hardware capabilities is set, the Arduino will limit to highest supported resolution. For example, using the Uno with analogReadResolution(10) will only allow you an 8-bit number.

If a resolution lower than the hardware capabilities is set, the least significant bits will be ignored.

Example

(:source lang=arduino:) void setup(){

 // open a serial connection
 Serial.begin(9600); 

}

void loop(){

 // read the input on A0 at default resolution (10 bits)
 // and send it out the serial connection 
 analogReadResolution(10);
 Serial.print("ADC 10-bit (default) : ");
 Serial.print(analogRead(A0));
 delay(5);
 // change the resolution to 12 bits and read A0
 analogReadResolution(12);
 Serial.print(", 12-bit : ");
 Serial.print(analogRead(A0));
 delay(5);
  // change the resolution to 16 bits and read A0
 analogReadResolution(12);
 Serial.print(", 16-bit : ");
 Serial.print(analogRead(A0));
 delay(5);
 // change the resolution to 8 bits and read A0
 analogReadResolution(8);
 Serial.print(", 8-bit : ");
 Serial.println(analogRead(A0));
 delay(5);

} (:sourceend:)

See also

• Description of the analog input pins
• analogRead()