Single button dimmer code like FC-106 module [Solve]

Projects Programming
1

Hi,
HW-206 and FC-106 are SGL8022W based Touch LED PWM Module to use as dimmer control module.
Module output as below:
Short touch / press = ON / OFF
Each Long press = Led fading increased / decreased vice versa

I am trying to achieve the same output through software side with simple dry contact button. I add code below with serial output.
I achieve toggle the state on short press. Also fading the led on long press.

Problem: When led is fading state long press didn't revert the brightness until short press and state change to work the logic.

Goal:

  1. During fading stage short press toggle the led state like ON / OFF
  2. During fading stage long press toggle fading state like fading ++ / fading--
#define PUSHED          LOW
#define NOTPUSHED       HIGH

#define LEDon           HIGH
#define LEDoff          LOW

boolean switchFlag      = false;  //true means we will allow switch hold timing checking
boolean fastFlag        = false;  //false means fast switch operation is enabled

byte ledState           = 0;
byte buttonOld          = 0;
byte buttonNew;
byte LEDstate           = 0;

const byte ledPin       = 3;
const byte buttonPin    = A0;
const byte heartBeatLED = 13;           //LED that flashes at 1Hz to show things are non blocking

int brightness;

//timing stuff
const unsigned long longPress = 750;  //time before level adjustment start being made
const unsigned long speed     = 50;   //time between each level change

unsigned long heartBeatMillis;
unsigned long switchMillis;
unsigned long longMillis;
unsigned long timePUSHED;

//****************************************************************************************
void setup()
{
  Serial.begin(9600);

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LEDstate);

  pinMode(heartBeatLED, OUTPUT);

  pinMode(buttonPin, INPUT_PULLUP);

} //END of setup()

//****************************************************************************************
void loop()
{
  //***************************
  //toggle Heartbeat LED every 500ms
  if (millis() - heartBeatMillis > 500)
  {
    //restart timer
    heartBeatMillis = millis();

    //toggle LED
    digitalWrite(heartBeatLED, !digitalRead(heartBeatLED));
  }

  //***************************
  //time to check the switches?
  if (millis() - switchMillis > 50)
  {
    //restart timer
    switchMillis = millis();

    checkSwitches();
  }

  //***************************
  //has the switch been held long enough?
  if (switchFlag == true && millis() - longMillis > longPress)
  {
    //is it time to go to the next level?
    if (digitalRead(buttonPin) == PUSHED && millis() - timePUSHED > speed)
    {
      //restart timing
      timePUSHED = millis();

      //disable fast switch operation
      fastFlag = true;

      //adjust level
      if (LEDstate == false)
      {
        analogWrite(ledPin, brightness);

        brightness = brightness - 10;
        Serial.print("brightness: "); Serial.println(brightness);

        if (brightness < 0)
        {
          brightness = 0;

          LEDstate = false;
          switchFlag = false;
        }
      }

      else
      {
        analogWrite(ledPin, brightness);

        brightness = brightness + 10;

        Serial.print("brightness: "); Serial.println(brightness);

        if (brightness > 255)
        {
          brightness = 255;

          LEDstate = true;
          switchFlag = false;
        }
      }
    }
  }

} //END of loop()

//****************************************************************************************
void checkSwitches()
{
  //***************************
  buttonNew = digitalRead(buttonPin);

  //has the switch changed state?
  if (buttonOld != buttonNew)
  {
    //update to the new state
    buttonOld = buttonNew;

    //***********************
    //was the switch pushed/closed?
    if (buttonNew == PUSHED)
    {
      //start timing
      timePUSHED = millis();
      longMillis = millis();

      switchFlag = true;
      Serial.println("S_Flag = true");
    }

    //***********************
    //was the switch released/open?
    else if (fastFlag == false && buttonNew == NOTPUSHED)
    {
      //disable switch 'hold' timing
      switchFlag = false;
      Serial.println("S_Flag = false");

      //toggle LED
      digitalWrite(ledPin, LEDstate);

      LEDstate = !LEDstate;

      if (LEDstate == LOW)
      {
        brightness = 255;
        Serial.println("Led ON");
      }

      else
      {
        brightness = 0;
        Serial.println("Led OFF");
      }

    }

    //allow fast switch operation
    fastFlag = false;


  }

} //END of checkSwitches()

//****************************************************************************************

Serial output with comment

S_Flag = true		// Short press
S_Flag = false
Led ON	
		
S_Flag = true		// Short press
S_Flag = false
Led OFF		
	
S_Flag = true		// Long press brightness ++
brightness: 10
brightness +++ up 
brightness: 260

S_Flag = true		// Long press
brightness: 265

S_Flag = true		// Long press
brightness: 265

S_Flag = true		// Short press
S_Flag = false
Led ON	
		
S_Flag = true		// Long press brightness --
brightness: 245
brightness --- up 
brightness: 5

Alternate approach or solution also welcome.

2

Can Anyone support for it.

3

not such trivial logic

consider

const byte PinBut = A1;
const byte PinLed = 10;

byte butLst;

const unsigned long MsecPeriod0 = 1000;
const unsigned long MsecPeriod1 =  100;
unsigned long msecPeriod;
unsigned long msecLst;

const int MaxLevel = 255;
int ledInc   = 16;
int ledLevel = 0;
int ledDir   = -1;

bool ledTimed;

// -----------------------------------------------------------------------------
void
loop (void)
{
    unsigned long msec = millis ();

    // check timer if active (msecPeriod set)
    if (msecPeriod && msec - msecLst >= msecPeriod)  {
        // reverse direction if initial timeout (MsecPeriod0)
        if (MsecPeriod0 == msecPeriod)
            ledDir   = -ledDir;

        // reset timer
        msecLst    = msec;
        msecPeriod = MsecPeriod1;

        // update level
        ledLevel += ledDir * ledInc;

        // check if endpoints reached
        if (0 > ledLevel)  {
            ledLevel   = 0;
            msecPeriod = 0;
        }
        else if (MaxLevel < ledLevel)  {
            ledLevel   = MaxLevel;
            msecPeriod = 0;
        }

        // update led
        analogWrite (PinLed, ledLevel);

        // set flag indicating timer active
        ledTimed = true;

        Serial.println (ledLevel);
    }

    // check for button press/release
    byte but = digitalRead (PinBut);
    if (butLst != but)  {
        butLst = but;
        delay (20);     // debounce

        if (LOW == but)  {              // pressed
            Serial.println ("pressed");
            msecPeriod = MsecPeriod0;
            msecLst    = msec;
        }
        else if (! ledTimed) {          // before timer expired
            msecPeriod = 0;             // disable timer
            if (0 < ledLevel)  {
                Serial.println ("released turn off");
                ledLevel = 0;
                ledDir   = -1;          // timer will reverse dir
            }
            else {
                Serial.println ("released turn on");
                ledLevel = MaxLevel;
                ledDir   =  1;
            }
            analogWrite (PinLed, ledLevel);
        }
        else  {                         // disable timer
            Serial.println ("released");
            msecPeriod = 0;
            ledTimed = false;
        }
    }
}

void
setup (void)
{
    Serial.begin (9600);

    pinMode (PinBut, INPUT_PULLUP);
    butLst = digitalRead (PinBut);

    pinMode (PinLed, OUTPUT);
    analogWrite (PinLed, ledLevel);
}
4

Thanks "gcjr" Its working as I want.
One last think need to add. Hold the status of dimmer value. Like if I OFF the dimmer at 50% when ON it should be at 50%.
Currently when ON by short click value will be 255 while at the time of OFF it was 150 for example.

5

why don't you make that change. capture the value when turned off, and initialize it when turned on