pwm works only for min and max values in core 2.4.2 - works great in 2.4.1

[jplavoiemtl]

If you do a simple pwm analogWrite to a value beetween 0 or max=1023, the pwm output is not updated properly only in current release core 2.4.2. If using 0 or 1023 the pwm output is properly set. So only the intermediate values are affected by the bug.

Reverting back to core 2.4.1, it works fine the LED is properly varying intensity as per the proper pwm value. The problem is very easy to see on my end.

I use a WeMos D1 R2 & mini board and I see that in core 2.4.2 the board is now defined as LOLIN also so maybe the problem is related to that?

Code is simple and easy to reproduce and can be seen very easily on my LED. The LED is properly dimmed in previous core 2.4.1 with a pwmVal value let's say of 50. In core 2.4.2 it is not varying at all and only respond to the min pwmVal=0 or max pwmVal=1023 values thus showing the problem.

analogWrite(LED_Gpin, pwmVal)

[earlephilhower]

Please post a MCVE sketch using LED_BUILTIN, as this is not reproducible by me and others have used PWM w/o incident. The WEMOS->LOLIN was a name only change (I'm using that board, in fact) and didn't affect code.

[earlephilhower]

This simple test code gives a smooth pulsating LED as a test. How's it look on your board?

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output
}

void loop() {
  for (int i=0; i<=1023; i++) { analogWrite(LED_BUILTIN, i); delay(1); }
  for (int i=1023; i>=0; i--) { analogWrite(LED_BUILTIN, i); delay(1); }
}

Simple analogWrites() also do as expected in my testing, too, on the USB logic analyzer and eyeball testing.

[jplavoiemtl]

Here is my code for this issue. Working on core 2.4.1, but not on core 2.4.2. The relevant part for the pwm issue is mostly at the end.

`
#include <Timer.h>
#include <ESP8266WiFi.h> //https://github.com/esp8266/Arduino
#include <PubSubClient.h>
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h> //https://github.com/tzapu/WiFiManager
#include <ESP8266mDNS.h> //for OTA programming
#include <WiFiUdp.h> //for OTA programming
#include <ArduinoOTA.h> //for OTA programming

const int ledPin=2; // Built-in Led on pin 2, active low
const int LED_Apin=5; // Yel LED on GPIO5 or Wemos D1, active high
const int LED_Bpin=4; // Red LED on GPIO4 or Wemos D2, active high
const int LED_Cpin=14; // Yel LED on GPIO14 or Wemos D5, active high
const int LED_Dpin=12; // Yel LED on GPIO12 or Wemos D6, active high
const int LED_Epin=13; // Yel LED on GPIO13 or Wemos D7, active high
const int LED_Fpin=15; // Yel LED on GPIO13 or Wemos D8, active high
const int LED_Gpin=0; // Yel LED on GPIO0 or Wemos D3, active high

// Variables
int periodState = LOW; //Used to toggle High and Low flashes
bool first = true;
bool sequenceDone = true; //LED sequence done or occuring
int bit = 0; //bit counter for flashing sequence
String pgm_Str; //programming string for main loop in serial monitor
Timer t_LED; //Timer for LED flashing pwm mode
Timer t_Chaser; //Timer for LED flashing chaser mode
Timer t_Ring; //Timer for LED flashing ring mode

int ledEvent;
int chaserLedEvent; //for chaser timer
int ringLedEvent; //for ring timer
bool otaMode; //OTA mode flag
bool pgmMode = false; //PGM mode variable for main loop
bool chaserMode = false; //Chaser mode when true. When false: pwm mode.
bool ringMode = false;
bool drbellActive; //Doorbell active with flashing LED or inactive
bool flasherDisable = false; //Disable completely flasher and LEDs

int LED_A_Pattern; //16 bits active pattern for LED A
int LED_A_Pattern1; //16 bits first pattern for LED A
int LED_A_Pattern2; //16 bits second pattern for LED A
int LED_B_Pattern; //16 bits active pattern for LED B
int LED_B_Pattern1; //16 bits first pattern for LED B
int LED_B_Pattern2; //16 bits second pattern for LED B
int LED_C_Pattern; //16 bits active pattern for LED C
int LED_C_Pattern1; //16 bits first pattern for LED C
int LED_C_Pattern2; //16 bits second pattern for LED C
int LED_D_Pattern; //16 bits active pattern for LED D
int LED_D_Pattern1; //16 bits first pattern for LED D
int LED_D_Pattern2; //16 bits second pattern for LED D
int LED_E_Pattern; //16 bits active pattern for LED E
int LED_E_Pattern1; //16 bits first pattern for LED E
int LED_E_Pattern2; //16 bits second pattern for LED E
int LED_F_Pattern; //16 bits active pattern for LED F
int LED_F_Pattern1; //16 bits first pattern for LED F
int LED_F_Pattern2; //16 bits second pattern for LED F
int LED_G_Pattern; //16 bits active pattern for LED G
int LED_G_Pattern1; //16 bits first pattern for LED G
int LED_G_Pattern2; //16 bits second pattern for LED G

int LED_PatCounter; //Counter for active patterns for all LEDs
int patternNumber = 1; //used to enter LED patterns via serial port
int sequenceNum; //LED sequence counter for each animation
int maxSequence = 13; //Nombre de séquences d'animation
int pgmResponse;
int pwmVal = 2; //pwm value default = 2 marchait, il faut maintenant 1023??
int randomPWM;
int periodLED = 250; //LED chaser minimum: 100, 250 optimum, 500, medium: 800, slowest: 1500

int *anim; //pointeur vers l'array d'animation

int anim_first[] = { 14, 28672,
62, 31744,
254, 32512,
1022, 32704,
4094, 32752,
16382, 32764,
65534, 32767 };

int anim_crossing[] = { 32, 4098,
16520, 17416,
4609, 288,
2050, 64,
9220, 32912,
272, 8708,
64, 2049 };

int anim_chaserClr[] = {0, 33288, //LED chaser par couleurs
8738, 0, //LED B
0, 17684, //LED C
21844, 0,
0, 10402,
34952, 0,
0, 4161 }; //LED G

int anim_chaser[] = { 48, 48,
76, 76,
130, 130,
257, 257,
33280, 33280,
19456, 19456,
12288, 12288 };

int anim_power[] = { 20508, 29676,
23580, 29632,
20508, 29679,
3072, 224,
41187, 36079,
44259, 36032,
41187, 36076 };

int anim_alternate[] = {1314, 1285,
0, 5,
1297, 1285,
34816, 34952,
20548, 20560,
0, 80,
20616, 20560 };

int anim_centerin[] = { 771, 771,
1028, 1028,
4112, 4112,
49344, 49344,
4112, 4112,
1028, 1028,
771, 771 };

int anim_blast[] = { 65278, 257,
31868, 33667,
14392, 51143,
4112, 61423,
14392, 51143,
31868, 33667,
65278, 257 };

int anim_colors[] = { 17476, 17476,
35466, 35466,
17476, 17476,
35466, 35466,
17476, 17476,
35466, 35466,
17476, 17476 };

int anim_side[] = { 6287, 909,
6287, 909,
6287, 909,
0, 0,
49984, 30834,
49984, 30834,
49984, 30834 };

int anim_wave[] = { 257, 257,
33667, 33667,
51143, 51143,
61423, 61423,
51143, 51143,
33667, 33667,
257, 257 };

int anim_bigchaser[] = {254, 254,
463, 463,
33667, 33667,
52993, 52993,
65024, 65024,
31744, 31744,
12288, 12288 };

int anim_slowcol[] = { 23558, 33120,
368, 11271,
23558, 33120,
368, 11271,
23558, 33120,
368, 11271,
23558, 33120 };

IPAddress SERVER (192, 168, 1, 130);
#define SERVERPORT 1883
#define USERNAME "user"
#define KEY "mypass"

const char CMD_OUT[] = "m9cmdout"; //MQTT topic commande vers le module
const char STA_OUT[] = "m9staout"; //MQTT topic statut du module
const char CMD_PWM[] = "m9pwmmode"; //MQTT topic programme LEDs vers le module for pwm led mode
const char STA_PWM[] = "m9stapwm"; //MQTT topic statut du module PRG
const char VAL_PWM[] = "m9valpwm"; //MQTT topic commande de valeur intensité pwm pour LED
const char BRI_PWM[] = "m9bripwm"; //MQTT topic statut de valeur brightness pwm vers Node-Red
const char VAL_PER[] = "m9valper"; //MQTT topic commande de valeur de periode du mode chaser de Node-Red
const char STA_PER[] = "m9staper"; //MQTT topic statut de valeur de periode du mode chaser vers Node-Red

const char CMD_PRG[] = "m9prgmode"; //MQTT topic programme LEDs vers le module
const char STA_PRG[] = "m9staprg"; //MQTT topic statut du module PRG
const char CMD_OTA[] = "m9otamode"; //MQTT topic commande OTA programming vers le module
const char STA_OTA[] = "m9staota"; //MQTT topic statut du module OTA
const char RING[] = "m9ring"; //MQTT topic commande vers le module pour faire sonner la sonnerie
const char CMD_DIS[] = "m9dismode"; //MQTT topic flasher disable mode all LEDs and events OFF
const char STA_DIS[] = "m9stadis"; //MQTT topic statut du falsher disable

const char PAYLOAD_ON[] = "on";
const char PAYLOAD_OFF[] = "of";

const int periodRingLED = 45; //Délai en ms du doorbell ring LED 45 est optimum
const int period_PWMLED = 5000; //Délai en ms du timer LED pwm, 60000 pour chaque minute

// Create an ESP8266 client class to connect to the MQTT server
WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
Serial.begin(115200);
pinMode(ledPin, OUTPUT); //Built-in LED output
pinMode(LED_Apin, OUTPUT);
pinMode(LED_Bpin, OUTPUT);
pinMode(LED_Cpin, OUTPUT);
pinMode(LED_Dpin, OUTPUT);
pinMode(LED_Epin, OUTPUT);
pinMode(LED_Fpin, OUTPUT);
pinMode(LED_Gpin, OUTPUT);
digitalWrite(ledPin, HIGH); //LED set off
digitalWrite(LED_Apin, LOW);
digitalWrite(LED_Bpin, LOW);
digitalWrite(LED_Cpin, LOW);
digitalWrite(LED_Dpin, LOW);
digitalWrite(LED_Epin, LOW);
digitalWrite(LED_Fpin, LOW);
digitalWrite(LED_Gpin, LOW);

WiFiManager wifiManager;
//reset saved settings
//wifiManager.resetSettings();
//If no Wifi connection, sets timeout until configuration portal gets turned off.
wifiManager.setConfigPortalTimeout(180);

if (!wifiManager.autoConnect("flashM9", "password")) {
  Serial.println("failed to connect and hit timeout");
  delay(5000);                                         //To avoid too many tries
  //reset and try again
  ESP.reset();
  delay(5000);
}

Serial.println("connected...");   //if you get here you have connected to the WiFi
Serial.println("local ip");
Serial.println(WiFi.localIP());
client.setServer(SERVER, SERVERPORT);
client.setCallback(callback);
reconnectMQTT();  

otaMode = false;
drbellActive = true;                    //Doorbell active on power-up

// OTA programming setup.  No authentication by default
ArduinoOTA.setPassword((const char *)"12345");

ArduinoOTA.onStart([]() {
  Serial.println("Start");
});
ArduinoOTA.onEnd([]() {
  Serial.println("\nEnd");
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
  Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
  Serial.printf("Error[%u]: ", error);
  if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
  else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
  else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
  else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
  else if (error == OTA_END_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
Serial.println("OTA Ready");
Serial.println("PWM starting");
ledEvent = t_LED.every(period_PWMLED, pwmLED); 
ringLedEvent = t_Ring.every(periodRingLED, ringLED);
chaserLedEvent = t_Chaser.every(periodLED, flashLED); 
pwmStart();

}

//Fonction appelée par le broker MQTT chaque fois qu'un message est publie sur un topic auquel le module est abonné
void callback(char* topic, byte* payload, unsigned int length) {
String topicString = topic;
String payloadString = (char*)payload;
String fullPayloadString;
char buffer[4];

//Serial.print("length = ");
//Serial.println(length, DEC);
fullPayloadString = payloadString.substring(0,length);
payloadString = payloadString.substring(0,2);

if(topicString == CMD_OUT && payloadString == PAYLOAD_ON) { //Commande pour activer chaser LEDs
if (flasherDisable == false) {
chaserMode = true; //we are in chaser mode
stopSequence();
t_Chaser.stop(chaserLedEvent);
chaserLedEvent = t_Chaser.every(periodLED, flashLED);
chaserStart();
}
}

if(topicString == CMD_OTA && payloadString == PAYLOAD_ON) { //Commande pour activer OTA
otaMode = true;
Serial.println("OTA mode on");
client.publish(STA_OTA, "on"); //Publish status OTA is ON
}

if(topicString == CMD_OTA && payloadString == PAYLOAD_OFF) { //Commande pour désactiver OTA
otaMode = false;
Serial.println("OTA mode off");
client.publish(STA_OTA, "off"); //Publish status OTA is OFF
}

if(topicString == CMD_PRG && payloadString == PAYLOAD_ON) { //Commande pour activer PRG des leds
pgmMode = true;
client.publish(STA_PRG, "on"); //Publish status PRG is ON
Serial.println("PGM mode, enter max sequences: ");
}

if(topicString == CMD_PRG && payloadString == PAYLOAD_OFF) { //Commande pour désactiver program des leds
pgmMode = false;
Serial.println("LED programming mode off");
client.publish(STA_PRG, "off"); //Publish status PRG is OFF
}

if(topicString == CMD_DIS && payloadString == PAYLOAD_ON) { //Commande pour flasher disable mode on
flasherDisable = true;
digitalWrite(LED_Apin, LOW);
digitalWrite(LED_Bpin, LOW);
digitalWrite(LED_Cpin, LOW);
digitalWrite(LED_Dpin, LOW);
digitalWrite(LED_Epin, LOW);
digitalWrite(LED_Fpin, LOW);
digitalWrite(LED_Gpin, LOW);
analogWrite(LED_Apin, 0);
analogWrite(LED_Bpin, 0);
analogWrite(LED_Cpin, 0);
analogWrite(LED_Dpin, 0);
analogWrite(LED_Epin, 0);
analogWrite(LED_Fpin, 0);
analogWrite(LED_Gpin, 0);
client.publish(STA_DIS, "on"); //Publish status DIS is ON
Serial.println("Flasher disabled ");
}

if(topicString == CMD_DIS && payloadString == PAYLOAD_OFF) { //Commande pour désactiver flasher disable
flasherDisable = false;
Serial.println("Flasher enabled ");
client.publish(STA_DIS, "off"); //Publish status DIS is OFF
}

if(topicString == CMD_PWM && payloadString == PAYLOAD_ON) { //Commande pour activer PWM des leds
if (flasherDisable == false) {
chaserMode = false; //we are not in chaser mode
stopSequence();
pwmStart();
}
}

if(topicString == VAL_PWM) { //Commande pour l'intensité pwm des leds
pwmVal = fullPayloadString.toInt();
dtostrf(pwmVal, 4, 0, buffer);
client.publish(BRI_PWM, buffer);
Serial.print("Received pwm = ");
Serial.println(pwmVal, DEC);
}

if(topicString == VAL_PER) { //Commande pour la période du mode chaser
periodLED = fullPayloadString.toInt();
dtostrf(periodLED, 4, 0, buffer);
client.publish(STA_PER, buffer);
Serial.print("Received period = ");
Serial.println(periodLED, DEC);
client.publish(CMD_OUT, PAYLOAD_ON); //Message to restart chaser mode automatically with new period value
}

if (topicString == RING && payloadString == PAYLOAD_ON) { //Commande pour faire un ring
if (flasherDisable == false) {
bit = 0;
stopSequence();
ringMode = true;
sequenceDone = false; //Init a flash sequence
sequenceNum = 1; //set first animation sequence
anim = anim_power;
loadSequence();
LED_PatCounter = 1; //Init LED pattern counter
Serial.println("Doorbell ring***");
}
}

}

//MQTT connection
void reconnectMQTT() {
yield();
while (!client.connected()) {
Serial.print("Attempting MQTT connection...");

if (client.connect("FLASHM9", USERNAME, KEY)) {
  Serial.println(" connected");                                    
  Serial.print("Client state connected, rc=");                                                     
  Serial.println(client.state());                             
  client.subscribe(CMD_OUT, 1);   //Topic de commande chaser LEDs
  client.subscribe(CMD_OTA, 1);   //Topic de commande OTA programming
  client.subscribe(CMD_PRG, 1);   //Topic de commande PRG programming for LEDs
  client.subscribe(CMD_PWM, 1);   //Topic de commande pwm mode for LEDs  
  client.subscribe(VAL_PWM, 1);   //Topic de commande de valeur pwm   
  client.subscribe(VAL_PER, 1);   //Topic de commande de valeur de periode mode chaser      
  client.subscribe(RING, 1);      //Topic de commande for a bell ring
  client.subscribe(CMD_DIS, 1);   //Topic de commande flasher disable mode for LEDs
} else {
  Serial.print("failed, rc=");
  Serial.print(client.state());
  Serial.println(" try again in 5 seconds");
  // Wait 5 seconds before retrying
  delay(5000);
}  

}
}

//Stop animation sequence
void stopSequence() {

sequenceDone = true; //sequence is done
digitalWrite(LED_Apin, LOW);
digitalWrite(LED_Bpin, LOW);
digitalWrite(LED_Cpin, LOW);
digitalWrite(LED_Dpin, LOW);
digitalWrite(LED_Epin, LOW);
digitalWrite(LED_Fpin, LOW);
digitalWrite(LED_Gpin, LOW);
analogWrite(LED_Apin, 0);
analogWrite(LED_Bpin, 0);
analogWrite(LED_Cpin, 0);
analogWrite(LED_Dpin, 0);
analogWrite(LED_Epin, 0);
analogWrite(LED_Fpin, 0);
analogWrite(LED_Gpin, 0);
}

//Load animation sequence patterns
void loadSequence() {

//Serial.println("Loading animation ");
LED_A_Pattern = anim[1]; //Load pattern 1
LED_A_Pattern2 = anim[0]; //Load pattern 2

//Serial.print("LED A Pattern 2 & 1 = ");
//Serial.print(LED_A_Pattern2, DEC);
//Serial.print(" ");
//Serial.println(LED_A_Pattern, DEC);
LED_B_Pattern = anim[3]; //Load pattern 1
LED_B_Pattern2 = anim[2]; //Load pattern 2
LED_C_Pattern = anim[5]; //Load pattern 1
LED_C_Pattern2 = anim[4]; //Load pattern 2
LED_D_Pattern = anim[7]; //Load pattern 1
LED_D_Pattern2 = anim[6]; //Load pattern 2
LED_E_Pattern = anim[9]; //Load pattern 1
LED_E_Pattern2 = anim[8]; //Load pattern 2
LED_F_Pattern = anim[11]; //Load pattern 1
LED_F_Pattern2 = anim[10]; //Load pattern 2
LED_G_Pattern = anim[13]; //Load pattern 1
LED_G_Pattern2 = anim[12]; //Load pattern 2
}

//Flash LED A according to active pattern
void displayLED_A() {
int value;

value = bitRead(LED_A_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Apin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Apin, LOW); //LED off for a 0
}
}

//Flash LED B according to active pattern
void displayLED_B() {
int value;

value = bitRead(LED_B_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Bpin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Bpin, LOW); //LED off for a 0
}
}

//Flash LED C according to active pattern
void displayLED_C() {
int value;

value = bitRead(LED_C_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Cpin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Cpin, LOW); //LED off for a 0
}
}

//Flash LED D according to active pattern
void displayLED_D() {
int value;

value = bitRead(LED_D_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Dpin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Dpin, LOW); //LED off for a 0
}
}

//Flash LED E according to active pattern
void displayLED_E() {
int value;

value = bitRead(LED_E_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Epin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Epin, LOW); //LED off for a 0
}
}

//Flash LED F according to active pattern
void displayLED_F() {
int value;

value = bitRead(LED_F_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Fpin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Fpin, LOW); //LED off for a 0
}
}

//Flash LED G according to active pattern
void displayLED_G() {
int value;

value = bitRead(LED_G_Pattern, bit);
if (value == 1 && flasherDisable == false) {
digitalWrite(LED_Gpin, HIGH); //LED on for a 1
} else {
digitalWrite(LED_Gpin, LOW); //LED off for a 0
}
}

//Flash LED sequence. Each bit changes as t_LED.every(periodLED, flashLED).
//When flashing sequence is complete set sequenceDone to true to end it.
//Also set bit to 0 to be ready for new sequence.
void flashLED() {

if (sequenceDone == false) { //if LED sequence is not done flashing
if (bit < 16) {
displayLED_A();
displayLED_B();
displayLED_C();
displayLED_D();
displayLED_E();
displayLED_F();
displayLED_G();
bit ++;
} else {
bit = 0;
LED_PatCounter++;

  if (LED_PatCounter == 2) {
    LED_A_Pattern = LED_A_Pattern2;     //load pattern 2 for LED A
    LED_B_Pattern = LED_B_Pattern2;     //load pattern 2 for LED B
    LED_C_Pattern = LED_C_Pattern2;     //load pattern 2 for LED C
    LED_D_Pattern = LED_D_Pattern2;          //Init LED pattern LED D
    LED_E_Pattern = LED_E_Pattern2;          //Init LED pattern LED E
    LED_F_Pattern = LED_F_Pattern2;          //Init LED pattern LED F
    LED_G_Pattern = LED_G_Pattern2;          //Init LED pattern LED G        
    displayLED_A();
    displayLED_B();
    displayLED_C();
    displayLED_D();
    displayLED_E();
    displayLED_F(); 
    displayLED_G();          
    bit ++; 
  }
       
  if (LED_PatCounter == 3) {                //animation is complete pattern 2 was done
    LED_PatCounter = 1;                     //reset pattern to 1
    sequenceNum ++;

    if (sequenceNum == maxSequence + 1) {   //if max number of animation is reached start over
      anim = anim_first;
      loadSequence();
      Serial.println("first");
      sequenceNum = 1;                      //last animation loop back to first animation
    } 

    if (sequenceNum == 2) {                 //more thant 1 animation to display in global sequence
      anim = anim_crossing;        
      loadSequence();
      Serial.println("crossing ");
    }

    if (sequenceNum == 3) {                 
      anim = anim_chaserClr;        
      loadSequence();
      Serial.println("chaser colors ");
    }

    if (sequenceNum == 4) {                 
      anim = anim_alternate;        
      loadSequence();
      Serial.println("alternate ");
    }      

    if (sequenceNum == 5) {                 
      anim = anim_centerin;        
      loadSequence();
      Serial.println("center in ");
    }              

    if (sequenceNum == 6) {                 
      anim = anim_chaser;        
      loadSequence();
      Serial.println("chaser");
    }  

    if (sequenceNum == 7) {                 
      anim = anim_colors;        
      loadSequence();
      Serial.println("colors");
    }  

    if (sequenceNum == 8) {                 
      anim = anim_bigchaser;        
      loadSequence();
      Serial.println("big chaser");
    }         

    if (sequenceNum == 9) {                 
      anim = anim_blast;        
      loadSequence();
      Serial.println("blast ");
    }

    if (sequenceNum == 10) {                 
      anim = anim_side;        
      loadSequence();
      Serial.println("side");
    } 

    if (sequenceNum == 11) {                 
      anim = anim_wave;        
      loadSequence();
      Serial.println("wave");
    } 

    if (sequenceNum == 12) {                 
      anim = anim_slowcol;        
      loadSequence();
      Serial.println("slow color");
    } 

    if (sequenceNum == 13) {                 
      anim = anim_power;        
      loadSequence();
      Serial.println("power");
    } 
    
    if (sequenceNum == 14) {                //all animations done for global sequence
      anim = anim_first;
      loadSequence();
      Serial.println("first");
      sequenceNum = 1;                      //last animation loop back to first animation
    }   
    
    displayLED_A();
    displayLED_B();
    displayLED_C();
    displayLED_D();
    displayLED_E();
    displayLED_F(); 
    displayLED_G();         
    bit ++; 

  } 

}

}
}

//Ring LED sequence. Each bit changes as t_LED.every(periodLED, ringLED).
//When flashing sequence is complete return to pwm random doorbell mode.
void ringLED() {

if (sequenceDone == false) { //if LED sequence is not done flashing
if (bit < 16) {
displayLED_A();
displayLED_B();
displayLED_C();
displayLED_D();
displayLED_E();
displayLED_F();
displayLED_G();
bit ++;
} else {
bit = 0;
LED_PatCounter++;

  if (LED_PatCounter == 2) {
    LED_A_Pattern = LED_A_Pattern2;     //load pattern 2 for LED A
    LED_B_Pattern = LED_B_Pattern2;     //load pattern 2 for LED B
    LED_C_Pattern = LED_C_Pattern2;     //load pattern 2 for LED C
    LED_D_Pattern = LED_D_Pattern2;          //Init LED pattern LED D
    LED_E_Pattern = LED_E_Pattern2;          //Init LED pattern LED E
    LED_F_Pattern = LED_F_Pattern2;          //Init LED pattern LED F
    LED_G_Pattern = LED_G_Pattern2;          //Init LED pattern LED G        
    displayLED_A();
    displayLED_B();
    displayLED_C();
    displayLED_D();
    displayLED_E();
    displayLED_F(); 
    displayLED_G();          
    bit ++; 
  }
       
  if (LED_PatCounter == 3) {                //animation is complete pattern 2 was done
    LED_PatCounter = 1;                     //reset pattern to 1
    sequenceNum ++;

    if (sequenceNum == 2) {                 
      anim = anim_chaserClr;        
      loadSequence();
      Serial.println("chaser colors ");
    }

    if (sequenceNum == 3) {                 
      anim = anim_alternate;        
      loadSequence();
      Serial.println("alternate ");
    }      

    if (sequenceNum == 4) {                 
      anim = anim_centerin;        
      loadSequence();
      Serial.println("center in ");
    }              

    if (sequenceNum == 5) {                 
      anim = anim_blast;        
      loadSequence();
      Serial.println("blast");
    }  

    if (sequenceNum == 5) {                 
      anim = anim_colors;        
      loadSequence();
      Serial.println("colors");
    }  

    if (sequenceNum == 6) {                 
      anim = anim_wave;        
      loadSequence();
      Serial.println("wave");
    } 

    if (sequenceNum == 7) {                 
      anim = anim_power;        
      loadSequence();
      Serial.println("power");
    } 
    
    if (sequenceNum == 8) {                //all animations done for ring sequence
      stopSequence();
      ringMode = false;
      sequenceNum = 1;                      //last animation loop back to first animation
      if (chaserMode == false) {           //not in chaser mode go back to pwm mode
        pwmStart();
      } else {                             //in chaser mode go back to that mode
        chaserStart();
      }
      
    } else {
      displayLED_A();
      displayLED_B();
      displayLED_C();
      displayLED_D();
      displayLED_E();
      displayLED_F(); 
      displayLED_G();               
    }

    bit ++; 
  } 

}

}
}

//Start chaser mode
void chaserStart() {
char buffer[4];

sequenceDone = false; //Init a flash sequence
sequenceNum = 1; //set first animation sequence
anim = anim_first;
loadSequence();
LED_PatCounter = 1; //Init LED pattern counter
bit = 0;
client.publish(STA_OUT, "on"); //Publish status ouput is ON
client.publish(STA_PWM, "off"); //Publish status PWM is OFF
Serial.println("Chaser mode activated");
Serial.println("first");
dtostrf(periodLED, 4, 0, buffer);
client.publish(STA_PER, buffer);
}

//Random pwm start sequence
void pwmStart() {
char buffer[4];

randomPWM = random(1,8);
pwmRandomDisplay(); //display 1st random LED
randomPWM = random(1,8);
pwmRandomDisplay(); //display 2nd random LED
client.publish(STA_PWM, "on"); //Publish status PWM is ON
client.publish(STA_OUT, "off"); //Publish status chaser is OFF
dtostrf(pwmVal, 4, 0, buffer);
client.publish(BRI_PWM, buffer);
Serial.println("PWM mode activated. Change brigthness 0-1023: ");
}

//Random pwm display
void pwmRandomDisplay() {
if (randomPWM == 1 && flasherDisable == false) {
analogWrite(LED_Apin, pwmVal);
}

if (randomPWM == 2 && flasherDisable == false) {
analogWrite(LED_Bpin, pwmVal);
}

if (randomPWM == 3 && flasherDisable == false) {
analogWrite(LED_Cpin, pwmVal);
}

if (randomPWM == 4 && flasherDisable == false) {
analogWrite(LED_Dpin, pwmVal);
}

if (randomPWM == 5 && flasherDisable == false) {
analogWrite(LED_Epin, pwmVal);
}

if (randomPWM == 6 && flasherDisable == false) {
analogWrite(LED_Fpin, pwmVal);
}

if (randomPWM == 7 && flasherDisable == false) {
analogWrite(LED_Gpin, pwmVal);
}

}

//PWM LED. Each bit changes as t_LED.every(period_PWMLED, pwmLED).
void pwmLED() {

analogWrite(LED_Apin, 0);
analogWrite(LED_Bpin, 0);
analogWrite(LED_Cpin, 0);
analogWrite(LED_Dpin, 0);
analogWrite(LED_Epin, 0);
analogWrite(LED_Fpin, 0);
analogWrite(LED_Gpin, 0);

randomPWM = random(1,8);
Serial.print("random = ");
Serial.print(randomPWM, DEC);
pwmRandomDisplay(); //display 1st random LED
randomPWM = random(1,8);
Serial.print(" random = ");
Serial.println(randomPWM, DEC);
pwmRandomDisplay(); //display 2nd random LED

}

void loop() {

if (ringMode == true) {
t_Ring.update();
} else {
if (chaserMode == false) {
t_LED.update();
} else {
t_Chaser.update();
}
}

//If MQTT client is not connected and wifi is connected
if (!client.connected() && WiFi.status() == WL_CONNECTED) {
reconnectMQTT();
}

//Programming mode section
if(pgmMode == true) {
// check if data has been sent from the computer:
if (Serial.available()) {
char received = Serial.read();
pgm_Str += received;

 // Process message when new line character is recieved
  if (received == '\n') {
    pgmResponse = pgm_Str.toInt();
    if (pgmResponse != 0) {
      maxSequence = pgmResponse;
    }
    Serial.print("Maximum sequences: ");
    Serial.println(maxSequence, DEC);
    pgm_Str = "";
    stopSequence();
  }
}

}

//PWM mode section
if(pgmMode == false) {
// check if data has been sent from the computer:
if (Serial.available()) {
char received = Serial.read();
pgm_Str += received;

 // Process message when new line character is recieved
  if (received == '\n') {
    pwmVal = pgm_Str.toInt();

// analogWrite(LED_Apin, pwmVal);
// analogWrite(LED_Bpin, pwmVal);
// analogWrite(LED_Cpin, pwmVal);
// analogWrite(LED_Dpin, pwmVal);
// analogWrite(LED_Epin, pwmVal);
// analogWrite(LED_Fpin, pwmVal);
// analogWrite(LED_Gpin, pwmVal);
Serial.print("pwm = ");
Serial.println(pwmVal, DEC);

    pgm_Str = "";
    Serial.println("Enter pwm 0-1023: ");
  }
}

}

if(otaMode==1) {
ArduinoOTA.handle();
}

client.loop();
}`

[earlephilhower]

Thanks, but that's pretty far from a minimum sketch. Before anyone can look at it, we'll need you to pull out the routines needed to reproduce your failure into a small sketch that can run anywhere. Think 10-100 lines of code. Here we've got a thousand lines and some specific hardware assumptions, which unfortunately isn't usable by the team.

Did you try the 5-line sample I posted, and was it working on your board?

[jplavoiemtl]

Sorry I don't have another development board and this one is in service in my home. I cannot switch code or play with it easily like you asked unfortunately. I reprogram the unit over the air for the tests I did to switch esp8266 core versions on my Arduino IDE.

The code I listed is too long I agree, but I didn't want to miss a part for you guys. I simply do an analogWrite to a value between extrems to change LED brigthness so it is very simple. No loop to vary the brightness or anything, just output a value. I don't vary pwm and any constant I put between 0 and 1023 do not give any output on the LED outputs with core 2.4.2. I reverted to core 2.4.1 for now so that I'm able to dim my LEDs (they were either off or full on). I thought this was easily to reproduce and hoped it could be resolved without too much difficulties. Here are the lines that really apply to the problem:

`//Random pwm display
void pwmRandomDisplay() {
if (randomPWM == 1 && flasherDisable == false) {
analogWrite(LED_Apin, pwmVal);
}

if (randomPWM == 2 && flasherDisable == false) {
analogWrite(LED_Bpin, pwmVal);
}

if (randomPWM == 3 && flasherDisable == false) {
analogWrite(LED_Cpin, pwmVal);
}

if (randomPWM == 4 && flasherDisable == false) {
analogWrite(LED_Dpin, pwmVal);
}

if (randomPWM == 5 && flasherDisable == false) {
analogWrite(LED_Epin, pwmVal);
}

if (randomPWM == 6 && flasherDisable == false) {
analogWrite(LED_Fpin, pwmVal);
}

if (randomPWM == 7 && flasherDisable == false) {
analogWrite(LED_Gpin, pwmVal);
}

}`

[earlephilhower]

The kind of code you've pasted is tested and verified working on its own, so there must be something else going on somewhere else in the code as a side effect. I thought it might have been Ticker, which uses timers, which would be the key but that also runs just fine for me:

#include <Ticker.h>

Ticker ticktock;

int cnt = 0;
void cb() {
  cnt++;
  ticktock.attach(1,  cb);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  ticktock.attach(.1,  cb);
}

void loop() {
  for (int i=0; i<=1023; i++) { analogWrite(LED_BUILTIN, i); delay(1); }
  for (int i=1023; i>=0; i--) { analogWrite(LED_BUILTIN, i); delay(1); }
  Serial.printf("cb: %d\n", cnt);
}

[earlephilhower]

Also I see you do an analogWrite(0) so I tried the following, and am also seeing it change intensity as expected:

#include <Ticker.h>

Ticker ticktock;

int cnt = 0;
void cb() {
  cnt++;
  ticktock.attach(1,  cb);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  ticktock.attach(.1,  cb);
}

void loop() {
//  for (int i=0; i<=1023; i++) { analogWrite(LED_BUILTIN, i); delay(1); }
//  for (int i=1023; i>=0; i--) { analogWrite(LED_BUILTIN, i); delay(1); }
  analogWrite(LED_BUILTIN, 0);
  analogWrite(LED_BUILTIN, 800);
  delay(2000);
  analogWrite(LED_BUILTIN, 0);
  analogWrite(LED_BUILTIN, 300);
  delay(2000);
  Serial.printf("cb: %d\n", cnt);
}

[jplavoiemtl]

These are good tests indeed. Like you say the problem must be a side effect from something else. I also do some digital writes on these outputs when I change mode.

On a side note my project is actually a LED chaser with 7 LEDs flashing some patterns with digital writes. When I put my module in "stealth" mode I use pwm to reduce the intensities of the LEDs and stop the LED chaser. This is where the problem occurs. Anyway I appreciate your efforts to reproduce the problem and I'm a bit sad because I don't have the proper hardware setup to make further tests like you asked. For this reason if you suggest to close the issue, it's ok with me since I have a workaround to go back to 2.4.1. Thanks.

[devyte]

@jplavoiemtl I suggest you work to reduce your code to something minimal that reproduces the issue, or add debug statements at key positions to give you hints for what's going on, or get another board for testing.
Closing this due to lack of info and can't reproduce.