Loop probleem

[benvo Profiel Privébericht]

Ik vergat nog te vertellen dat ik ook keek onder: Schedule Point format: (Hour, Minute, Intensity) dus onder de in te voeren waarden. Ook Intensity met of zonder hoofdletter geeft geen resultaat.


Groet,
Ben.

[Dries Profiel Privébericht]

kijk hier eens naar Ben, deze toevoeging heb ik des tijds ook geprobeerd en werkte bij mij:
https://github.com/dalgibbard/LightController
ik ben ook zo hoor, nooit tevreden maar zo blijft die grijze hersenmassa wel in beweging hé

voor iedereen een zalige kerstmis

[benvo Profiel Privébericht]

Dries, exact deze had ik al gevonden! Deze meneer drukt alleen, in zijn geval 4 x (voor 4 kanalen) een percentage af op dezelfde plek op zijn scherm. Ik wil 3x (voor 3 kanalen) op mijn scherm krijgen. Ik ben nog aan het zoeken hoe dit aan te passen.

Dank je wel voor je reactie! Je hebt me overigens echt goed geholpen!

[Dries Profiel Privébericht]

Alsjeblieft Ben:

/*
* Name: LightController.ino
* Author: User "benjaf" at plantedtank.net forums
* URL: https://github.com/benjaf/LightController
* This example is set up for 2 channels with a maximum of 10 points.
* Anything that may require editing is labeled with �CHANGE�

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

// ----------------------- RTC Library -----------------------
// Use Wire and RTClib (https://github.com/adafruit/RTClib):
// Please note that there are a significant differences between the original JeeLabs RTCLib and the Adafruit fork!
#include <Wire.h>
#include "RTClib.h"
#include "ChannelManager.h"
#include "T6963.h"
// ----------------------- Constants -----------------------
// �CHANGE�
const int MaxChannels = 3; // Max number of channels, change if more or less are required
const int MaxPoints = 10; // Max number of light intensity points, change if more or less are required
char tijd[25];
char rood[25];
char blauw[25];
char groen[25];
T6963 LCD(240,128,6,32);
// ----------------------- Variables -----------------------
// RTC
RTC_DS1307 RTC;

// Time
DateTime CurrentTime;

// ----------------------- Lights -----------------------

// Schedule Point format: (Hour, Minute, Intensity)
// Difference in intensity between points is faded/increased gradually
// Example:
// Channels[0].AddPoint(8, 0, 0);
// Channels[0].AddPoint(8, 30, 255);
// Channels[0].AddPoint(11, 0, 255);
// ...
//
// Explanation:
// 00:00 - 08:00 -> Light OFF
// 08:00 - 08:30 -> Increment light towards Fully ON
// 08:30 - 11:00 -> Light Fully ON
//
// Min intensity value: 0 (OFF)
// Max intensity value: 255 (Fully ON)
//
// If only 1 point is added, channel always maintains value of that point
//
// There is the option of which fade mode to use.
// Basically there are 2 modes: Linear and Exponential
// - Linear is what you would expect - 50% on = 50% duty cycle.
// - Exponential is an estimation of how our eyes react to brightness. The 'real' formula is actually inverse logarithmic,
// but for our use exponential is close enough (feel free to add more fade modes if you disagree) - and much faster to compute!

Channel Channels[MaxChannels];
Point Points[MaxChannels][MaxPoints];

// Add more timing definitions here if more channels are added:
// �CHANGE�
void InitializeChannels(int channels) {
// Channel 0: (Example)
// This is an example of a typical lighting schedule (Lights on 08:30 - 19:00 w. 30 minutes of sunrise / sunset added)
// using linear fading on pin 10.

//int channelNo = 0;
//int pin = 10;
//Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);
//Channels[channelNo].AddPoint(8, 0, 0);
//Channels[channelNo].AddPoint(8, 30, 255);
//Channels[channelNo].AddPoint(19, 0, 255);
//Channels[channelNo].AddPoint(19, 30, 0);

// Channel 0:
int channelNo = 0; // BLAUW
int pin = 6; // Channel 0 uses pin 10
Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]); // Initialize channel and choose FadeMode
Channels[channelNo].AddPoint(9, 30, 0); // Add Point (can also use decimal values ranging from 0 to 1 if you prefer)
Channels[channelNo].AddPoint(10, 30, 255);
Channels[channelNo].AddPoint(22, 0, 255);
Channels[channelNo].AddPoint(23, 59, 0);

// Channel 1:
channelNo = 1; // ROOD
pin = 3; // Channel 1 uses pin 11
Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);
Channels[channelNo].AddPoint(9, 30, 0); // Add Point (can also use decimal values ranging from 0 to 1 if you prefer)
Channels[channelNo].AddPoint(10, 30, 255);
Channels[channelNo].AddPoint(22, 0, 255);
Channels[channelNo].AddPoint(23, 0, 0);

channelNo = 2; // GROEN
pin = 5; // Channel 1 uses pin 11
Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);
Channels[channelNo].AddPoint(9, 30, 0); // Add Point (can also use decimal values ranging from 0 to 1 if you prefer)
Channels[channelNo].AddPoint(10, 30, 255);
Channels[channelNo].AddPoint(22, 00, 255);
Channels[channelNo].AddPoint(23, 59, 0);

}

// ----------------------- Functions -----------------------
long lastUpdateTime = 0;

// Update light intensity values
void UpdateLights(DateTime currentTime)
{
long now = Seconds(currentTime.hour(), currentTime.minute(), currentTime.second()); // Convert current time to seconds since midnight
if(now != lastUpdateTime) // Perform update only if there is a perceivable change in time (no point wasting clock cycles otherwise)
{
sprintf(tijd, "%02d:%02d:%02d", CurrentTime.hour(), CurrentTime.minute(), CurrentTime.second());


for(int channel = 0; channel < MaxChannels; channel++) // For each Channel
{
analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now)); // Get updated light intensity and write value to pin (update is performed when reading value)
float intensityblauw = Channels[0].GetLightIntensityInt(now);
float maxIntensityblauw = 255;
float b = intensityblauw / maxIntensityblauw;
float currentPercentblauw = b * 100;
dtostrf(currentPercentblauw,5,2,blauw);



}
for(int channel = 1; channel < MaxChannels; channel++)
{
analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now));
float roodwaarde = Channels[1].GetLightIntensityInt(now);
float maxIntensityrood = 255;
float r = roodwaarde / maxIntensityrood;
float currentPercentrood = r * 100;
dtostrf(currentPercentrood,5,2,rood);


}
for(int channel = 2; channel < MaxChannels; channel++)
{
analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now));
float groenwaarde = Channels[2].GetLightIntensityInt(now);
float maxIntensitygroen = 255;
float g = groenwaarde / maxIntensitygroen;
float currentPercentgroen = g * 100;
dtostrf(currentPercentgroen,5,2,groen);

}



}
lastUpdateTime = now;
}


// Convert HH:mm:ss -> Seconds since midnight
long Seconds(int hours, int minutes, int seconds) {
return ((long)hours * 60 * 60) + (minutes * 60) + seconds ;
}

void InitDisplay(){

LCD.TextGoTo(0,0);
LCD.writeString(tijd);
LCD.TextGoTo(0,1);
LCD.writeString("Kanaal blauw: ");
LCD.writeString(blauw);
LCD.writeString(" %");
LCD.TextGoTo(0,2);
LCD.writeString("Kanaal rood: ");
LCD.writeString(rood);
LCD.writeString(" %");
LCD.TextGoTo(0,3);
LCD.writeString("Kanaal groen: ");
LCD.writeString(groen);
LCD.writeString(" %");
}




// ----------------------- Setup -----------------------
void setup() {
// Initialize channel schedules
InitializeChannels(MaxChannels);

// Clock
Wire.begin();
RTC.begin();
LCD.Initialize();
InitDisplay();
//RTC.adjust(DateTime(__DATE__, __TIME__)); // Set RTC time to sketch compilation time, only use for 1 (ONE) run. Will reset time at each device reset!
}

// ----------------------- Loop -----------------------
void loop() {
// Get current time
CurrentTime = RTC.now();





// Update lights
UpdateLights(CurrentTime);

InitDisplay();
}

ik had dit destijds aangepast om een RGB strip aan te sturen met telkens de % per kanaal, probeer het maar eens

[benvo Profiel Privébericht]

Op dit moment ben ik zover dat ik de percentages kan afdrukken op mijn LCD scherm.

Er gebeurd iets vreemds; de waarden kloppen niet. Zo heb ik op dit moment bijvoorbeeld op mijn scherm staan dat Channel 0 op 37% staat. Channel 1 zegt dat de led met 67% brand en Channel geeft een percentage van 52% aan.
(Het is nu :17:03 uur.) Wanneer je kijkt naar mijn instellingen komt dit niet overeen. Bovendien merkt ik dat de waardes heel langzaam zakken hoewel dat Channel 0 en 1 in ieder geval nog vol zouden moeten branden.

Dal Gibbard verteld overigens ook nog dat de originele controller sketch van "Benjaf" maar op 80% maximale helderheid zou kunnen komen. Hij past z'n invoerwaarden ook aan. Ik vind nergens terug waar hij dit op baseert.

Mijn sketch zoals die er nu uitziet:

cpp code

/*
 * Name:	LightController.ino
 * Author:	User "benjaf" at plantedtank.net forums
 * URL:		https://github.com/benjaf/LightController
 * Updated by Dal Gibbard
 * https://github.com/dalgibbard/LightController
 * This example is set up for 2 channels with a maximum of 10 points.
 * Anything that may require editing is labeled with �CHANGE�
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. 
 */

// ----------------------- RTC Library -----------------------
// Use Wire and RTClib (https://github.com/adafruit/RTClib):
// Please note that there are a significant differences between the original JeeLabs RTCLib and the Adafruit fork!
#include <Wire.h>
#include "RTClib.h"
#include "ChannelManager.h"
#include<LCD.h>
#include<LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F,2,1,0,4,5,6,7); //0x3F is hetI2C bus adres voor een ongemodificeerd Backpak
 

// ----------------------- Constanten -----------------------
// �CHANGE�
const int MaxChannels = 3;   // Max number of channels, change if more or less are required
const int MaxPoints = 25;    // Max number of light intensity points, change if more or less are required

// RTC
RTC_DS3231 rtc;

// Time
DateTime CurrentTime;

// ----------------------- Variabelen -----------------------


// ----------------------- Licht -----------------------

// Schedule Point format: (Hour, Minute, Intensity)
// Difference in intensity between points is faded/increased gradually
// Example: 
// 	Channels[0].AddPoint(8, 0, 0);
//	Channels[0].AddPoint(8, 30, 255);
//	Channels[0].AddPoint(11, 0, 255);
//  ...
//
// Explanation:
//  00:00 - 08:00 -> Light OFF
//  08:00 - 08:30 -> Increment light towards Fully ON
//  08:30 - 11:00 -> Light Fully ON
//
// Min intensity value: 0 (OFF)
// Max intensity value: 255 (Fully ON)
//
// If only 1 point is added, channel always maintains value of that point
//
// There is the option of which fade mode to use.
// Basically there are 2 modes: Linear and Exponential
// - Linear is what you would expect - 50% on = 50% duty cycle.
// - Exponential is an estimation of how our eyes react to brightness. The 'real' formula is actually inverse logarithmic,
// 	 but for our use exponential is close enough (feel free to add more fade modes if you disagree) - and much faster to compute!

Channel Channels[MaxChannels];
Point Points[MaxChannels][MaxPoints];

// Add more timing definitions here if more channels are added:
// �CHANGE�
void InitializeChannels(int channels) {
	// Channel 0: (Example)
	// This is an example of a typical lighting schedule (Lights on 08:30 - 19:00 w. 30 minutes of sunrise / sunset added)
	// using linear fading on pin 10.
	
	//int channelNo = 0;
	//int pin = 10;
	//Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);
	//Channels[channelNo].AddPoint(8, 0, 0);
	//Channels[channelNo].AddPoint(8, 30, 255);
	//Channels[channelNo].AddPoint(19, 0, 255);
	//Channels[channelNo].AddPoint(19, 30, 0);

  //De originele Controller software geeft max. 80% helderheid, daarom onderstaande aanpassingen.
  // 204 is de Maximale Intensiteit i.p.v. 255
  //       Off=0
  //      10%=20
  //      25%=51
  //     50%=102
  //     75%=153
  //    100%=204
  
  	
	// Channel 0:
	int channelNo = 0;	// Currently editing channel 0
	int pin = 9;		// Channel 0 uses pin 9, wit-rode balk
	Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);	// Initialize channel and choose FadeMode
	Channels[channelNo].AddPoint(8, 0, 0);	// Add Point (can also use decimal values ranging from 0 to 1 if you prefer)
	Channels[channelNo].AddPoint(8, 30, 25);
	Channels[channelNo].AddPoint(9, 0, 76);
	Channels[channelNo].AddPoint(9 , 30, 255);
	Channels[channelNo].AddPoint(18, 0, 76);
  Channels[channelNo].AddPoint(20, 0, 25);
  Channels[channelNo].AddPoint(21, 0, 10);
  Channels[channelNo].AddPoint(23, 0, 0);
  
  
  
	
// Channel 1:
  channelNo = 1;  // Currently editing channel 1
  pin = 10;   // Channel 1 uses pin 10, wit-blauwe balk
  Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);
  Channels[channelNo].AddPoint(8, 0, 0);
  Channels[channelNo].AddPoint(9, 30, 25);
  Channels[channelNo].AddPoint(10, 0, 127);
  Channels[channelNo].AddPoint(10, 30, 255);
  Channels[channelNo].AddPoint(20, 30, 127);
  Channels[channelNo].AddPoint(21, 30, 76);
  Channels[channelNo].AddPoint(22, 0, 25);
  Channels[channelNo].AddPoint(23, 0, 0);
  
  

  // Channel 2:
  channelNo = 2;  // Currently editing channel 2
  pin = 11;   // Channel 2 uses pin 11, witte balk
  Channels[channelNo] = Channel(pin, MaxPoints, fademode_linear, Points[channelNo]);
  Channels[channelNo].AddPoint(8, 0, 0);
  Channels[channelNo].AddPoint(10, 00, 127);
  Channels[channelNo].AddPoint(10, 30, 255);
  Channels[channelNo].AddPoint(17, 30, 127);
  Channels[channelNo].AddPoint(18, 00, 0);
  
  
  
}

// ----------------------- Functions -----------------------
long lastUpdateTime = 0;

// Update light intensity values
 void UpdateLights(DateTime CurrentTime)
{
	long now = Seconds(CurrentTime.hour(), CurrentTime.minute(), CurrentTime.second());	// Convert current time to seconds since midnight
	if(now != lastUpdateTime)  	// Perform update only if there is a perceivable change in time (no point wasting clock cycles otherwise)
	{
		for(int channel = 0; channel < MaxChannels; channel++)    		// For each Channel
		{




    
			analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now));	// Get updated light intensity and write value to pin (update is performed when reading value)


 //Bereken  het percentage output gebasserd op de huidige licht intensiteit.
   { 
   int channel=0;
   
   float intensityNow=Channels[channel].GetLightIntensityInt(now);
   float maxIntensity=255;
   float a=intensityNow/maxIntensity;
   float currentPercent=a*100;
      
   lcd.setCursor(0,1);
   lcd.print(int(currentPercent));                          //Print het licht intensiteits percentage (niet nauwkeurig) afgerond van channel 0.
   }
   {
   int channel=1;
     
   float intensityNow=Channels[channel].GetLightIntensityInt(now);
   float maxIntensity=255;
   float a=intensityNow/maxIntensity;
   float currentPercent=a*100;   
   
   lcd.setCursor(0,2);
   lcd.print(int(currentPercent));                         //Print het licht intensiteits percentage (niet nauwkeurig) afgerond van channel 1.
   }
   {
   int channel=2;

   float intensityNow=Channels[channel].GetLightIntensityInt(now);
   float maxIntensity=255;
   float a=intensityNow/maxIntensity;
   float currentPercent=a*100; 
   
   lcd.setCursor(0,3);
   lcd.print(int(currentPercent));                       //Print het licht intensiteits percentage (niet nauwkeurig) afgerond van channel 2.        
   }

      
	}
 }
	lastUpdateTime = now;
}


// Convert HH:mm:ss -> Seconds since midnight
long Seconds(int hours, int minutes, int seconds) {
	return ((long)hours * 60 * 60) + (minutes * 60) + seconds ;
}

// ----------------------- Setup -----------------------
void setup() {
  //Activeer LCD module
  
  lcd.begin (20,4);   //voor een 20x4 LCD module
  lcd.setBacklightPin(3,POSITIVE);
  lcd.setBacklight(HIGH);     //achtergrondverlichting LCD aan.

  Serial.begin(9600);

  delay(1000); // wacht to de Serial monitor geopend wordt.

  if (! rtc.begin()) {
    Serial.println("Kan de RTC niet vinden");
    while (1);
  }

  if (rtc.lostPower()) {
    Serial.println("RTC zonder stroom geweest, nu op tijd zetten!");
    // De volgende regel zet de RTC op de datum en tijd toen de sketch was gecompileerd.
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // Deze regel zet de RTC op een bepaalde datum en tijd, bijvoorbeeld: 
    // Januari 21e, 2014 op 3 uur na de middag zou je zo in moeten voeren:
    // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }
{
  //De % tekens en de (led-)balknamen worden op de LCD scherm gezet.
  
  lcd.setCursor(3,1);
  lcd.print("%");
  lcd.setCursor(3,2);
  lcd.print("%");
  lcd.setCursor(3,3);
  lcd.print("%");
  lcd.setCursor (5,1);
  lcd.print("Wit-rode balk");  
  lcd.setCursor(5,2);
  lcd.print("Wit-blauwe balk");
  lcd.setCursor(5,3);
  lcd.print("Witte balk");
}

  
	// Initialize channel schedules
	InitializeChannels(MaxChannels);
	
	// Clock
	Wire.begin();
	rtc.begin();
	//RTC.adjust(DateTime(__DATE__, __TIME__));  // Set RTC time to sketch compilation time, only use for 1 (ONE) run. Will reset time at each device reset!
}

// ----------------------- Loop -----------------------
void loop() {
	// Get current time
	
  DateTime now=rtc.now();

   //Print dagdatum, maand en jaar.
    lcd.home();                                                                            //zet de cursor op de eerste kolom, op de eerste rij.
    if (now.day() <10)
    {
     lcd.print("0");                                                                       //zet een nul voor een enkel cijfer
    }
    
    lcd.print(now.day());
    lcd.print('-');
    if (now.month()<10)
    {
      lcd.print("0");                                                                     //zet een nul voor een enkel cijfer
    }
    lcd.print(now.month());
    lcd.print('-');
    lcd.print(now.year());
    lcd.print("  ");
    
    //Print de tijd in uren, minuten en seconden
    if (now.hour()<10)
    {
      lcd.print("0");                                                                   //zet een nul voor een enkel cijfer
    }
    lcd.print(now.hour());
    lcd.print(':');
    if (now.minute()<10)
    {
      lcd.print("0");                                                                  //zet een nul voor een enkel cijfer
    }
    lcd.print(now.minute());
    lcd.print(':');
    if (now.second()<10)
    {
      lcd.print("0");                                                                //zet een nul voor een enkel cijfer
    }
    lcd.print(now.second());

    
 

// Update lights
	UpdateLights(rtc. now());
  


 

}

[Dries Profiel Privébericht]

Ben, kijk eens goed naar mijn code:

for(int channel = 0; channel < MaxChannels; channel++) // For each Channel
{
analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now)); // Get updated light intensity and write value to pin (update is performed when reading value)
float intensityblauw = Channels[0].GetLightIntensityInt(now);
float maxIntensityblauw = 255;
float b = intensityblauw / maxIntensityblauw;
float currentPercentblauw = b * 100;
dtostrf(currentPercentblauw,5,2,blauw);



}
for(int channel = 1; channel < MaxChannels; channel++)
{
analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now));
float roodwaarde = Channels[1].GetLightIntensityInt(now);
float maxIntensityrood = 255;
float r = roodwaarde / maxIntensityrood;
float currentPercentrood = r * 100;
dtostrf(currentPercentrood,5,2,rood);


}
for(int channel = 2; channel < MaxChannels; channel++)
{
analogWrite(Channels[channel].GetPin(), Channels[channel].GetLightIntensityInt(now));
float groenwaarde = Channels[2].GetLightIntensityInt(now);
float maxIntensitygroen = 255;
float g = groenwaarde / maxIntensitygroen;
float currentPercentgroen = g * 100;
dtostrf(currentPercentgroen,5,2,groen);

}

je moet per kanaal het percentage gaan uittellen, ik zie dit niet in je code staan, btw ik ben zeker niet de Arduino specialist maar misschien steek je best het lcd gedeelte dat nu in je loop staat, in een functie en deze oproepen in je loop functie, ook opletten met het gebruik van delay's want dit kan je programma in de war sturen.

[shooter Profiel Privébericht]

je gebruikt now als variabele en als functie
de analogwrite staat aan het begin en er wordt ook helemaal niet berekentwelke tijd al voorbij is.
je zult dus een getal uit moeten rekenen dat tussen de starttijd en de eindtijd ligt, en dan met die 'tijd'een waarde uitrekenen welke de led aan moet zijn.
maar ook dat moet van de beginhelderheid naar de eindhelderheid is.

[benvo Profiel Privébericht]

@Shooter; met dat analogWrite regeltje ben ik al aan het schuiven geweest, het schijnt toch echt hier te horen, ik krijg het elders ook niet werkend. Wordt het getal tussen start en eindtijd niet berekend (in seconden) in de regel die begint met long now? De eerste maker zet hier als commentaar, vrij vertaald, "Converteert de huidige tijd naar seconden vanaf middernacht". Trouwens ik moet wel zeggen dat ik de sketch steeds beter begrijp maar er zitten nog wel "gaten in dat begrip. Waar de "rare" getallen vandaan komen is niet duidelijk. Het programma doet, op zich, trouwens wel precies wat ik zocht!

@Dries,

Je code heb ik goed bekeken, Dries. Jij hebt eigenlijk hetzelfde in de code staan als ik met de toevoeging van de analogWrite regel. Iets wat ik trouwens wel ook heb geprobeerd voor elk door mij gebruikt channel. Maar dat maakte geen verschil.Wat ik niet snap dat je een for lus gebruikt die, in jou geval vier keer over elk kanaal loopt, daar waar ik meteen het juiste kanaal telkens middels een int aangeef. Hieronder het voorbeeld met een "invulling" van de formules.

Alle helderheden worden op alle kanalen goed uitgevoerd. Helaas komt de waarden die op mijn LCD scherm niet overeen met hetgeen er uitgevoerd wordt.

Op het moment dat ik dit schrijf is het 21:15 uur.

Op channel 1 staat nu een lichtwaarde ingevoerd van 127 (ongeveer 50% lichtsterkte)
De led brand ook zo ongeveer op 50%, juist dus.
De waarde die ik op mijn scherm zie is 30%

Nu even naar het stukje sketch wat e.e.a. op het scherm zou moeten zetten:

int channel=1;

float intensityNow=Channels[channel].GetLightIntensityInt(now);
float maxIntensity=255;
float a=intensityNow/maxIntensity;
float currentPercent=a*100;

lcd.setCursor(0,2);
lcd.print(int(currentPercent));

}

Als ik dit goed interpreteer en “vertaal” staat er:

int channel=1

float intensityNow=Channels [waarde 0].127;
Float maxIntensiteit=255;
float a=0.127/255
float current=0.00049*100

lcd.setCursor(0,2);
lcd.print(49);

Dus op mijn LCD scherm zou een waarde van 49% moeten komen wat dan ook zou kloppen.

De vraag is dus; waar komt die 30% waarde die in werkelijkheid afgedrukt wordt dan vandaan?


Dank jullie wel voor je reacties!

Groet,
Ben.

[benvo Profiel Privébericht]

Een reactie op mijn eigen voorgaande bericht. Dat de waarden op mijn LCD scherm niet juist zijn heeft denkelijk te maken met de afronding. Deze is onnauwkeurig, er wordt telkens een integer genomen van LightIntensity. Daarna een afronding van de afronding etc. etc. Zo stond rond 9:30 uur channel 0 op 98%. Eigenlijk al de eerste onnauwkeurigheid. Zou 100% moeten zijn. Nu, het is 14:25 uur staat het LCD scherm al op 59%. Dat is dus te gek. De oplossing zou dus moeten zijn een nauwkeuriger verwerking van het af te drukken eindresultaat, "currentPercent". Mochten jullie denken dat deze gedachten gang fout is dan hoor ik dit natuurlijk graag!


Groet,
Ben.

[nicoverduin Profiel PrivéberichtWebsite]

Je redeneringen kloppen al sowieso niet in je vorige post. En daarmee ook je uitwerkingen niet. het is bijv. geen 0.127 maar 127. Het is een int en geen float die je binnenkrijgt. anders was het 0. Ik zou om te beginnen eerst de waardes die je binnenkrijgt ff op de serial zetten om de juiste berekening te maken voordat je de verkeerde conclusies trekt.