12v pwm to addressable LED arduino

[SkullboyNL]

Ik wil graag mijn RGB header op mijn moederbord synchroniseren met mijn RGB fans. Helaas zijn mijn RGB fans addressable en is mijn ledstrip en de led header op mijn moederbord PWM. Nu kan ik natuurlijk gewoon een addressable ws2812 RGB strip kopen maar dat is te makkelijk en dan kan ik de software van mijn moederbord niet gebruiken. Ik vind de opties in de software van Corsair niet mijn ding en ik hou van DIY.

Wat heb ik nu.
Moederbord: MSI Z270 GAMING PRO CARBON
Ledstrip: 5050 PWM strip.
Fans: Corsair SP120 RGB en Corsair ML140 RGB
Overige hardware: arduino (uno, mega, mini, nano)

Natuurlijk ben ik eerst het net op gegaan en het enige wat ik kon vinden was dit. https://linustechtips.com...rip-with-mbo-rgb-headers/

Ik heb dat natuurlijk na gemaakt en het werkt deels. Dit is wat ik nu heb.


12v, R, G, B = RGB header op mijn moederbord.
A0 = arduino analog pin 0
A1 = arduino analog pin 1
A2 = arduino analog pin 2

Deze code heb ik gebruikt.

C:

 
#include <FastLED.h>

//Set this to the number of fans if using SP fans or 12*num fans if using HD fans
#define NUM_FAN_LEDS 1

#define FAN_PIN 6

CRGB leds[NUM_FAN_LEDS];

void setup() {
  //LED setup code, to initialise FastLED.

  //Fan LED setup. Replace 'UICS1903' with 'WS2812' if using HD fans. Leave if using SP fans.
  //BRG is added to change order of data transmission to SP fans. Change if fans do not output correct colours.
  FastLED.addLeds<UCS1903, FAN_PIN, BRG>(leds, NUM_FAN_LEDS);
}

void loop() {
  
  //Read analogue values from pins connected to Aura header.
  int red = analogRead(2);
  int green = analogRead(0);
  int blue = analogRead(1);


  //Modify the 0-1023 value from analogue read to 0-255 for use with FastLED.
  double redTemp = red - 1.;
  double greenTemp = green - 1;
  double blueTemp = blue - 1;

  redTemp = redTemp / 3.84;
  blueTemp = blueTemp / 3.84;
  greenTemp = greenTemp / 3.84;

  int redToLED = 255 - redTemp;
  int greenToLED = 255 - greenTemp;
  int blueToLED = 255 - blueTemp;
  
  //Check if each of the RGB values is outisde the range 0-255, and if so set it to 0/255.
  //Values outside this range make FastLED behave strangely.
  if (redToLED > 255){
    redToLED = 255;
  } else if (redToLED < 0){
    redToLED = 0;
  }
    if (blueToLED > 255){
    blueToLED = 255;
  } else if (blueToLED < 0){
    blueToLED = 0;
  }
    if (greenToLED > 255){
    greenToLED = 255;
  } else if (greenToLED < 0){
    greenToLED = 0;
  }
 
  //Sync fans with aura.
  fill_solid(leds, NUM_FAN_LEDS, CRGB(redToLED, greenToLED, blueToLED));


  //Send the colour data to the LEDs/fans.
  FastLED.show();
}
 

Helaas werkt het toch niet helemaal goed. Omdat mijn moederbord PWM signaal uit stuurt heb ik dus geen stabiele 5v lijn op de analoge input van de arduino. Hierdoor knipperen de Leds als een gek. Zie filmpje. De Led hoort wit te branden.

Waar ik dus eigenlijk naar opzoek ben is een manier om de 12v lijn naar 5v stabiel te krijgen zodat ik die kan aansluiten op arduino en met die waarde de Leds weer aan kan sturen.

Iemand een idee hoe ik dit het beste kan oplossen?

[itcouldbeanyone]

Inplaats van 100nf zou ik 1uf proberen.
Dit zou je ook software matig kunnen doen, om zo van pwm een spanning te maken.
Heb zelf daar een software matige condensator voor geschreven

Waarom deel je die 0 tot 1023 niet gewoon door 4.
Hoef je ook niet te constrainen.
Daar naast if(x>255){x=255;} gewoon constrain(x, 0,255); zo blijft x dus tussen 0 en 255

[SkullboyNL]

itcouldbeanyone schreef op donderdag 22 februari 2018 @ 00:03:
Inplaats van 100nf zou ik 1uf proberen.
Dit zou je ook software matig kunnen doen, om zo van pwm een spanning te maken.
Heb zelf daar een software matige condensator voor geschreven

Waarom deel je die 0 tot 1023 niet gewoon door 4.
Hoef je ook niet te constrainen.
Daar naast if(x>255){x=255;} gewoon constrain(x, 0,255); zo blijft x dus tussen 0 en 255

bedankt voor je input. Heb je de software matige condensator bij de hand en zal je die willen delen?

[EHelmond]

Je moederboard PWM't

Hierdoor heeft het volgens mij geen zin om dit analoog te gaan meten.


Ik zou het PWM signaal digitaal meten, de dutycycle bepalen
en aan de hand van de RGB dutycycles de LEDs aansturen

[itcouldbeanyone]

hier een simpele script die als virtuele capacitor dient

code:

long C[32];//32 is het maximum aantal condensators, vergroot indien je meer nodig hebt
long Ccharge[32];// 
long jouleCharge[32];// capacitor function
long PL;// capacitor function
void setup(){
Serial.begin(9600);}
void loop(){
  
  Serial.println(cap(C[1],  analogRead(A5),47) );// 47 is het formaat van je condensator, 
//hoe groter hoe smoother, 
//C[1] is het nummer van de condensator, bij een 2e analoge pin, gebruik je dus C[2]
delay(10);
}

long cap(int capNum,  long VAL,  long Farads) {
  Ccharge[capNum] += VAL;
  jouleCharge[capNum]++;
  PL  = Ccharge[capNum] / jouleCharge[capNum];
  if (jouleCharge[capNum] > Farads) {
    Ccharge[capNum] = PL;
    jouleCharge[capNum] = 1;
  }
  return PL;
}

wat je ook kan doen is constrainen.
bovenstaande functie werkt goed met voltages,
onderstaande werkt zeer goed met toerentellers.

code:

int lstX=0;
int smoothValue=1; // increase for less smoothness
void setup(){
Serial.begin(9600);}

void loop() {
  // put your main code here, to run repeatedly:
  int x;
  x=constrain(analogRead(A5), lstX-smoothValue, lstX+smoothValue);
  Serial.println(x);
  lstX=x;

  delay(10);
}

wat EHelmond al zegt, je kan ook de duty cycles gaan meten, maar in principe lukt het als voltage ook net zo goed.

[ Voor 7% gewijzigd door itcouldbeanyone op 22-02-2018 13:04 ]

[SkullboyNL]

@EHelmond
Ik weet dat het PWM is maar pwm kun je ook uitlezen als voltage.

@itcouldbeanyone Bedankt voor de code. Ik ga er wat mee spelen.


Gister avond nog even geprobeerd om wat uit te lezen doormiddel van het pwm signaal te meten.

C:

 int pin1 = 5;  
 int pin2 = 6;  
 int pin3 = 7;  
 int duration; 

void setup() {
pinMode(pin1, INPUT); 
pinMode(pin2, INPUT); 
pinMode(pin3, INPUT); 
Serial.begin(9600);    
}

void loop() {
 duration = pulseIn(pin1, HIGH);
 Serial.print("red ");
Serial.println(duration);  

 duration = pulseIn(pin2, HIGH);
 Serial.print("Green ");
Serial.println(duration);  

 duration = pulseIn(pin3, HIGH);
 Serial.print("Blue ");
Serial.println(duration);  
  

Serial.println("----------------"); 
}

Hier kwam veel data uit waar ik niet veel mee kan

Bijvoorbeeld groen. Dan geeft rood en blauw 0 aan dat is mooi maar groen geef dan een paar 100x 5 dan 261 en dan weer 10 talen keren 5 en dan weer 5534.

Maar die code zal niet goed werken voor mijn doel dus ik zoek wat verder.

[itcouldbeanyone]

SkullboyNL schreef op donderdag 22 februari 2018 @ 13:41:
@EHelmond
Ik weet dat het PWM is maar pwm kun je ook uitlezen als voltage.

@itcouldbeanyone Bedankt voor de code. Ik ga er wat mee spelen.


Gister avond nog even geprobeerd om wat uit te lezen doormiddel van het pwm signaal te meten.

C:

 int pin1 = 5;  
 int pin2 = 6;  
 int pin3 = 7;  
 int duration; 

void setup() {
pinMode(pin1, INPUT); 
pinMode(pin2, INPUT); 
pinMode(pin3, INPUT); 
Serial.begin(9600);    
}

void loop() {
 duration = pulseIn(pin1, HIGH);
 Serial.print("red ");
Serial.println(duration);  

 duration = pulseIn(pin2, HIGH);
 Serial.print("Green ");
Serial.println(duration);  

 duration = pulseIn(pin3, HIGH);
 Serial.print("Blue ");
Serial.println(duration);  
  

Serial.println("----------------"); 
}

Hier kwam veel data uit waar ik niet veel mee kan

Bijvoorbeeld groen. Dan geeft rood en blauw 0 aan dat is mooi maar groen geef dan een paar 100x 5 dan 261 en dan weer 10 talen keren 5 en dan weer 5534.

Maar die code zal niet goed werken voor mijn doel dus ik zoek wat verder.

pulseIn is verre van accuraat, vaak worden daar laat maar zeggen 1000 readings gedaan, en daar een gemidelde van getrokken.
dat kan je dus ook doen door hem door de virtuele capacitor te trekken.
maar aangezien de range onbekend is, zou ik gewoon voor voltage gaan

[SkullboyNL]

Het is gelukt.

Wat heb ik gedaan:

Ik heb de condensator waardes verhoogt van 100nf naar 10uf. Hierna zag ik op mijn scope een bijna stabiele spanning.

De code heb ik wat aangepast. En heb nu onderstaande code in gebruik.

C:

#include <FastLED.h>

//Set this to the number of fans SP fans. And Pin number 
#define NUM_SP_FANS 1
#define SP_PIN 6

//Set this to the number of fans ML fans *8 And Pin number 
#define NUM_ML_FANS 8
#define ML_PIN 7

CRGB leds[NUM_SP_FANS];
CRGB leds2[NUM_ML_FANS];

void setup() {

  //Fan LED setup. UCS1903 is for the SP fans, WS2812 is for the ML fans.
  
  FastLED.addLeds<UCS1903, SP_PIN, BRG>(leds, NUM_SP_FANS);
  FastLED.addLeds<WS2812, ML_PIN>(leds2, NUM_ML_FANS);
  }

void loop() {
  //Read analogue values from pins connected to motherboard RGB header.
  float red = analogRead(2);
  float green = analogRead(0);
  float blue = analogRead(1);

  //Modify the analogue value to 0-255 (8 Bit) for use with FastLED
  red = (red -850) * 2.2;
  blue = (blue -850) * 2.2;
  green = (green -850) * 2.2;

  int redToLED = 255 - red;
  int greenToLED = 255 - green;
  int blueToLED = 255 - blue;
  
  //Check if each of the RGB values is outisde the range 0-255, and if so set it to 0/255.
  redToLED = constrain(redToLED, 0, 255);
  greenToLED = constrain(greenToLED, 0, 255);
  blueToLED = constrain(blueToLED, 0, 255);
  
      //Set color for the fans.
      fill_solid(leds, NUM_SP_FANS, CRGB(redToLED, greenToLED, blueToLED));
      fill_solid(leds2, NUM_ML_FANS, CRGB(greenToLED, redToLED, blueToLED));

        //Send the colour data to the LEDs/fans.
        FastLED.show();
}

Ik heb hier wel gebruik moeten maken van een berekening omdat ik geen mooie waarde van tussen de 0 en 1023 kreeg maar tussen de 845 en 980.

Zie hier het resultaat. (Let niet op de kabels)

@itcouldbeanyone bedankt voor de input.

Wat nog te doen:
Printje etsen.


Ik heb dit getest op een arduino UNO maar het zal gaan draaien op een arduino nano

[itcouldbeanyone]

Mooi om te horen dat het gelukt is