MySensors shield and RGBW Controller

[LastSamurai]

@GertSanders Thanks you very much but I just can't find any of them (at least at a reasonable price) on aliexpres or ebay(.de).
Should you (or someone else) know a link to one, please send it to me!

[LastSamurai]

So I got my pcbs yesterday and started to test them. After some problems with power supply (here) I got the pro mini + nrf to work and send/receive commands. Today I connected the led lights and nothing happened (although it should start with a little power on all channels). After some time of testing to figure out the error the AMS suddenly got very hot and I disconnected the power as fast as possible. Now the pro mini doesn't react anymore to programming (or even serial in/output). I think I somehow broke it. Before I destroy another one though:
do you guys have any idea if there might be an error in my schematics (especially concerning the mosfet part)?

The schematics are in the pdf:
link text

This is my current code:

/**
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 - First version

TODO
safe/request values after restart/loss of connection
*/


#define SN   "RGBW test"
#define SV   "v1.0 29042016"

// Load mysensors library	
#include <MySensor.h>	
// Load Serial Peripheral Interface library  
#include <SPI.h>

// Arduino pin attached to driver pins
#define RED_PIN 3 
#define WHITE_PIN 9	// this is not a pwm pin! change it if you want pwm
#define GREEN_PIN 5
#define BLUE_PIN 6
#define NUM_CHANNELS 4 // how many channels, RGBW=4 RGB=3...

#define SENSOR_ID 1

// Smooth stepping between the values
#define STEP 1
#define INTERVAL 10
const int pwmIntervals = 255;
float R; // equation for dimming curve

// change the pins to free up the pwm pin for led control
#define RF24_CE_PIN   4 //<-- NOTE!!! changed, the default is 9
#define RF24_CS_PIN   10  // default is 10
#define RF24_PA_LEVEL RF24_PA_MAX

MyTransportNRF24 transport(RF24_CE_PIN, RF24_CS_PIN, RF24_PA_LEVEL);
MySensor gw(transport);	
   
// Stores the current color settings
byte channels[4] = {RED_PIN, GREEN_PIN, BLUE_PIN, WHITE_PIN};
byte values[4] = {100, 100, 100, 100};
byte target_values[4] = {100, 100, 100, 100}; 


// 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)
  gw.begin(incomingMessage);	// 123 = node id for testing	
       
  // Present sketch (name, version)
  gw.sendSketchInfo(SN, SV);				
       
  // Register sensors (id, type, description, ack back)
  gw.present(SENSOR_ID, S_RGBW_LIGHT, "RGBW test light", true);

  // request current values from gateway/controller
  //gw.request(SENSOR_ID, S_RGBW_LIGHT);

  // 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));

  // init lights
  updateLights();
  
  // debug
  if (isOn) {
    Serial.println("RGBW is running...");
  }
 
  Serial.println("Waiting for messages...");  
}

void loop()
{
  // Process incoming messages (like config and light state from controller) - basically keep the mysensors protocol running
  gw.process();		

  // and set the new light colors
  if (millis() > lastupdate + INTERVAL) {
    updateLights();
    lastupdate = millis();
  } 
}

// callback function for incoming messages
void incomingMessage(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();
  }

  // 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);    
  }  
}

// 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 * 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, (values[i] / 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;
}

[LastSamurai]

I finally found the mistake (with some help). The pins for the mosfets were switched. I rotatet them and now its working perfectly. Smooth dimming and switching between colors is really cool. New pictures are on my openhardware.io project page.
Now I need to get some more features for the code (linear fading, remembering the values after restarts...) and then perhaps sometime in the future a better (and fixed) version of the pcb.

[activemind]

@LastSamurai This is a very nice and useful board you have here. But I was more interested in the first PCB you made with heftier FETs. Would it be okay if I took that first rev as a base and modified it for my needs. I need a VERY simple 3 channel (RGB) controller with hefty (> 5A) FETs.

How do I access the board files of that first rev to use them as base?

-AM

[LastSamurai]

@activemind said:

@LastSamurai This is a very nice and useful board you have here. But I was more interested in the first PCB you made with heftier FETs. Would it be okay if I took that first rev as a base and modified it for my needs. I need a VERY simple 3 channel (RGB) controller with hefty (> 5A) FETs.

How do I access the board files of that first rev to use them as base?

-AM

Thanks you! The old files are here I think. It has been done with Target3001 and kicad. You could just take my newest board and replace the FETs. Or just order my boards and solder the FETs onto the smd pads (not perfect but should work too).
I did some updates in the newer versions so be carefull to catch that (e.g. use pwm pins for all 4 colors).

Once I find the time I'll upload some pictures here too. At the moment I am using 3 of my boards to light up a room. Looks very nice imho.

[activemind]

Thanks @LastSamurai . I went ahead and ordered v1.3 of the board just to try them out. If I can solder heftier FETs then your board is EXACTLY what I am looking for. I dont care much about 4th channel since all of my applications will be high power RGB floods.

I didnt look too closely but is there provision for current limiting ressistors in each of the channels.

I will go ahead and load your files in KiCad and see if I can find my way around. Never done any PCB dev but want to give it a try :-)

-AM

[LastSamurai]

@activemind Cool, I guess you are the first one (beside me^^) using these boards. It's nice to see that my work can help others. Some feedback later on would be great :+1:

Current limiting resistors are not part of the board atm. Did not really need them. I only added pulldowns to the control lines.
But just have a look with kicad; the program (while having some strange menues/shortcuts) isn't that hard to learn and if you continue to work with electronics its a nice skill to have. I am 100% selft taught and my designs (mostly :stuck_out_tongue_closed_eyes: ) work.

[activemind]

@LastSamurai Thats a bummer that there are no current limiting ressistor. They are a must with any kind of RGB flood. Hmmm!

I understand why you did not need them because you are primarily driving strips and not RGB floods!

Maybe you can add them to your TODO list for the next rev as optional components.

Yeah, I installed KiCad and now need to load your files to see if I can stumble my way around :-)

-AM

[LastSamurai]

@activemind Yes, I will include that in my next version (whenever that will be^^). You could just add them "after" the board before connection the actual RGB lights though (if you use TH components).

Ok have fun ;) If you have questions feel free to send me a message here.

[activemind]

@LastSamurai Thanks for the offer. I might take you up on it though :-P

I think I am going to start another thread once I have something meaningful to update.

-AM

[LastSamurai]

Just a short update: I now have 5 of these controllers controlling different led strips in my apartment. They are all working without a problem (some of them for nearly half a year now).
I did some small updates to the code (which you can get via github) and will try to update the pcb later to fix that one annoying error with the mosfets.

[LastSamurai]

I will try to upload the changed pcb tomorrow. Today I added my sensor platform that I am currently using with a motion sensor to light up a room when someone enters.
I will also try to add some pictures of my current setup soon.

Here is the sensor platform: https://www.openhardware.io/view/261

[Jan Gatzke]

@LastSamurai

I tried the new version of the pcb. I think the hardware is just working fine. However I have a problem with the sketch or domoticz. I can switch the light on and off. This switches all channels. So the FETs and the Arduino seem to work fine. I can dim the light, too. What does not work is the color selection with domoticz. If I select another color nothing happens. All 4 channels seem to habe the same level all the time. Any idea?

[LastSamurai]

@Jan-Gatzke Was this due to the error in my fading code? Otherwise you have to connect a serial to usb controller to the node and check what the converter method does that converts domoticz to RGBW values.

[Jan Gatzke]

@LastSamurai

Yes, this was the problem we already discussed in the other thread.

[pepson]

Hi
Is anybody who can help me how add phisical button to enable from the wall leds only in color white ?
Button will be connect to pin in arduino but how implement it to code sketch ? I want to on/off white color without gateway... example gateway not working....

[franz-unix]

@pepson Hi, not sure if it is exactly what you are looking for, but this firmware

https://github.com/d-diot/d-diot-nano-repeater

Can turn a RGB led strip on and off with a button press. To force white color you need to customize the code.

[pepson]

But I need code in sketch to upload by Arduino IDE...

[pichaty]

This post is deleted!

[TRS-80]

@LastSamurai,

Very nice project you have here! Thank you for taking the time to post/share your work!

At first I thought it might be exactly what I was looking for, but reading through everything now I am not so sure.

I have been studying various ways (Wi-Fi, 433/315 Mhz RF, MySensors) to implement controlling RGB lights and I initially thought Wi-Fi (while readily available, easy, and cheap) might be too "slow" in response time, which got me thinking to use MySensors (with NRF24) instead, which led me to this thread (among others).

Something concerned me though, I see in your GitHub for this project you stated:

Project frozen/final - This project is done from my side. It has been working for years but I switched to another solution so I won't update this anymore.

and on your OpenHardware page:

Update2: They have been running for about 2 years now mostly without problems. The only disadvantage is that my Mysensors network overall is quite "slow" (~1s reaction time). I am currently experimenting with Wifi RGBWW controllers (H801) so there wont be to many more updates to this project

Which made me want to ask you what you are using now?

It seems to me that those MagicHome type Wi-Fi (or RF) RGB controllers would be pretty hard to beat price wise, I don't think I could implement similar functionality (including packaging, etc.) for the same amount of money, and that's before even counting my time.

Also I am still struggling with reliability of my MySensors network in general, but I hope to be able to still solve this as it seems that many others have been able to (but that is a different subject altogether).