πŸ’¬ OH MySensors RGBW Controller





  • Is it possible to buy the corrected pcb anywhere?


  • Hardware Contributor

    Not yet. You could take the kicad files from my github and change that by yourself. I did start to update my design some weeks ago but as I still have enough of the old boards (and they work with that one tweak) I didn't finish that. Might do that soon so. Once I updated it I will add the new file to my github repo and the openhardware page.


  • Hardware Contributor

    @Cliff-Karlsson I did update my kicad and gerber files in the github repo (are these files automatically updated in the openhardware.io project too?). I haven't tested these yet but they should work without an error now. You could just take these gerber files and order them somewhere.


  • Admin

    Nope, you have to press the refresh button in the github-tab.



  • Great, just one stupid question. Do I just upload the gbl file to dirtypcbs/oshpark or how does it work?


  • Hardware Contributor

    @Cliff-Karlsson said:

    Great, just one stupid question. Do I just upload the gbl file to dirtypcbs/oshpark or how does it work?

    You take a zip file with all the gerber files inside (I think I already put one into the git), test it online (if you want to; sometimes it doesnt look perfect here) and then you upload it to dirtypcbs. I don't know how oshpark works, but I guess similar.

    Online gerber viewers I use are:
    http://circuitpeople.com/
    http://mayhewlabs.com/3dpcb

    Edit: I did just fix the files, you should be able to just use the RGBWController-Gerber.zip from the github (I will try to update the openhardware.io page now)



  • What is the correct pitch for the screw terminals? 2.54mm? 5mm ? or other?


  • Hardware Contributor

    @Cliff-Karlsson It should be 5 mm



  • dirtypcb says that the outline files are missing
    No board outline (.GML/.GKO/.GBR) file found.
    Can you please add this outline files to the GIT.



  • I had the same problem with dirtypcbs so I ordered from seedstudio instead. Almost the same price.


  • Hardware Contributor

    Oh thats just a naming issue. Rename the "RGBWController-Edge.cuts.gm1" to .gml in the zip file and it should work just fine.



  • Just got the v1.3 pcb's from OSH Park, just waiting for some components, and the we go. It will be an exciting christmas πŸ˜‰



  • I got my v1.3 pcbs from Smart Prototyping. Quality is good. The controller works fine BUT the sketch version in your github repo is broken. Seems like the non linear fading part never got finished. I am now using linear fading and the sketch is working. πŸ™‚



  • @Jan-Gatzke
    Hi can you please post your adjusted sketch for further reference?



  • @peerkersezuuker

    You have to fix the following part:

    for (int i = 0; i < NUM_CHANNELS; i++) {
        if (isOn) {
          // normal fading
          //analogWrite(channels[i], dimming / 100.0 * values[i]);
    
          // non linear fading, idea from https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
          analogWrite(channels[i], pow (2, (dimming / R)) - 1);
        } else {
          analogWrite(channels[i], 0);
        }
      }
    

    Corrected Version

    for (int i = 0; i < NUM_CHANNELS; i++) {
        if (isOn) {
          // normal fading
          analogWrite(channels[i], dimming / 100.0 * values[i]);
    
          // non linear fading, idea from https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
          //analogWrite(channels[i], pow (2, (dimming / R)) - 1);
        } else {
          analogWrite(channels[i], 0);
        }
      }
    

    Or else all channels are set to the Value of dimming. The sketch on openhardware.io is broken, too.



  • @Jan-Gatzke
    Thank you for your post.
    I hope the Mosfet's are comming in today, then i can build it up and play with it.


  • Hardware Contributor

    @Jan-Gatzke Thank you for correcting it πŸ˜‰ I never got around to making the fading part work a 100% so I reverted back to my normal linear fading for my controllers. Seems like I forgot to correct that in my git repo 😦 Sorry for that, I will fix it after christmas.
    Great to hear that others are using the controllers too! Have fun with them and update me if you change something or build some (other) cool thing with them!



  • A little question, the v1.3 is this the one with the corrected mosfet placement ?
    I build and programmed one now, but i only get a bright white light, and no response when i switch the node. So now i am in doubt...

    With regards
    Peer



  • @peerkersezuuker

    The node always starts with white on. This is normal behaviour.



  • @Jan-Gatzke
    Thank you, i see it in the code now ...
    I tested it with setting the RGB levels one by one to 255, and this works, so the channels are responding to the initialisation code.
    And because it is rebuild to version 2.0, i forgot one void to adjust...
    void incomingMessage(
    should be
    void receive(

    Problem solved, thank you very much.
    With regards
    Peer van Hoek



  • @peerkersezuuker

    Great.Can you post the complete 2.0 sketch, please? I am going to upgrade and this would be a good starting point.



  • @Jan-Gatzke
    Sure, no problem.
    But it is not 100% clean, i am just a coppier and paste'r....
    If you can clean it up that would be nice.

    /**
    Based on the MySensors Project: http://www.mysensors.org
    
    This sketch controls a (analog)RGBW strip by listening to new color values from a (domoticz) controller and then fading to the new color.
    
    Version 1.0 - Changed pins and gw definition
    Version 0.9 - Oliver Hilsky
    
    TODO
    safe/request values after restart/loss of connection
    */
    #define MY_DEBUG 
    
    #define SN   "RGBW 01"
    #define SV   "1.0"
    #define MY_RADIO_NRF24
    // change the pins to free up the pwm pin for led control
    #define MY_RF24_CE_PIN 4 //<-- NOTE!!! changed, the default is 9
    #define MY_RF24_CS_PIN 10 // default is 10
    #define MY_RF24_PA_LEVEL RF24_PA_MAX
    #define MY_REPEATER_FEATURE
    #define MY_NODE_ID 6
    
    
    // Load mysensors library	
    #include <MySensors.h>	
    // Load Serial Peripheral Interface library  
    #include <SPI.h>
    
    // Arduino pin attached to driver pins
    #define RED_PIN 3 
    #define WHITE_PIN 9
    #define GREEN_PIN 5
    #define BLUE_PIN 6
    #define NUM_CHANNELS 4 // how many channels, RGBW=4 RGB=3...
    #define CHILD_ID 1
    
    // Smooth stepping between the values
    #define STEP 1
    #define INTERVAL 10
    const int pwmIntervals = 255;
    float R; // equation for dimming curve
    
    // Stores the current color settings
    byte channels[4] = {RED_PIN, GREEN_PIN, BLUE_PIN, WHITE_PIN};
    byte values[4] = {0, 0, 0, 255};
    byte target_values[4] = {0, 0, 0, 255}; 
    
    
    // stores dimming level
    byte dimming = 100;
    byte target_dimming = 100;
    
    // tracks if the strip should be on of off
    boolean isOn = true;
    
    // time tracking for updates
    unsigned long lastupdate = millis();
         
    void setup() 
    {
      // Initializes the sensor node (with callback function for incoming messages)
      //begin(incomingMessage);	// 123 = node id for testing	
           
      // Set all channels to output (pin number, type)
      for (int i = 0; i < NUM_CHANNELS; i++) {
        pinMode(channels[i], OUTPUT);
      }
    
      // set up dimming
      R = (pwmIntervals * log10(2))/(log10(255));
    
      // get old values if this is just a restart
      request(CHILD_ID, V_RGBW);
    
      // init lights
      updateLights();
      
      // debug
      if (isOn) {
        Serial.println("RGBW is running...");
      }
     
      Serial.println("Waiting for messages...");  
    }
    
    void presentation()  {
      // Send the sketch version information to the gateway and Controller
      sendSketchInfo(SN, SV);
    
      // Register this device as Waterflow sensor
      present(CHILD_ID, S_RGBW_LIGHT, SN, true);
    }
    
    void loop()
    {
      // Process incoming messages (like config and light state from controller) - basically keep the mysensors protocol running
    //  process();		
    
      // and set the new light colors
      if (millis() > lastupdate + INTERVAL) {
        updateLights();
        lastupdate = millis();
      } 
    }
    
    // callback function for incoming messages
    void receive(const MyMessage &message) {
    
      Serial.print("Got a message - ");
      Serial.print("Messagetype is: ");
      Serial.println(message.type);
    
      // acknoledgment
      if (message.isAck())
      {
       	Serial.println("Got ack from gateway");
      }
      
      // new dim level
      else if (message.type == V_DIMMER) {
          Serial.println("Dimming to ");
          Serial.println(message.getString());
          target_dimming = message.getByte();
    
          // a new dimmer value also means on, no seperate signal gets send (by domoticz)
        isOn = true;
      }
    
      // on / off message
      else if (message.type == V_STATUS) {
        Serial.print("Turning light ");
    
        isOn = message.getInt();
    
        if (isOn) {
          Serial.println("on");
        } else {
          Serial.println("off");
        }
      }
    
      // new color value
      else if (message.type == V_RGBW) {    
        const char * rgbvalues = message.getString();
        inputToRGBW(rgbvalues);  
    
        // a new color also means on, no seperate signal gets send (by domoticz); needed e.g. for groups
        isOn = true;  
      }  
    }
    
    // this gets called every INTERVAL milliseconds and updates the current pwm levels for all colors
    void updateLights() {  
    
      // update pin values -debug
      //Serial.println(greenval);
      //Serial.println(redval);
      //Serial.println(blueval);
      //Serial.println(whiteval);
    
      //Serial.println(target_greenval);
      //Serial.println(target_redval);
      //Serial.println(target_blueval);
      //Serial.println(target_whiteval);
      //Serial.println("+++++++++++++++");
    
      // for each color
      for (int v = 0; v < NUM_CHANNELS; v++) {
    
        if (values[v] < target_values[v]) {
          values[v] += STEP;
          if (values[v] > target_values[v]) {
            values[v] = target_values[v];
          }
        }
    
        if (values[v] > target_values[v]) {
          values[v] -= STEP;
          if (values[v] < target_values[v]) {
            values[v] = target_values[v];
          }
        }
      }
    
      // dimming
      if (dimming < target_dimming) {
        dimming += STEP;
        if (dimming > target_dimming) {
          dimming = target_dimming;
        }
      }
      if (dimming > target_dimming) {
        dimming -= STEP;
        if (dimming < target_dimming) {
          dimming = target_dimming;
        }
      }
    
      /*
      // debug - new values
      Serial.println(greenval);
      Serial.println(redval);
      Serial.println(blueval);
      Serial.println(whiteval);
    
      Serial.println(target_greenval);
      Serial.println(target_redval);
      Serial.println(target_blueval);
      Serial.println(target_whiteval);
      Serial.println("+++++++++++++++");
      */
    
      // set actual pin values
      for (int i = 0; i < NUM_CHANNELS; i++) {
        if (isOn) {
          // normal fading
          analogWrite(channels[i], dimming / 100.0 * values[i]);
    
          // non linear fading, idea from https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
          //analogWrite(channels[i], pow (2, (dimming / R)) - 1);
        } else {
          analogWrite(channels[i], 0);
        }
      }
    }
    
    // converts incoming color string to actual (int) values
    // ATTENTION this currently does nearly no checks, so the format needs to be exactly like domoticz sends the strings
    void inputToRGBW(const char * input) {
      Serial.print("Got color value of length: "); 
      Serial.println(strlen(input));
      
      if (strlen(input) == 6) {
        Serial.println("new rgb value");
        target_values[0] = fromhex (& input [0]);
        target_values[1] = fromhex (& input [2]);
        target_values[2] = fromhex (& input [4]);
        target_values[3] = 0;
      } else if (strlen(input) == 9) {
        Serial.println("new rgbw value");
        target_values[0] = fromhex (& input [1]); // ignore # as first sign
        target_values[1] = fromhex (& input [3]);
        target_values[2] = fromhex (& input [5]);
        target_values[3] = fromhex (& input [7]);
      } else {
        Serial.println("Wrong length of input");
      }  
    
    
      Serial.print("New color values: ");
      Serial.println(input);
      
      for (int i = 0; i < NUM_CHANNELS; i++) {
        Serial.print(target_values[i]);
        Serial.print(", ");
      }
     
      Serial.println("");
      Serial.print("Dimming: ");
      Serial.println(dimming);
    }
    
    // converts hex char to byte
    byte fromhex (const char * str)
    {
      char c = str [0] - '0';
      if (c > 9)
        c -= 7;
      int result = c;
      c = str [1] - '0';
      if (c > 9)
        c -= 7;
      return (result << 4) | c;
    }```


  • @peerkersezuuker

    If I find the time, I will clean it up. I want to have a look at the non linear fading. IMHO the initial settings need to be customized, too. Instead of switching the white LEDs on the node could request the values from the controller (if possible) or from eeprom.



  • As promised I had a look at the sketch. The node can now save and restore values for rgbw, dimming and status to/from the controller. I had a look at the non linear fading, too. I got it partially working and refreshed my math knowledge a lot. πŸ™‚
    In the end I removed the code for it because it made the sketch much more complicated and I didn't like the results. The formula from the original sketch was ok for fading a single LED from 0% to 100%. It didn't cover other starting values and the combination of the colors. IMHO only the dimming can be done non linear without problems. For this I would use a static table of PWM values and percent values. Doing the log calculations on the pro mini seems to be too slow for a smooth fading. I saw massive flickering.

    Here is the sketch:

    /**
      Based on the MySensors Project: http://www.mysensors.org
    
      This sketch controls a (analog)RGBW strip by listening to new color values from a (domoticz) controller and then fading to the new color.
    
      Version 1.1 - Added save/restore of values to/from controller, removed non linear fading code
      Version 1.0 - Changed pins and gw definition
      Version 0.9 - Oliver Hilsky
    
    **/
    #define MY_DEBUG
    
    #define SN   "RGBW 01"
    #define SV   "1.1"
    #define MY_RADIO_NRF24
    // change the pins to free up the pwm pin for led control
    #define MY_RF24_CE_PIN 4 //<-- NOTE!!! changed, the default is 9
    #define MY_RF24_CS_PIN 10 // default is 10
    // Set LOW transmit power level as default, if you have an amplified NRF-module and
    // power your radio separately with a good regulator you can turn up PA level.
    #define MY_RF24_PA_LEVEL RF24_PA_LOW
    //Uncomment to enable repeater mode
    //#define MY_REPEATER_FEATURE
    //Uncomment to assign static node ID
    //#define MY_NODE_ID 9
    
    
    // Load mysensors library
    #include <MySensors.h>
    // Load Serial Peripheral Interface library
    #include <SPI.h>
    
    // Arduino pin attached to driver pins
    #define RED_PIN 3
    #define WHITE_PIN 9
    #define GREEN_PIN 5
    #define BLUE_PIN 6
    #define NUM_CHANNELS 4 // how many channels, RGBW=4 RGB=3...
    #define CHILD_ID 1
    
    // Smooth stepping between the values
    #define STEP 1
    #define INTERVAL 10
    
    MyMessage lastvalueMsg(CHILD_ID, V_VAR1);
    MyMessage lastisonMsg(CHILD_ID, V_VAR2);
    MyMessage lastdimmMsg(CHILD_ID, V_VAR3);
    
    // Stores the current color settings
    byte channels[4] = {RED_PIN, GREEN_PIN, BLUE_PIN, WHITE_PIN};
    byte values[4] = {0, 0, 0, 0};
    byte target_values[4] = {0, 0, 0, 0};
    
    
    // stores dimming level
    byte dimming = 100;
    byte target_dimming = 100;
    
    // tracks if the strip should be on of off
    boolean isOn = false;
    // tracks if the strip's last status was off. This overrides isOn at startup
    boolean wasOff = true;
    //tracks if the old values have bben requested from the controller. This prevents the request from being send multipßle times in the main loop.
    boolean valuesrequested = false;
    // time tracking for updates
    unsigned long lastupdate = millis();
    
    void setup()
    {
      // Set all channels to output (pin number, type)
      for (int i = 0; i < NUM_CHANNELS; i++) {
        pinMode(channels[i], OUTPUT);
      }
      // debug
      if (isOn) {
        Serial.println("RGBW is running...");
      }
    }
    
    void presentation()  {
      // Send the sketch version information to the gateway and Controller
      sendSketchInfo(SN, SV);
    
      // Register this device as Waterflow sensor
      present(CHILD_ID, S_RGBW_LIGHT, SN, true);
    }
    
    void loop()
    {
      if (!valuesrequested) {
        // get old values if this is just a restart
        Serial.println("Requesting old values...");
        //Request RGBW values
        request( CHILD_ID, V_VAR1 );
        wait(200);
        //Request Status
        request( CHILD_ID, V_VAR2 );
        wait(200);
        //Request dimm level
        request( CHILD_ID, V_VAR3 );
        valuesrequested = true;
      }
    
      // set the new light colors
      if (millis() > lastupdate + INTERVAL) {
        updateLights();
        lastupdate = millis();
      }
    }
    
    // callback function for incoming messages
    void receive(const MyMessage &message) {
    
      Serial.print("Got a message - ");
      Serial.print("Messagetype is: ");
      Serial.println(message.type);
    
      // acknoledgment
      if (message.isAck())
      {
        Serial.println("Got ack from gateway");
      }
    
      // new dim level
      else if (message.type == V_DIMMER or message.type == V_VAR3) {
        Serial.println("Dimming to ");
        Serial.println(message.getString());
        target_dimming = message.getByte();
        send(lastdimmMsg.set(target_dimming));
    
        if (!wasOff) {
          // a new dimmer value also means on, no seperate signal gets send (by domoticz)
          isOn = true;
          send(lastisonMsg.set(isOn));
        }
      }
    
      // on / off message
      else if (message.type == V_STATUS or message.type == V_VAR2) {
        Serial.print("Turning light ");
    
        isOn = message.getInt();
    
        if (isOn) {
          Serial.println("on");
          wasOff = false;
        } else {
          Serial.println("off");
        }
        send(lastisonMsg.set(isOn));
      }
    
      // new color value
      else if (message.type == V_RGBW or message.type == V_VAR1) {
        const char * rgbvalues = message.getString();
        send(lastvalueMsg.set(rgbvalues));
        inputToRGBW(rgbvalues);
        if (!wasOff) {
          // a new color also means on, no seperate signal gets send (by domoticz); needed e.g. for groups
          isOn = true;
          send(lastisonMsg.set(isOn));
        }
      }
    }
    
    // this gets called every INTERVAL milliseconds and updates the current pwm levels for all colors
    void updateLights() {
      // update pin values -debug
      //Serial.println(greenval);
      //Serial.println(redval);
      //Serial.println(blueval);
      //Serial.println(whiteval);
    
      //Serial.println(target_greenval);
      //Serial.println(target_redval);
      //Serial.println(target_blueval);
      //Serial.println(target_whiteval);
      //Serial.println("+++++++++++++++");
    
      // for each color
      for (int v = 0; v < NUM_CHANNELS; v++) {
        if (values[v] < target_values[v]) {
          values[v] += STEP;
          if (values[v] > target_values[v]) {
            values[v] = target_values[v];
          }
        }
    
        if (values[v] > target_values[v]) {
          values[v] -= STEP;
          if (values[v] < target_values[v]) {
            values[v] = target_values[v];
          }
        }
      }
    
    
      // dimming
      if (dimming < target_dimming) {
        dimming += STEP;
        if (dimming > target_dimming) {
          dimming = target_dimming;
        }
      }
      if (dimming > target_dimming) {
        dimming -= STEP;
        if (dimming < target_dimming) {
          dimming = target_dimming;
        }
      }
    
      /*
        // debug - new values
        Serial.println(greenval);
        Serial.println(redval);
        Serial.println(blueval);
        Serial.println(whiteval);
    
        Serial.println(target_greenval);
        Serial.println(target_redval);
        Serial.println(target_blueval);
        Serial.println(target_whiteval);
        Serial.println("+++++++++++++++");
      */
    
      // set actual pin values
      for (int i = 0; i < NUM_CHANNELS; i++) {
        if (isOn) {
          // normal fading
          analogWrite(channels[i], dimming / 100.0 * values[i]);
        } else {
          analogWrite(channels[i], 0);
        }
      }
    }
    
    // converts incoming color string to actual (int) values
    // ATTENTION this currently does nearly no checks, so the format needs to be exactly like domoticz sends the strings
    void inputToRGBW(const char * input) {
      Serial.print("Got color value of length: ");
      Serial.println(strlen(input));
    
      if (strlen(input) == 6) {
        Serial.println("new rgb value");
        target_values[0] = fromhex (& input [0]);
        target_values[1] = fromhex (& input [2]);
        target_values[2] = fromhex (& input [4]);
        target_values[3] = 0;
      } else if (strlen(input) == 9) {
        Serial.println("new rgbw value");
        target_values[0] = fromhex (& input [1]); // ignore # as first sign
        target_values[1] = fromhex (& input [3]);
        target_values[2] = fromhex (& input [5]);
        target_values[3] = fromhex (& input [7]);
      } else {
        Serial.println("Wrong length of input");
      }
    
    
      Serial.print("New color values: ");
      Serial.println(input);
    
      for (int i = 0; i < NUM_CHANNELS; i++) {
        Serial.print(target_values[i]);
        Serial.print(", ");
      }
    
      Serial.println("");
      Serial.print("Dimming: ");
      Serial.println(dimming);
    
    }
    
    // converts hex char to byte
    byte fromhex (const char * str)
    {
      char c = str [0] - '0';
      if (c > 9)
        c -= 7;
      int result = c;
      c = str [1] - '0';
      if (c > 9)
        c -= 7;
      return (result << 4) | c;
    }
    
    

  • Hardware Contributor

    @Jan-Gatzke Good job! I have a working 2.0 Version but it lacks your new features. I will take the time and add yours to the code in my git repo πŸ™‚



  • @LastSamurai

    Thx. Those new features, however, are kind of a workaround. It would have been better if the node could request the V_RGBW value directly. MySensors supports this, but domoticz doesn't seem to. I have testet this and domoticz always returned "0" as value. And because you and me are both using domoticz, I decided to implement this feature using V_VAR1-3.

    I am still thinking about the fading. I think we could get better colors if we could compensate the non linear dimming of the LEDs. With the actual sketch colors composed of mid range values could be wrong because every PWM value above 150 or so looks like almost full power. So 00AAFF almost looks like 00FFFF. AA has a value of 170 where FF is 255. This should make a big difference.



  • I have tried to get some kind of non linear fading by calculating the values for 256 steps using Excel and putting them in an array. The result is pretty good. Please test and share your opinion. πŸ˜‰

    /**
      Based on the MySensors Project: http://www.mysensors.org
    
      This sketch controls a (analog)RGBW strip by listening to new color values from a (domoticz) controller and then fading to the new color.
    
      Version 1.1 - Added save/restore of values to/from controller, removed non linear fading code
      Version 1.0 - Changed pins and gw definition
      Version 0.9 - Oliver Hilsky
    
    **/
    #define MY_DEBUG
    
    #define SN   "RGBW 01"
    #define SV   "1.1"
    #define MY_RADIO_NRF24
    // change the pins to free up the pwm pin for led control
    #define MY_RF24_CE_PIN 4 //<-- NOTE!!! changed, the default is 9
    #define MY_RF24_CS_PIN 10 // default is 10
    // Set LOW transmit power level as default, if you have an amplified NRF-module and
    // power your radio separately with a good regulator you can turn up PA level.
    #define MY_RF24_PA_LEVEL RF24_PA_LOW
    //Uncomment to enable repeater mode
    //#define MY_REPEATER_FEATURE
    //Uncomment to assign static node ID
    //#define MY_NODE_ID 9
    
    
    // Load mysensors library
    #include <MySensors.h>
    // Load Serial Peripheral Interface library
    #include <SPI.h>
    
    // Arduino pin attached to driver pins
    #define RED_PIN 3
    #define WHITE_PIN 9
    #define GREEN_PIN 5
    #define BLUE_PIN 6
    #define NUM_CHANNELS 4 // how many channels, RGBW=4 RGB=3...
    #define CHILD_ID 1
    
    // Smooth stepping between the values
    #define STEP 1
    #define INTERVAL 10
    
    MyMessage lastvalueMsg(CHILD_ID, V_VAR1);
    MyMessage lastisonMsg(CHILD_ID, V_VAR2);
    MyMessage lastdimmMsg(CHILD_ID, V_VAR3);
    
    // Stores the current color settings
    byte channels[4] = {RED_PIN, GREEN_PIN, BLUE_PIN, WHITE_PIN};
    byte values[4] = {0, 0, 0, 0};
    byte target_values[4] = {0, 0, 0, 0};
    //Stores corrected values for each step from 0 to 255. See https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
    byte converted_values[256] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8,8,8,8,8,9,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,13,13,13,13,14,14,14,15,15,15,16,16,17,17,17,18,18,19,19,20,20,20,21,21,22,22,23,23,24,24,25,26,26,27,27,28,29,29,30,31,31,32,33,34,34,35,36,37,38,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,54,55,56,57,58,60,61,62,64,65,67,68,70,71,73,75,76,78,80,81,83,85,87,89,91,93,95,97,99,101,104,106,108,111,113,116,118,121,123,126,129,132,135,138,141,144,147,150,154,157,161,164,168,171,175,179,183,187,191,195,200,204,209,213,218,223,228,233,238,243,249,255};
    
    
    // stores dimming level
    byte dimming = 100;
    byte target_dimming = 100;
    
    // tracks if the strip should be on of off
    boolean isOn = false;
    // tracks if the strip's last status was off. This overrides isOn at startup
    boolean wasOff = true;
    //tracks if the old values have bben requested from the controller. This prevents the request from being send multipßle times in the main loop.
    boolean valuesrequested = false;
    // time tracking for updates
    unsigned long lastupdate = millis();
    
    void setup()
    {
      // Set all channels to output (pin number, type)
      for (int i = 0; i < NUM_CHANNELS; i++) {
        pinMode(channels[i], OUTPUT);
      }
      // debug
      if (isOn) {
        Serial.println("RGBW is running...");
      }
    }
    
    void presentation()  {
      // Send the sketch version information to the gateway and Controller
      sendSketchInfo(SN, SV);
    
      // Register this device as Waterflow sensor
      present(CHILD_ID, S_RGBW_LIGHT, SN, true);
    }
    
    void loop()
    {
      if (!valuesrequested) {
        // get old values if this is just a restart
        Serial.println("Requesting old values...");
        //Request RGBW values
        request( CHILD_ID, V_VAR1 );
        wait(200);
        //Request Status
        request( CHILD_ID, V_VAR2 );
        wait(200);
        //Request dimm level
        request( CHILD_ID, V_VAR3 );
        valuesrequested = true;
      }
    
      // set the new light colors
      if (millis() > lastupdate + INTERVAL) {
        updateLights();
        lastupdate = millis();
      }
    }
    
    // callback function for incoming messages
    void receive(const MyMessage &message) {
    
      Serial.print("Got a message - ");
      Serial.print("Messagetype is: ");
      Serial.println(message.type);
    
      // acknoledgment
      if (message.isAck())
      {
        Serial.println("Got ack from gateway");
      }
    
      // new dim level
      else if (message.type == V_DIMMER or message.type == V_VAR3) {
        Serial.println("Dimming to ");
        Serial.println(message.getString());
        target_dimming = message.getByte();
        send(lastdimmMsg.set(target_dimming));
    
        if (!wasOff) {
          // a new dimmer value also means on, no seperate signal gets send (by domoticz)
          isOn = true;
          send(lastisonMsg.set(isOn));
        }
      }
    
      // on / off message
      else if (message.type == V_STATUS or message.type == V_VAR2) {
        Serial.print("Turning light ");
    
        isOn = message.getInt();
    
        if (isOn) {
          Serial.println("on");
          wasOff = false;
        } else {
          Serial.println("off");
        }
        send(lastisonMsg.set(isOn));
      }
    
      // new color value
      else if (message.type == V_RGBW or message.type == V_VAR1) {
        const char * rgbvalues = message.getString();
        send(lastvalueMsg.set(rgbvalues));
        inputToRGBW(rgbvalues);
        if (!wasOff) {
          // a new color also means on, no seperate signal gets send (by domoticz); needed e.g. for groups
          isOn = true;
          send(lastisonMsg.set(isOn));
        }
      }
    }
    
    // this gets called every INTERVAL milliseconds and updates the current pwm levels for all colors
    void updateLights() {
      int convertedvalue=0;
      // update pin values -debug
      //Serial.println(greenval);
      //Serial.println(redval);
      //Serial.println(blueval);
      //Serial.println(whiteval);
    
      //Serial.println(target_greenval);
      //Serial.println(target_redval);
      //Serial.println(target_blueval);
      //Serial.println(target_whiteval);
      //Serial.println("+++++++++++++++");
    
      // for each color
      for (int v = 0; v < NUM_CHANNELS; v++) {
        if (values[v] < target_values[v]) {
          values[v] += STEP;
          if (values[v] > target_values[v]) {
            values[v] = target_values[v];
          }
        }
    
        if (values[v] > target_values[v]) {
          values[v] -= STEP;
          if (values[v] < target_values[v]) {
            values[v] = target_values[v];
          }
        }
      }
    
    
      // dimming
      if (dimming < target_dimming) {
        dimming += STEP;
        if (dimming > target_dimming) {
          dimming = target_dimming;
        }
      }
      if (dimming > target_dimming) {
        dimming -= STEP;
        if (dimming < target_dimming) {
          dimming = target_dimming;
        }
      }
    
      /*
        // debug - new values
        Serial.println(greenval);
        Serial.println(redval);
        Serial.println(blueval);
        Serial.println(whiteval);
    
        Serial.println(target_greenval);
        Serial.println(target_redval);
        Serial.println(target_blueval);
        Serial.println(target_whiteval);
        Serial.println("+++++++++++++++");
      */
    
      // set actual pin values
      for (int i = 0; i < NUM_CHANNELS; i++) {
        if (isOn) {
          // normal fading
          //analogWrite(channels[i], dimming / 100.0 * values[i]);
          //Fading with corrected values see https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
          analogWrite(channels[i], dimming / 100.0 * converted_values[values[i]]);
          
        } else {
          analogWrite(channels[i], 0);
        }
      }
    }
    
    // converts incoming color string to actual (int) values
    // ATTENTION this currently does nearly no checks, so the format needs to be exactly like domoticz sends the strings
    void inputToRGBW(const char * input) {
      Serial.print("Got color value of length: ");
      Serial.println(strlen(input));
    
      if (strlen(input) == 6) {
        Serial.println("new rgb value");
        target_values[0] = fromhex (& input [0]);
        target_values[1] = fromhex (& input [2]);
        target_values[2] = fromhex (& input [4]);
        target_values[3] = 0;
      } else if (strlen(input) == 9) {
        Serial.println("new rgbw value");
        target_values[0] = fromhex (& input [1]); // ignore # as first sign
        target_values[1] = fromhex (& input [3]);
        target_values[2] = fromhex (& input [5]);
        target_values[3] = fromhex (& input [7]);
      } else {
        Serial.println("Wrong length of input");
      }
    
    
      Serial.print("New color values: ");
      Serial.println(input);
    
      for (int i = 0; i < NUM_CHANNELS; i++) {
        Serial.print(target_values[i]);
        Serial.print(", ");
      }
    
      Serial.println("");
      Serial.print("Dimming: ");
      Serial.println(dimming);
    
    }
    
    // converts hex char to byte
    byte fromhex (const char * str)
    {
      char c = str [0] - '0';
      if (c > 9)
        c -= 7;
      int result = c;
      c = str [1] - '0';
      if (c > 9)
        c -= 7;
      return (result << 4) | c;
    }
    
    

  • Hero Member

    @Jan-Gatzke for Domoticz you can use V_TEXT. You can request a value and manipulate it in Lua. Also Domoticz is terrible with rgb as it only allows saturated colors.


  • Hero Member

    @Jan-Gatzke the FastLED library allows for very fast math with color values. Also some very educational stuff for color manipulation in the code and documentation.



  • @AWI

    Thx for the info. This comes 24 hours to late. πŸ˜‚



  • Is any chance to also project PCB for radio RFM69HW ?


  • Hardware Contributor

    @pepson I wont do it because my networks is using NRFs but the kicad files are online, you could just get those and only change the radio part.



  • I dont know software kicad... and can i please you to help me for changing it to radio RFM69HW please ?


  • Admin

    @pepson, please respect @LastSamurai (who has gracefully shared his hardware design files) when he says he won't change it.

    There are resources online on how to learn Kicad,


  • Admin

    @pepson

    There are also converter boards available, that let you use rfm69hw in a nrf24 socket. That could be an option. Search openhardware.io for it..





  • What software is for file kicad_pcb ?
    I download this but i can not open this file by this soft...
    http://kicad-pcb.org/download/windows/

    Or in which file is write project PCB ?


  • Hardware Contributor

    @pepson The *.kicad_pcb file should be the pcb, the *.sch file the schematics.
    You could just use the schematics to remake my project by yourself though and learn kicad on the way. Otherwise the suggested adaptor seems to be the easiest solution.



  • @LastSamurai

    But in soft kicad i dont have option to open this file... kicad can only open *.pro



  • This PCB will also available to buy it as i can buy PCB to converter NRF to RFM69 ?


  • Hardware Contributor

    @pepson said:

    This PCB will also available to buy it as i can buy PCB to converter NRF to RFM69 ?

    I am not sure if I understand your question. I am not selling the pcbs but you can buy it from dirtypcbs and support me. I guess you should be able to use it with the converter though I never did. Be sure to check dimensions first!



  • But on dirtypcb what type file i must upload to give cost ?


  • Hardware Contributor

    A zip with the gerber files. The version 1.3 that I used is already in their store though: http://dirtypcbs.com/store/designer/details/7078/867/mysensors-rgbw-controller-v1-3



  • Hmm a littlebig cost same PCB. Can you show me it how it looks in Domoticz ?


  • Hardware Contributor

    @pepson What do you want to know about domoticz? It looks like every other RGB switch in domotizc depending on your used theme, just google it πŸ˜‰



  • But is any chance to implement also button as in fibaro rgbw ?


  • Hardware Contributor

    @pepson I don't understand?!



  • Buttons to controlling leds red gren blue and white.


  • Hardware Contributor

    @pepson Still not sure what you mean. If you want hardware buttons you can add those to the node (I did not). Everything else is part of the controller software which I don't control. You can always use something other than domoticz. But lets not spam this thread with that anymore please πŸ™‚



  • Will this board works with an APA102 ledstrip? And, I'm new to custom boards, how can I simply order a couple of this boards?
    EDIT: i'm too fast, found this link: http://dirtypcbs.com/store/designer/details/7078/867/mysensors-rgbw-controller-v1-3
    so my second question is already be answered!


  • Hardware Contributor

    @niek APA102 are adressable leds, right? My led controller only supports "analog" leds controlled by pwm. At least without some modding.


  • Hero Member

    @niek an apa102 strip contains internal logic/ driver circuitry so it can be controlled direct from arduino power pins. No mosfet needed. Take a look at the FastLED library to control these strips.



  • I am trying to compile this project with the 2.1.1 library, but I keep getting the errors: the 'MyTransportNRF24' does not name a type.
    As far as I can see, it seems that the type is nowhere defined in the libraries.


  • Hardware Contributor

    @CoolSaet Yes that is because the sketch you are using is still from MySensors 1.5. I already updated the sketch to Version 2 in November but forgot to push the changes to github.
    Here is a newer version that should work with mysensors 2. Only the (non)linear fading is still not working 100%.

    PS I also updated the text of the openhardware.io project



  • @LastSamurai Thank you very much for the update. That seems to have done the trick.



  • @LastSamurai The gerber files on Dirty PCBs are the mosfet corrected ones or the wrong? I just ordered some and now I've this doubt.



  • @Sergio-Rius
    I ordered the pcb a few months back on dirty pcbs. That one had the MOSFET pins connected wrong, but it wasn't that difficult to turn them an discribed in the post. I am not sure if a correct one is available.



  • @CoolSaet Thankiuu! I'll try not to mess anything.


  • Hardware Contributor

    @Sergio-Rius I am pretty sure the version 1.3 from the store still has the pins rotated (= wrong but you can fix it as described). There is a fixed version of the gerber files in my github repo that is linked to this project though. I just haven't ordered them from dirtyPCBs yet so they are not in the store (as I am still using the rest of the old ones).



  • Thanks, @LastSamurai, I went and compared the DIrty PCB files with the v1.3 ones on OpenHardware.IO and they are indeed different. It looks like the DIrtyPCB link is out of date and still has the error on them.
    @Sergio-Rius would be very grateful if you could update those files πŸ™‚



  • @Stuart-Middleton Unfortunately my boards are already made and shipped. They made them in just a day (Sunday) and didn't have me time to rectify my order.



  • @Sergio-Rius Oh well, it doesn't look too hard to adapt for the error.


  • Hardware Contributor

    @Stuart-Middleton It really shoudn't be. Just follow the pictures in the project. There are also updated project/gerber files in my github for anyone wanting to order new ones. Once I have used all of the Version 1.3 ones I will order new ones from dirtyPCBs and add the link here.


  • Hardware Contributor

    @Jan-Gatzke Did you ever manage to get your non-linear fading to work? I used the predefined values from your sketch and added them to my newer one but whenever I use that the sketch stops working and only rubbish is shown on the serial port.
    Here is my new version: github



  • @LastSamurai

    Yes, I did! This sketch is working for me:

    /**
      Based on the MySensors Project: http://www.mysensors.org
    
      This sketch controls a (analog)RGBW strip by listening to new color values from a (domoticz) controller and then fading to the new color.
    
      Version 1.1 - Added save/restore of values to/from controller, removed non linear fading code
      Version 1.0 - Changed pins and gw definition
      Version 0.9 - Oliver Hilsky
    
    **/
    #define MY_DEBUG
    
    #define SN   "RGBW 01"
    #define SV   "1.1"
    #define MY_RADIO_NRF24
    #define MY_PARENT_NODE_ID 10
    // change the pins to free up the pwm pin for led control
    #define MY_RF24_CE_PIN 4 //<-- NOTE!!! changed, the default is 9
    #define MY_RF24_CS_PIN 10 // default is 10
    // Set LOW transmit power level as default, if you have an amplified NRF-module and
    // power your radio separately with a good regulator you can turn up PA level.
    #define MY_RF24_PA_LEVEL RF24_PA_LOW
    //Uncomment to enable repeater mode
    //#define MY_REPEATER_FEATURE
    //Uncomment to assign static node ID
    //#define MY_NODE_ID 9
    
    
    // Load mysensors library
    #include <MySensors.h>
    // Load Serial Peripheral Interface library
    #include <SPI.h>
    
    // Arduino pin attached to driver pins
    #define RED_PIN 3
    #define WHITE_PIN 9
    #define GREEN_PIN 5
    #define BLUE_PIN 6
    #define NUM_CHANNELS 4 // how many channels, RGBW=4 RGB=3...
    #define CHILD_ID 1
    
    // Smooth stepping between the values
    #define STEP 1
    #define INTERVAL 10
    
    MyMessage lastvalueMsg(CHILD_ID, V_VAR1);
    MyMessage lastisonMsg(CHILD_ID, V_VAR2);
    MyMessage lastdimmMsg(CHILD_ID, V_VAR3);
    
    // Stores the current color settings
    byte channels[4] = {RED_PIN, GREEN_PIN, BLUE_PIN, WHITE_PIN};
    byte values[4] = {0, 0, 0, 0};
    byte target_values[4] = {0, 0, 0, 0};
    //Stores corrected values for each step from 0 to 255. See https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
    byte converted_values[256] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8,8,8,8,8,9,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,13,13,13,13,14,14,14,15,15,15,16,16,17,17,17,18,18,19,19,20,20,20,21,21,22,22,23,23,24,24,25,26,26,27,27,28,29,29,30,31,31,32,33,34,34,35,36,37,38,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,54,55,56,57,58,60,61,62,64,65,67,68,70,71,73,75,76,78,80,81,83,85,87,89,91,93,95,97,99,101,104,106,108,111,113,116,118,121,123,126,129,132,135,138,141,144,147,150,154,157,161,164,168,171,175,179,183,187,191,195,200,204,209,213,218,223,228,233,238,243,249,255};
    
    
    // stores dimming level
    byte dimming = 100;
    byte target_dimming = 100;
    
    // tracks if the strip should be on of off
    boolean isOn = false;
    // tracks if the strip's last status was off. This overrides isOn at startup
    boolean wasOff = true;
    //tracks if the old values have bben requested from the controller. This prevents the request from being send multipßle times in the main loop.
    boolean valuesrequested = false;
    // time tracking for updates
    unsigned long lastupdate = millis();
    
    void setup()
    {
      // Set all channels to output (pin number, type)
      for (int i = 0; i < NUM_CHANNELS; i++) {
        pinMode(channels[i], OUTPUT);
      }
      // debug
      if (isOn) {
        Serial.println("RGBW is running...");
      }
    }
    
    void presentation()  {
      // Send the sketch version information to the gateway and Controller
      sendSketchInfo(SN, SV);
    
      // Register this device as Waterflow sensor
      present(CHILD_ID, S_RGBW_LIGHT, SN, true);
    }
    
    void loop()
    {
      if (!valuesrequested) {
        // get old values if this is just a restart
        Serial.println("Requesting old values...");
        //Request RGBW values
        request( CHILD_ID, V_VAR1 );
        wait(200);
        //Request Status
        request( CHILD_ID, V_VAR2 );
        wait(200);
        //Request dimm level
        request( CHILD_ID, V_VAR3 );
        valuesrequested = true;
      }
    
      // set the new light colors
      if (millis() > lastupdate + INTERVAL) {
        updateLights();
        lastupdate = millis();
      }
    }
    
    // callback function for incoming messages
    void receive(const MyMessage &message) {
    
      Serial.print("Got a message - ");
      Serial.print("Messagetype is: ");
      Serial.println(message.type);
    
      // acknoledgment
      if (message.isAck())
      {
        Serial.println("Got ack from gateway");
      }
    
      // new dim level
      else if (message.type == V_DIMMER or message.type == V_VAR3) {
        Serial.println("Dimming to ");
        Serial.println(message.getString());
        target_dimming = message.getByte();
        send(lastdimmMsg.set(target_dimming));
    
        if (!wasOff) {
          // a new dimmer value also means on, no seperate signal gets send (by domoticz)
          isOn = true;
          send(lastisonMsg.set(isOn));
        }
      }
    
      // on / off message
      else if (message.type == V_STATUS or message.type == V_VAR2) {
        Serial.print("Turning light ");
    
        isOn = message.getInt();
    
        if (isOn) {
          Serial.println("on");
          wasOff = false;
        } else {
          Serial.println("off");
        }
        send(lastisonMsg.set(isOn));
      }
    
      // new color value
      else if (message.type == V_RGBW or message.type == V_VAR1) {
        const char * rgbvalues = message.getString();
        send(lastvalueMsg.set(rgbvalues));
        inputToRGBW(rgbvalues);
        if (!wasOff) {
          // a new color also means on, no seperate signal gets send (by domoticz); needed e.g. for groups
          isOn = true;
          send(lastisonMsg.set(isOn));
        }
      }
    }
    
    // this gets called every INTERVAL milliseconds and updates the current pwm levels for all colors
    void updateLights() {
      int convertedvalue=0;
      // update pin values -debug
      //Serial.println(greenval);
      //Serial.println(redval);
      //Serial.println(blueval);
      //Serial.println(whiteval);
    
      //Serial.println(target_greenval);
      //Serial.println(target_redval);
      //Serial.println(target_blueval);
      //Serial.println(target_whiteval);
      //Serial.println("+++++++++++++++");
    
      // for each color
      for (int v = 0; v < NUM_CHANNELS; v++) {
        if (values[v] < target_values[v]) {
          values[v] += STEP;
          if (values[v] > target_values[v]) {
            values[v] = target_values[v];
          }
        }
    
        if (values[v] > target_values[v]) {
          values[v] -= STEP;
          if (values[v] < target_values[v]) {
            values[v] = target_values[v];
          }
        }
      }
    
    
      // dimming
      if (dimming < target_dimming) {
        dimming += STEP;
        if (dimming > target_dimming) {
          dimming = target_dimming;
        }
      }
      if (dimming > target_dimming) {
        dimming -= STEP;
        if (dimming < target_dimming) {
          dimming = target_dimming;
        }
      }
    
      /*
        // debug - new values
        Serial.println(greenval);
        Serial.println(redval);
        Serial.println(blueval);
        Serial.println(whiteval);
    
        Serial.println(target_greenval);
        Serial.println(target_redval);
        Serial.println(target_blueval);
        Serial.println(target_whiteval);
        Serial.println("+++++++++++++++");
      */
    
      // set actual pin values
      for (int i = 0; i < NUM_CHANNELS; i++) {
        if (isOn) {
          // normal fading
          //analogWrite(channels[i], dimming / 100.0 * values[i]);
          //Fading with corrected values see https://diarmuid.ie/blog/pwm-exponential-led-fading-on-arduino-or-other-platforms/
          analogWrite(channels[i], dimming / 100.0 * converted_values[values[i]]);
          
        } else {
          analogWrite(channels[i], 0);
        }
      }
    }
    
    // converts incoming color string to actual (int) values
    // ATTENTION this currently does nearly no checks, so the format needs to be exactly like domoticz sends the strings
    void inputToRGBW(const char * input) {
      Serial.print("Got color value of length: ");
      Serial.println(strlen(input));
    
      if (strlen(input) == 6) {
        Serial.println("new rgb value");
        target_values[0] = fromhex (& input [0]);
        target_values[1] = fromhex (& input [2]);
        target_values[2] = fromhex (& input [4]);
        target_values[3] = 0;
      } else if (strlen(input) == 9) {
        Serial.println("new rgbw value");
        target_values[0] = fromhex (& input [1]); // ignore # as first sign
        target_values[1] = fromhex (& input [3]);
        target_values[2] = fromhex (& input [5]);
        target_values[3] = fromhex (& input [7]);
      } else {
        Serial.println("Wrong length of input");
      }
    
    
      Serial.print("New color values: ");
      Serial.println(input);
    
      for (int i = 0; i < NUM_CHANNELS; i++) {
        Serial.print(target_values[i]);
        Serial.print(", ");
      }
    
      Serial.println("");
      Serial.print("Dimming: ");
      Serial.println(dimming);
    
    }
    
    // converts hex char to byte
    byte fromhex (const char * str)
    {
      char c = str [0] - '0';
      if (c > 9)
        c -= 7;
      int result = c;
      c = str [1] - '0';
      if (c > 9)
        c -= 7;
      return (result << 4) | c;
    }
    
    

  • Hardware Contributor

    @Jan-Gatzke Thanks, I'll try that later although it doesn't look much different from mine. May I ask why you are using V_VAR1/2 types in your sketch? And why you send answer messages? Are you using home assistant (thats the only one where this is need imho)?



  • @LastSamurai

    I am using Domoticz. This was the only way reading initial values from the controller. Directly requesting the value of a child did not work for me. Meanwhile MySensors support in Domoticz seems extremly bugy and uncomplete to me. I am going to give OpenHAB2 a try.


  • Hardware Contributor

    @Jan-Gatzke Ah ok nice to know. I am facing the same problem. RGBW is not that well supported in domoticz. I am currently trying to switch to openhab2 but having some problems with my RGBW nodes there too. Development on the plugin seems to be very active though. If you want to follow the discussion have a look at the forum thread here or on github πŸ˜‰
    Once I got everything up and running in openhab I'll post an update here.

    Meanwhile the newest sketch from my github should work with Home assistant too.



  • I just assembled my first OH! My... πŸ˜€ board and realized that the V2 sketch doesn't work for me.
    Anyways I'm posting a sample sketch for testing the board:

    #define RED_PIN 3
    #define GREEN_PIN 5
    #define BLUE_PIN 6
    #define WHITE_PIN 9
    
    #define ON 100 // Please, don't burn my eyes
    #define OFF 0
    
    #define ON_INTERVAL (3*1000ul)
    
    void setup() {
      // Setting pins to output and low is not required for analogWrite.
        Serial.begin(115200);
    }
    
    void loop() {
        analogWrite(RED_PIN, ON);
        Serial.println(F("**RED**"));
        delay(ON_INTERVAL);
        analogWrite(RED_PIN, OFF);
        analogWrite(GREEN_PIN, ON);
        Serial.println(F("**GREEN**"));
        delay(ON_INTERVAL);
        analogWrite(GREEN_PIN, OFF);
        analogWrite(BLUE_PIN, ON);
        Serial.println(F("**BLUE**"));
        delay(ON_INTERVAL);
        analogWrite(BLUE_PIN, OFF);
        analogWrite(WHITE_PIN, ON);
        Serial.println(F("**WHITE**"));
        delay(ON_INTERVAL);
        analogWrite(WHITE_PIN, OFF);
    }
    

  • Hardware Contributor

    @Sergio-Rius Nice to hear! And good idea with the test sketch.

    What exactly did not work with my sketch? I would really like to fix it (for others too).



  • @LastSamurai I'm using Domoticz. With your sketch, turning on and off worked.
    But whenever it had any rgb value, the white light was always 100% on. The RGB leds where all three lit at a time and never more than 20% but slightly responded to dimming control.

    The above code from @Jan-Gatzke works flawlessy. Even turns the white leds on when reaching the white band on the gradient.
    Only I would like it to not turn off the color leds until the selected color is totally or almost white, so we could white-wash the selection.

    Oh, men... soldering those mosfets turned around was so difficult. πŸ™‚ I recommend the next who buys boards to use the new designs.

    Give me some time and I'll give a turn to the sketch. But I'm still working on the "water-heating-solar-controller", and still have to assemble the energy monitor board, and do something with the meteo board.



  • @LastSamurai I have some doubts on this code, can I ask you?
    The change between color values is done by a fade, and I understand that you don't want a linear change but an exponential one. Right?

    One doubt i have is that I'm seeing that the fade is accomplished using a conversion array. So you are doing variable steps depending on the difference of value for each channel. Wouldn't be preferable to always take the same amount of time/steps doing the change?

    Wouldn't be better to divide the difference for each value on the same steps and then doing the transformation. Then could be fixed without an array.

    Sorry if I wrote something wrong. My english it's not so good.



  • @Sergio-Rius

    The problem with the linear fading was that a value of 100 almost looked the same as 150. So the goal was to make the fading look more linear. The logarythmic calculations needed for this cannot be done on an atmega 328p. (I tried it)
    This is why I calculated the values with MS Excel and put them in an array.

    Making the fading process alway take the same time would be nice. Feel free to post your implementation. πŸ˜‰



  • @Jan-Gatzke @LastSamurai I've been playing with the formula of the blog post written in comments on the sketch and I see that this isn't something trivial.
    I think the code in the post has a misconception, that using 0-255 he missed that the graph data is not related to time, but pwm value.

    So a fixed table for conversion between pwm value and appreciated light has to be built. And you also arrived to this conclusion seeing the array.
    I'm generating the array on the fly using the formula with 256 steps.
    (In the blog code there's a bug caused by the mean of zero in intervals and the formula that causes max value to being reached. You have to sum one to interval before using on the formula.)

    I'm now trying to separate a loop for traveling the array that compensates for in between values so it can handle smaller steps->variable interval.

    Sorry. Just thinking out loud.



  • I've been working on an sketch for this board. Somewhere in the path I started adding functionalities and it ended in a library. Perhaps it's way overkill, but I thought that could be easier add it to NodeManager like that.
    It's based on the work done here and some more ideas around the network. Thanks to LastSamurai for the board and code and also to Jan.
    You can find the sources there: https://github.com/SergioRius/RGBWDimmer

    This thing includes a serial manager that I use myself, but you can remove it and delete all the code for debugging, and perhaps add yourselves if necessary.
    Just clone the repo or download and install as a zip library on Arduino IDE.
    The example works for the OH! MySensors RGBW board as is.

    It's very self explanatory in the code, but in essence:

    • It can be used stand-alone or with mysensors
    • You simply send to the commands and the class does all for you.
    • Uses a non blocking system for the fading.
    • Configurable fading time and resolution
    • Several configurable fading curves
    • Option for gamma (brightness + hue) calibration.

    I'm currently debugging the fading curves equations other than linear, as the arduino mcu capabilities are tight and it's so easy to overflow it. Also I'm doing a program for calibrating the hue (arduino with leds and a rotary encoder for manually adjusting), so for now gamma only compensates brightness. You can change the values if you prefer. I'll be a good idea to lower the white channel.

    It still lacks some memory optimization, but for now I'm scared about overflows. I got one of those and it was a two days nightmare and I had to revert to ints to get something running.
    I'll soon add a stand alone sample and port to NodeManager.
    For the while, for using it alone the minimal it's:

    #include "RGBWDimmer.h"
    RGBWDimmer myDimmer(1, 3, 5, 6, 9);  ///< id (to remove), Red Pin, Green Pin, Blue Pin, White Pin
    
    bool JustDontBlockLoop = true;
    
    void loop() {
      if(JustDontBlockLoop) {
          myDimmer.setNewValues(255, 0, 150, 0);  ///< RGBW decimal values. If you prefer hex, use setNewValuesHex
          myDimmer.StartFading();
          JustDontBlockLoop = false;
      }
      myDimmer.loop();
    }
    

    I hope you like it. And if you have any idea for adding functionality, please tell me.



  • I updated the repo for being easier to download and install.


  • Hardware Contributor

    Wow nice! Might take me some time, but I will take a look at your code (and maybe add some of its features back to my sketches if that fine with you).



  • @LastSamurai Yes, of course.
    Just a question. How did you make the "values curve"? You said in excel and perhaps a graph... did you manage to change graph values and update data in any way?

    I've made the sketch for adjusting the gamma values, something with a Serial monitor menu that allows for increasing and decreasing the channels in real time. And adjusted the greens for a better hue (orange being orange, not a greenish yellow) but now I do't know how to adapt the curve.
    I refuse to modify the 255 values by hand.

    Now I'm making a case for 3d-print. Where do I have to post it, there or in a separate post? I read anything about posts becoming entries at hardware.io and ΒΏbuild?



  • Do you really need an external voltage regulator for this module? I mean the Arduino Pro Mini has its linear regulator already built in. You can only draw about 100ma from it, but wouldn't that be sufficient for the micro, radio and the mosfet gates?


  • Hardware Contributor

    @ThetaDev Maybe you you could get away with it but especially the radio is very sensitive concerning the power supply. Cheap pro minis often use very cheap regulators too and then this might become a problem.
    I also wanted to support the high power version of the NRF and that definitly needs more power than provided by the onboard regulator.



  • Hi
    How i can modify sketch files INO to use it with radio RFM69HW with this adaptaer:
    https://www.openhardware.io/view/16/NRF2RFM69#tabs-design


  • Hardware Contributor

    I never tried that but as far as I know you have to tell Mysensors to use a different kind of radio by adding a define like:

    #define MY_RADIO_RFM69
    

    Just do a quick search on this forum though πŸ˜‰



  • And your project works also with Home Assistant ?
    Can you show how it looks in your automation ? Which controller you use ? (Domoticz or other)
    And on MySensors 2.2.0 this also works ?


  • Hardware Contributor

    I only had Home Assistant installed for some days (did not really like it at the time) so I can't tell you that it works 100% but it did back then. You have to add some strange additional messages but I tried to integrate that into my code.
    I am using my RGBW controllers with openhab 2 in one location and with domoticz in another. As it is controlled by MySensors it works (and looks) pretty much like any other mysensors node. Both installations run on 2.2. Hope this helps πŸ™‚



  • @lastsamurai
    Very thanks for info. I try build and test with Home Assistant.



  • Mmmmm... How much have you pushed this board? I mean, in terms of load.
    I just had one fail at me and I'm trying to understand what component may have been the weak link.

    It was driving a 5m white stripe when it turned himself off and on again, but although the light was still on the node was down. I took it out and almost burned my hand. Not the mosfets, but the arduino and radio. Nothing seems bad (components good looking, arduino seems to start) but as soon as you apply 12v, even without load it starts the barbecue.

    It seems that the mosfets are good to 4,2Ah if I understand it. So what would be the boards specs? πŸ€”


  • Mod

    Have you checked the voltage on the arduino?



  • @gohan As you suspected, it was 12v.


  • Mod

    No wonder why it got hot, poor little arduino πŸ˜„



  • @gohan Yeah, but what is not that intiutive for me is why when load increases in the mosfets side, the ams regulator goes away.

    Anyways, no one knows what max led strip length is this board good for?


  • Mod


  • Hardware Contributor

    @sergio-rius A little late, sorry, but that depends on the mosfets you are actually using. I am driving ~5m strips of white leds with most of my controllers and they don't even really get hot.

    There is also a big(ish) update from my side concerning this project: I have designed, 3d printed and tested my own case for the controllers and they work great. I have just added the stl files and some images to the project page!!
    For now this project is done from my side. The controllers have been working great for the past 2 years but due to the "huge" (~1s) delay with my Mysensors network (with signing and openhab on a raspi) when switching the leds I am currently testing some MQTT and wifi based RGBWW controller boards as an alternative.

    alt text


 

258
Online

7.7k
Users

8.6k
Topics

92.3k
Posts