hallo ik wil een eigentijd van 24 minuten inplaats van 24 uur om in die tijd lampjes te laten branden
In the English section of the forum you will have to ask your question in English.
You have a complete solution (with explanation) in Over een project waar ik leds op een bepaalt moment aan en uit moeten gaan.
Why do you again post here? Please answer that as cross-posting is against the rules of the forum.
Show us a simple schematic of your project and the code as you currently have it.
Vis os et simpelt skema over dit projekt og koden, som du har den i øjeblikket.
#define NUMELEMENTS(x) (sizeof(x) / sizeof(x[0]))
// model tijden
const uint32_t oneMinute = 1000UL;
const uint32_t oneHour = 60000UL;
const uint32_t oneDay = 1440000UL;
struct TIMING
{
const uint32_t timeOn;
const uint32_t timeOff;
};
struct LIGHTS
{
const uint8_t pin;
const TIMING t[4];
};
LIGHTS lightTiming[] = {
{8, {{(1 * oneHour), (2 * oneHour)}, {(3 * oneHour), (4 * oneHour)}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}}},
{9, {{(1 * oneHour), (3 * oneHour)}, {(5 * oneHour) + (7 * oneMinute), (20 * oneHour)}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}}},
{10, {{(23 * oneHour), (1 * oneHour)}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}}},
{11, {{(2 * oneHour), (4 * oneHour)}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}}},
};
// middernacht
uint32_t midnight;
void setup()
{
Serial.begin(115200);
// toon de configuratie
for (uint8_t ltCnt = 0; ltCnt < NUMELEMENTS(lightTiming); ltCnt++)
{
Serial.print(F("Lade "));
Serial.println(ltCnt);
Serial.print(F("\tPin "));
Serial.println(lightTiming[ltCnt].pin);
Serial.println(F("\tTijden"));
for (uint8_t tCnt = 0; tCnt < NUMELEMENTS(lightTiming[ltCnt].t); tCnt++)
{
if (lightTiming[ltCnt].t[tCnt].timeOn == 0xFFFFFFFF)
{
Serial.println(F("\t\tGeen tijden"));
}
else
{
Serial.print(F("\t\tAan "));
Serial.print(lightTiming[ltCnt].t[tCnt].timeOn);
Serial.print(F("\tUit "));
Serial.println(lightTiming[ltCnt].t[tCnt].timeOff);
}
}
}
// zet pinnen als uitgang
for (uint32_t ltCnt = 0; ltCnt < NUMELEMENTS(lightTiming); ltCnt++)
{
pinMode(lightTiming[ltCnt].pin, OUTPUT);
digitalWrite(lightTiming[ltCnt].pin, LOW);
// debugging
Serial.print(F("Pin "));
Serial.print(lightTiming[ltCnt].pin);
Serial.println(F(" output"));
}
// middernacht
midnight = millis();
}
void loop()
{
// test voor nieuwe dag
if (millis() - midnight >= oneDay)
{
midnight = millis();
Serial.println(F("Een dag voorbij"));
}
lightControl();
}
void lightControl()
{
uint32_t timeAfterMidnight = millis() - midnight;
// loop door alle laden (LEDs)
for (uint8_t ltCnt = 0; ltCnt < NUMELEMENTS(lightTiming); ltCnt++)
{
// bijhouden of LED aan of uit moet; default uit
bool lightOn = false;
// loop door alle lightTimings rijen in een lade
for (uint8_t tCnt = 0; tCnt < NUMELEMENTS(lightTiming[ltCnt].t); tCnt++)
{
// overslaan indien niet gespecificeerd
if (lightTiming[ltCnt].t[tCnt].timeOn == 0xFFFFFFFF)
{
// volgende lightTiming rij in de lade
continue;
}
// controleren of de huidige tijd in een gespecificeerde aan/uit tijd valt
// aan tijd kleiner dan uit tijd
if (lightTiming[ltCnt].t[tCnt].timeOn < lightTiming[ltCnt].t[tCnt].timeOff)
{
if (timeAfterMidnight >= lightTiming[ltCnt].t[tCnt].timeOn && timeAfterMidnight < lightTiming[ltCnt].t[tCnt].timeOff)
{
// debugging
if (digitalRead(lightTiming[ltCnt].pin) == LOW)
{
Serial.print(F("Pin "));
Serial.print(lightTiming[ltCnt].pin);
Serial.print(F(" aan tussen "));
Serial.print(lightTiming[ltCnt].t[tCnt].timeOn);
Serial.print(F(" en "));
Serial.println(lightTiming[ltCnt].t[tCnt].timeOff);
}
// aangeven dat LED moet worden ingeschakeld
lightOn = true;
}
}
// (2) aan tijd groter dan uit tijd; bv 23 tot 1
else
{
if (timeAfterMidnight >= lightTiming[ltCnt].t[tCnt].timeOn || timeAfterMidnight < lightTiming[ltCnt].t[tCnt].timeOff)
{
if (digitalRead(lightTiming[ltCnt].pin) == LOW)
{
// debugging
Serial.print(F("Pin "));
Serial.print(lightTiming[ltCnt].pin);
Serial.print(F(" aan tussen "));
Serial.print(lightTiming[ltCnt].t[tCnt].timeOn);
Serial.print(F(" en "));
Serial.println(lightTiming[ltCnt].t[tCnt].timeOff);
}
// aangeven dat LED moet worden ingeschakeld
lightOn = true;
}
}
}
// indien de LED aan moet zijn
if (lightOn == true)
{
// schakel LED aan
digitalWrite(lightTiming[ltCnt].pin, HIGH);
}
else
{
// debugging
if (digitalRead(lightTiming[ltCnt].pin) == HIGH)
{
Serial.print(F("Pin "));
Serial.print(lightTiming[ltCnt].pin);
Serial.println(F(" uit "));
}
// schakel LED uit
digitalWrite(lightTiming[ltCnt].pin, LOW);
}
}
}
dit is de code @gilshultz en @sterretje maar ik had noch een idee ik wil met een pot meter en een lcd schermpje de leds dimmen naar een bepalde waarde heeft iemand tips
v.g jarno
Please write your messages in English or move your topic to the International category of the forum.
I can move your thread to another category, okay?
oh sorry
i'm jarno i build a farm with an arduino nano and i put about 15 leds on it and i have them controlled with a model clock you see in the sketch and now i would like to be able to dim leds with a potentiometer and can read what time it is and at what percentage the lights are on the lcd, thanks in advance
There are a lot of ways to do what you want, unfortunately for you there are also many ways to wire and control it. Without an annotated schematic I am finished.
Kun je je code uitlijnen (ctrl-t) en plaatsen tussen code tags?
LEDs dimmen doe je met een analogwrite.
uint8_t brightness = 64;
if lightTiming(alles wat er nu achter diditalWrite staat) {
analogwrite(analogPin, brightness);
}
else {
analogWrite(analogPin, 0);
}
En dan in loop() de waarde van brightness aanpassen.
Ik snap nog niet waarom je daarvoor een LCD nodig zou kunnen hebben...
Gewoon een variabele weerstand van + naar -, midden aftakking naar analoge poort en dan uitlezen met analogRead.
Het zou goed kunnen dat je te weinig analoge poorten hebt... ook dat kan opgelost worden, maar dan wordt het ingewikkeld.
Een rotary encoder is stukken handiger dan een potentiometer. Je kan er een range aan koppelen en elke klik heeft een vaste waarde. Draai je sneller dan worden de stappen groter. 2 inputs en eventueel een derde voor de knop. In commerciële toestellen vind je nog amper potmeters. Des te meer rotary encoders.
Voor er kan bepaald worden hoe je het beste kan dimmen moet je toch wat meer info geven over je hardware setup. Gebruik je een relais om je lichten aan te doen, vergeet dan het dimmen. Je relais gaat dat niet appreciëren. Gebruik je lampjes of leds?
Hangt ervan af wat hebt liggen, wat je bereid bent te kopen en of je het aan de gang krijgt...
Een rotary encoder aan de gang krijgen is eenvoudiger als een analog read. Voor ESP ai_esp32_rotary_encoder en voor arduino
Voor de prijs hoef je het ook niet te laten. Een 1k potmeter bij Mouser vanaf 1,12€ excl BTW. Heb je maar 1 waarde. Een rotary encoder vanaf 1,76€ excl BTW. En hier koppel je zoveel waardes aan als je zelf wil. Bij ali gaan ze nog goedkoper zijn.
Voor een neopixel controller gebruik ik 4 rotary encoders. Rood, Groen en blauw voor de kleuren en de 4de als helderheid. Heb je al minstens 4 analoge ingangen nodig + convertietijd van je analogread.
nou ik wil eigelijk geen geld uitgeven en ik gebruik led en waar in mijn code zou ik jouw code kunnen zetten van het dimmen @build_1971
Het is de bedoeling dat jij het werk doet, en wij je helpen als het niet lukt.
Het is niet de bedoeling dat anderen voor jou alle code gaan schrijven...
1 Like
Ik zou beginnen met een separaat project. 1 led, 1 potmeter...
Eerst 1 potmeter uitlezen via Serial.print.
Dan 1 LED harder en zachter laten branden via analogWrite.
Dan aan elkaar knopen.
Dan ga je ter plaatse blijven trappelen. Als je alles wil gaan maken met wat je in je la hebt liggen is het snel ten einde.
Je gebruikt leds, en hoe ga je die aansturen? Rechtstreeks uit je µC? Veel succes. Van 1 zaak ga je snel overtuigd zijn. In elke electronica component zit er rook. Maar ze roken allemaal maar 1 keer. Heel dikwijls zorgen ze er wel voor dat een collega spontaan gaat mee roken. Componenten zijn redelijk sociaal.
Dimmen van LEDs wordt electronisch gedaan door gebruik te maken van PWM. Ik zou eerst eens kijken hoeveel pinnen er op een Nano zitten die PWM kunnen doen in hardware. Als dat minder is dan 15 heb je een probleem dat je mogelijk op een paar manieren kunt oplossen
- Een Arduino gebruiken die genoeg pinnen heeft die PWM kunnen doen.
- PWM implementeren in software in plaats van in hardware.
- Je leds opdelen in groepen en de groepen dimmen; je zult wel wat extra hardware moeten gebruiken zoals weerstanden en transistors.
- Speciaal bordje gebruiken dat je 16 PWM uitgangen geeft en kan worden aangesliten op de Nano via I2C of SPI.
Je andere probleem komt als je ook nog een LCD wilt aansluiten en een potentiometer. Een standaard LCD is 6 of 7 signaal pinnen als ik me niet vergis. Dus dan zit je all op 21 of 22 pinnen hetgeen meer is dan je Nano heeft als pinnen die je als uitgang kunt gebruiken.
Je kunt het aantal pinnen dat gebruikt wordt voor de 15 LEDs reduceren door gebruik te maken van multiplexing.
Je kunt het aantal pinnen dat gebruikt wordt voor de LCD reduceren door een I2C LCD te g.ebruiken
De potentiometer kan op A6 of A7.
Je hebt wat dingen om over na te denken 
De LCD kan ook nog op UART (onder andere NewHaven heeft ze) heb je maar 1 (TX) pen nodig Maar dan komen er weer andere zaken om de hoek kijken. TS heeft dus wat werk.
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.