Over een project waar ik leds op een bepaalt moment aan en uit moeten gaan

Hallo ik ben jarno en ik heb een vraag ik heb een minatuur boederij gemaakt en daar zitten verschilende leds in maar ik wil graag als dag geen 24 uur maar 24 minuten en in die 24 minuten zou ik leds uit en wwer aan zetten maar de delay(); functie werkt daar niet voor en ik heb alles geprobeert maar het lukt nog niet echt heeft iemand tips om een 24 minuten klok temaken en een functie waarbij ik de leds kan aansturen

Vriendelijke groet jarno

hoi,
je zou eerder ook wat meer info moeten geven zodat de mensen hier jou verder kunnen helpen.
zover ik begrijp wil je dat je miniatuur boerderij in 24min zijn dag cyclus afrond. (weet niet of er verschillende lampen aan/uit gaan of enkel aan en na 24min terug uit)

  • is het de bedoeling dat het spel om de 24min opnieuw start ? of gewoon 1x 24 min afspelen ?
  • wanneer begint jouw "24min cyclus dag" dan ? als je op een knop drukt of aanzet ?

in ieder geval, zoals je het ondervonden hebt, zal dit met delay niet zo goed werken. je zou hiervoor best de millis functie gebruiken.

je kan best je huidige opstelling die je al gemaakt hebt eens posten hier ( wel op de juiste manier "</>" zodat het duidelijk is voor anderen.)

Hallo ja ik wil dat het elke 24 minuten opnieuw en ik wil dat hij de hele tijd aanstaat net zo lang tot ik de voeding er af haal

Dit zijn de foto's
Ik hoop dat jullie het beter begrijpen zo en anders hoor ik het wel

Probeer onderstaand programma te begrijpen. Het programma maakt gebruik van millis() in plaats van delay() en een model dag is 1440.000 milliseconden.

// model tijden
const uint32_t oneMinute = 1000UL;
const uint32_t oneHour = 60000UL;
const uint32_t oneDay = 1440000UL;

// led interval in model minuten
const uint32_t ledInterval = 5UL * oneMinute;

// ingebouwde led
const uint8_t pinLed = LED_BUILTIN;

void setup()
{
  Serial.begin(115200);
  pinMode(pinLed, OUTPUT);
  digitalWrite(pinLed, LOW);
}

void loop()
{
  // middernacht
  static uint32_t midnight = millis();

  // start tijd voor een delay
  static uint32_t ledDelayStarttime;

  // test voor nieuwe dag
  if (millis() - midnight >= oneDay)
  {
    midnight = millis();
    Serial.println(F("Een dag voorbij"));
  }

  // lamp aan/uit iedere N model minuten
  if (millis() - ledDelayStarttime >= ledInterval)
  {
    ledDelayStarttime = millis();
    digitalWrite(pinLed, !digitalRead(pinLed));
    Serial.print(F("Led is "));
    Serial.println(digitalRead(pinLed) == LOW ? "uit" : "aan");
  }
}

Je kunt di uitbreiden met meerdere led pinnen, led intervallen en meerdere ledDelayStarttimes. Dat is de volgende stap en je kunt gebruik maken van structs om alle gerelateerde informatie voor een (1) LED bij elkaar te houden. En vervolgens een array van deze structs.

1 Like

hallo sterretje
ik had nu bedacht om 3 leds op een breadbortje te plaatsen en daar op uit te probeeren en daar na meerdere led op aan te sluiten is die 1440000UL 24 minuten en zou je meschien een beetje meer comentaar neer willen zetten somige dingen begrijp ik nog niet helemaal

vriendelijke groet jarno


Hier bij ee foto hoe ik het nu wil testen en daarna ga ik het in mijn boederij zettenen

dit snap ik nu maar ik wil hem s'avonds en s'morgens de lamp aan avond 6 tot 10 en ochten 5 tot 8 in millis dan bij voorbeeld dan ik heb je code uitgeprobeert op een lampje in het breadboard en hij knippert nu maar ik heb wel een stuk of 15 lampjes dus hoe moet ik dat dan doen

Welk bord/processor gebruik je?

Allemaal afhankelijk hoe je het wil hebben en het verbruik van die lampjes/leds. Alles te gelijk aan? 1 uitgang en een mosfet die een relais stuurt. Een voldoende stevige mosfet kan ook. Wil je apart gaan sturen, dan heb je per lampje/led een uitgang nodig. Voor leds kan je een BC547 transistor gebruiken (met de nodige weerstanden) of ook weer een mosfet. Haal zo weinig mogelijk stroom uit je processor. Heb je te weinig uitgangen, dan kan een shiftregister uitkomst bieden.

Je kan op vele manieren naar Parijs rijden. Ook hier zijn meerdere oplossingen mogelijk. Elk met zijn voor en nadelen.

Wil je om een bepaald uur in en uitschakelen, dan gaat je processor toch enige kennis moeten hebben van uur en tijd. Voor ESP32/ESP8266 is dat eenvoudig te maken met WiFi en NTP. Voor een ATmega is dat het eenvoudigste met een DS3231 (los SMD bijna nergens meer te vinden) of de minder nauwkeurige DS1307, die ook nog een horloge kristal nodig heeft.

Om het allemaal netjes te houden (en voor jou waarschijnlijk gecompliceerder :wink:), gaan we arrays van structs gebruiken.

Stel je een ladenkast voor. Iedere lade heeft een nummer (de Arduino pin) op de voorkant en heeft een aantal rijen (van voor naar achter) met vakjes (van links naar rechts).

Er zijn twee vakjes in iedere rij, de tijd dat een LED aan moet en de tijd dat dezelfde LED uit moet. Je kunt een rij nu 'vertalen' naar een struct.

struct TIMING
{
  uint32_t timeOn;
  uint32_t timeOff;
};

En je kunt nu een array maken die alle aan/uit tijden voor een (1) LED bevat; dat zijn dus een aantal rijen in een lade). Onderstaand geeft aan dat een LED om 5 in de morgen wordt ingeschakeld, uitgeschakeld om 8 in de morgen, ingeschakeld om 6 in de avond en uitgeschakeld om 8 in de avond.

TIMING t[] = {
  {(5 * oneHour), (8 * oneHour)},
  {(18 * oneHour), (20 * oneHour)}
};

Nu hebben we dus de inhoud van een lade met rijen van aan/uit tijden.

In de volgende stap voegen we het nummer van de pin toe met behulp van een andere struct

struct LIGHTS
{
  const uint8_t pin;
  const TIMING t[4];
};

Voor deze opzet is het aantal aan/uit tijden beperkt tot 4; je kunt het uitbreiden naar behoefte. Er is een betere oplossing als het aantal tijden niet hetzelfde is voor de verschillende LEDs.

Je kunt nu een array van LIGHTS structs maken waar.

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}}},
};

Dit toont een voorbeeld voor 3 LEDs. Het eerste nummer is de pin (8/9/10), wat daarop volgt zijn de aan/uit tijden. In het voorbeeld ben je beperkt to 4 tijd blokken (zoals gezegd kun je dit uitbreiden). Aan/uit tijden die je niet gebruikt zijn ingevuld met {0xFFFFFFFF, 0xFFFFFFFF}; dit kunnen we later gebruiken om deze over te slaan.
Je kunt extra rijen elementen toevoegen aan de lightTiming array; simpel kopieren en plakken en de niewe regel aanpassen.

Onderstaand (onderdeel van de) setup() functie laat zien hoe je door dit alless heen kunt gaan. Het gebruikt twee tellers, een (1) voor de lightTiming array (ltCnt) en een (1) voor de timing array (tCnt) in de lightTiming.

  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.print(F(" output"));
  }

Met een punt kun je de velden in een struct aanspreken. Bv lightTiming[ltCnt].t[tCnt].timeOn.

  1. lightTiming[ltCnt] is een element in het lightTiming array.
  2. t is het veld t (hetgeen een array is) en t[tCnt] is een element in dat array.
  3. timeOn is het veld in t[tCnt].

NUMELEMENTS is een macro die het aantal elementen in een array berekent; het maakt niet uit wat voor type array het is (character, int, float, struct, class, ...). Plaats het volgende boven aan je programma.

#define NUMELEMENTS(x) (sizeof(x) / sizeof(x[0]))

Ik heb midnight veranderd van een lokale statische variabele naar een globale variable (gedeclareerd voor setup()) en die nu in setup() de waarde van millis() gegeven. De code ziet er nu zo uit

#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}}},
};

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

Dit doet nog niet wat je wilt. Daarvoor gaan we een functie schrijven die door alle laden en alle rijen in een lade loopt.

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++)
    {
    }
  }
}

Het gebruik van een for-loop is hier acceptabel omdat er geen delays gebruikt gaan worden die kunnen resulteren in lange vertragingen.

In de binnenste for-loop gaan we de tijden controleren om te zien of voor een bepaalde LED timeAfterMidnight in een gegeven aan/uit blok valt. Indien ja, dan wordt een variable gezet om aan te geven dat de LED aan moet. Er zijn drie situaties

  1. Een tijd blok is leeg (0xFFFFFFFF).
  2. En tijd blok valt in een dag.
  3. Een tijd blok begint voor middernacht maar eindigt na middernacht.
    // 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)
      {
      }
      // (2) aan tijd groter dan uit tijd; bv 23 tot 1
      else
      {
      }
    }

Voor (2) hierboven gebruiken we

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

Om te voorkomen dat de seriele monitor als een idioot gaat scrollen wordt er alleen geprint als er een verandering in de LED zal gaan optreden (van uit naar aan).
De code voor (3) hierboven is practisch hetzelfde; ik laat het aan jou over om het verschil te vinden en te begrijpen in de volledige sketch die later volgt

Zodra we door alle rijen zijn gelopen in een lade weten we of een LED aan of uit moet zijn. We kunnen dat nu gebruiken om te schakelen

    // indien de LED aan moet zijn
    if (lightOn == true)
    {
      // schakel LED aan
      digitalWrite(lightTiming[ltCnt].pin, HIGH);
      // geen debugging
    }
    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);
    }

Deze niewe functie moet je nu vanuit loop() aanroepen

void loop()
{
  // test voor nieuwe dag
  if (millis() - midnight >= oneDay)
  {
    midnight = millis();
    Serial.println(F("Een dag voorbij"));
  }

  // bestuur de LEDs
  lightControl();
}

Onderstaand de volledige sketch. Ik heb het getest met 2.4 minuten voor een dag (in plaats van 24 minuten) en dat lijkt goed te gaan.

#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}}},
};

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

Ik hoop dat deze uitleg duidelijk is. Als je vragen hebt, laat maar horen.

1 Like

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}}},
};
ik snap deze code niet helemaal :face_with_raised_eyebrow:
zou je dat eens willen uitlegen uitgebreid ik begin de rest nu wel te snapen bedankt dat je me nu al zo ver hebt geholpen.

Het is waarschijnlijk duidelijker als je het een beetje splitst over een aantal regels. Onderstaand een lightTiming array met een (1) element (een (1) pin).

LIGHTS lightTiming[] = {
  {8, {{(1 * oneHour), (2 * oneHour)}, {(3 * oneHour), (4 * oneHour)}, {0xFFFFFFFF, 0xFFFFFFFF}, {0xFFFFFFFF, 0xFFFFFFFF}}},
};

Gesplitst over verschillende regels

{
    {
        8,
        {
            {
                (1 * oneHour),
                (2 * oneHour)
            },
            {
                (3 * oneHour),
                (4 * oneHour)
            },
            {
                0xFFFFFFFF,
                0xFFFFFFFF
            },
            {
                0xFFFFFFFF,
                0xFFFFFFFF
            }
        },
    },
};
1 2 3 4 5 beschrijving
{ begin lightTiming array
{ begin lightTiming array element
8 pin
{ begin timing array t[]
{ begin eerste element timing array t[]
(1 * oneHour) timeOn in eerste element timing array
(2 * oneHour) timeOff in eerste element timing array
} einde eerste element timing array
{ begin tweede element timing array t[]
(3 * oneHour) timeOn in inhoud eerste element timing array
(4 * oneHour) timeOff in inhoud eerste element timing array
} einde tweede element timing array
} einde timing array
} einde lightTiming array element
} einde lighTiming array

Commas scheiden elementen van de arrays en velden in een struct.

1 Like

dit begin ik tebegrijpen maar als ik halfen uuren heb hoe moet dat meschien is dit wel heel moelijk als dit niet kan dan snap ik dit wel

Het element in lightTiming voor pin 9 schakelt in om 1 uur in de morgen en uit om 3 uur in de morgen, weer in om 7 minuten over 5 in de morgen en vervolgens uit om 8 uur in de avond. Dus halve uren zullen geen probleem zijn.

1 Like

ik zat er aan te denken om een kachel te maken met een geel en rood led maar die moeten kniperen als de een uit is moet de andere aan gaan zou dsat kunnen in jouw code sory voor daar net dat hat niet mogen gebeuren dat wist ik niet ga ik niet meer doen nogmaals sory :disappointed_relieved:

De huidige code kan dit in principe niet.

Maar ik zou eens kijken naar het programma in antwoord #7 waar gebruik gemaakt wordt van millis() om wat met knipperen te doen. Je kunt een tweede led aansturen door bv deze de omgekeerde waarde te geven van de eerste.

Je kunt met 1 pin de rode en de gele LED tegelijk aansturen als je dat wil.
Je zegt dat wanneer de ene uit gaat, de andere aan moet.
Wat ik nu ga beschrijven werkt niet wanneer ze ook allebei uit moeten kunnen.

Je hebt de gele LED's volgens het plaatje hierboven aangesloten met een rode draad uit de Arduino, dan een weerstand, de LED anode en de kathode aan de min (GND).

Wanneer je een rode LED met de anode via een weerstand aan de 5 volt hangt, en met de kathode aan dezelfde pin als de gele LED, dan gaan ze om de beurt branden.
Zo brandt er dus altijd een van die LEDs.
Wanneer de Arduino een 1 op zijn uitgang heeft, gaat de gele LED aan en is de rode uit.
Zet ie een 0 op die uitgang, dan gaat de gele LED uit, en de rode aan.

Let wel op:
Je hebt het over 15 LED's.
Wanneer die ook allemaal tegelijk aan moeten kunnen, dan is 15 waarschijnlijk teveel voor de maximale stroom die de Arduino door alle uitgangen tegelijk kan verwerken.
Je kunt dat rekken door LED's te gebruiken die hoog efficiënt zijn, vaak hebben die maar 1/10e van de stroom nodig.
Daar moet je dan dus ook de weerstand op aanpassen.
Moet je daar wel naar zoeken natuurlijk.

ik moet eerst mijn lamp 6 uur uit hebben en daarna 3 uur aan en daarna 8 uur uit en 5uur aan en weer 2 uur uit dat snap ik niet heb je een tip

Pin 10 (de laatste regel) heeft een (1) aan/uit blok. Die andere twee hebben ieder twee aan/uit blokken.

Zoek het verschil. Ik heb je ook verteld dat 0xFFFFFFFF gebruikt wordt voor een blok dat niet geimplementeerd is / gebruikt wordt. En ik heb je verteld dat je met de gegeven opzet 4 blokken hebt (per LED) die je een tijd kunt geven.

dat pin 10 eerder stopt

pin tijdblok 1 tijdblok 2 tijdblok 3 tijdblok 4
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}

Kijk eens naar het verschil voor tijdblok 2.

Wat denk je dat er gaat gebeuren als er voor pin 10 een tijd wordt ingevuld in tijdblok 2 (aan tijd en uit tijd) zoals dat voor de andere twee gedaan is? Wat denk je dat er gaat gebeuren als als je daar nu ook nog een aan- en uit tijd invult in tijdblok 3?