Dim it with PWM

This is the newer board, the one with the PWM pad. The earlier version has no PWM pin, so this sketch has nothing to drive on it.

Duty cycle and frequency

A PWM pin turns the dimmer switch on and off over and over. Two numbers describe it, and they do different jobs.

The duty cycle is the fraction of each period the pin is high. The switch is on for that fraction, the digit is lit for that fraction, and the average light is proportional to it. This is the brightness. 0 % is dark, 100 % is a pin held high.

The frequency is how many periods a second there are, and so how long each lit and dark stretch is. It does not change the average light. It changes whether you can see the switching.

The bar shows average light, which is proportional to duty because the switch is fully on or fully off. It is not what the eye reports, and that is not linear, so a 50 % duty cycle usually does not look half as bright as 100 %.

On an Uno analogWrite() gives about 490 Hz on pins 3, 9, 10 and 11, and about 980 Hz on pins 5 and 6. D11 is already the latch here, so the sketch uses D9. A low frequency can be seen as flicker, and a phone camera usually shows it sooner than an eye does. We have not found, and do not claim, a frequency above which it stops. The switch itself is not the limit: R9 times Q2's gate capacitance is about 2.7 microseconds, and the periods here are 1 to 2 milliseconds.

The sketch

The wiring is in the comment header: 12 V and its ground to the two-pin header, 5 V and ground and three signals to the six-pin one, and D9 to PWM. It does not need a library. Bring the supply's ground and the Uno's ground to the same point.

show() is the three lines from the shift register page. loop() ramps the duty cycle from 0 to 255 and back, in 6 ms steps, then moves to the next digit. Look at what happens in between: the digit is dark at the bottom of the ramp, and the next digit is sent while it is dark. When the ramp starts again the new digit is simply there. The register held its byte the whole time, and the dimmer only decided whether it was visible.

The same on an ESP32

Arduino core 3.x has analogWrite() too, on any output pin, and analogWriteFrequency(pin, hz) to set the rate, which defaults to roughly 1 kHz. One thing differs. analogWrite() attaches the pin to the LEDC hardware, and after that a plain digitalWrite() on that pin is refused. Use analogWrite(pin, 0) for low and analogWrite(pin, 255) for high on any pin that is ever PWM'd.

// Same wiring as the Uno sketch, on an ESP32 with Arduino core 3.x.
// Pick any four free GPIOs; these are examples. The PWM pad stays open.
#define SER  4
#define LAT  5
#define CLK  6
#define PWM  7

const uint8_t d[] = {
  0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F
};

void show(uint8_t b) {
  digitalWrite(LAT, LOW);
  shiftOut(SER, CLK, MSBFIRST, b);
  digitalWrite(LAT, HIGH);
}

void setup() {
  pinMode(SER, OUTPUT);
  pinMode(LAT, OUTPUT);
  pinMode(CLK, OUTPUT);
  analogWriteFrequency(PWM, 1000);   // Hz; call before the first analogWrite
  analogWrite(PWM, 0);               // low. Not digitalWrite: see the text
  show(d[8]);
}

void loop() {
  for (int level = 0; level <= 255; level++) { analogWrite(PWM, level); delay(6); }
  for (int level = 255; level >= 0; level--)  { analogWrite(PWM, level); delay(6); }
}

Its pins are 3.3 V logic. That runs U1 (2 V to 6 V) and is, on the arithmetic of the previous page, enough to turn Q1 on; that page says what was not measured.