Arduino Nieuw

Hallo!

Ik ben volledig nieuw met het gebruik van Arduino en het programmeren hiervan. Zojuist mijn eerste Arduino besteld en wil hier mee aan de slag.

Wat ik wil gaan maken is een luikje wat na een bepaalde tijd open gaat, dan voor een bepaalde tijd open staat en dan weer dicht gaat.

Wil hieronder graag mijn idee neerzetten en hoop dat jullie me qua codering op de goede weg kunnen helpen....

LuikOpen = //Tijd dat het luikje open gaat 09:30
LuikDicht = //Tijd dat het luikje dicht gaat 19:30
LuikOpenDoen = //Tijd die nodig is voor de motor om het luik helemaal open te doen
LuikDichtDoen = //Tijd die nodig is voor de motor om het luik helemaal dicht te doen

//Omdat ik niet over een RTC beschik denk ik dat ik dit met behulp van timers dit op zou kunnen lossen

SecondenTussenOpenDicht = //Berekening voor het aantal seconden tussen tijd open en dicht
SecondenTussenDichtOpen = //Berekening voor het aantal seconden tussen tijd dicht en open

//Inschakelen Arduino + Programma (Dit moet nu de eerste keer op de LuikOpen tijd) (Dit gebeurd handmatig door spanning op de arduino te zetten)

//Start Functie Luik Open Doen


//Functie Luik Open Doen
//Start Timer Luik Dicht (SecondenTussenOpenDicht)
//Geef signaal naar de motor om het luik te openen voor LuikOpenDoen aantal seconden

//Functie Luik Dicht Doen
//Start Timer Luik Open Doen (SecondenTussenDichtOpen)
//Geef signaal naar de motor om het luik dicht te doen voor LuikDichtDoen seconden (zelfde motor andersom lopen)

Dit is een beetje wat ik in gedachte had.

Eventueel wil ik dit dan later uitbreiden met een RTC als dit nodig blijkt te zijn. En eventueel met een magneetswitch of iets dergelijks om te kijken of het luik helemaal open is, maar dit hoeft voorlopig nog niet omdat ik deze onderdelen ook nog niet heb.

Alvast heel erg bedankt voor de geboden hulp!

Zeker last van de vossen? Dat hebben die andere studenten ook altijd.....

nicoverduin: Zeker last van de vossen? Dat hebben die andere studenten ook altijd.....

Hallo Nico,

Bedankt voor je reactie. Helaas 2x mis ;) Ben geen student en heb geen last van vossen.

Zou je me ook wat op weg kunnen helpen met het maken van de Sketch? Heb al een beetje gelezen over het zetten van constante en variabele, maar vooral de berekening is wat lastiger voor me.

Denk dat ik de bovenste vaste gegevens allemaal als constante kan wegschrijven?

Hoi bierens42, welkom.

het woord constante heeft dezelfde betekenis als vaste gegevens. Dus ja, als het gegevens zijn die niet zullen veranderen dan wel.

Je zult al veel van je vragen kunnen beantwoorden als je de vastgepinde onderwerpen hier in het Nederlandstalige deel eens doorneemt.

Veel plezier !

Bedankt alvast voor de tip, ik ben wat gaan lezen en proberen en heb nu onderstaande code. Ik weet helaas nog niet zo goed hoe ik de berekening tussen de uren het beste kan doen, hopelijk hebben jullie hier een idee over. Ook weet ik nog niet zo goed hoe ik het beste een timer start die na afloop een functie oproept.

const int LuikOpen = 0930; //Tijd dat het luikje open gaat 09:30
const int LuikDicht = 1930; //Tijd dat het luikje dicht gaat 19:30
const int LuikOpenDoen = 20; //Tijd die nodig is voor de motor om het luik helemaal open te doen
const int LuikDichtDoen = 20; //Tijd die nodig is voor de motor om het luik helemaal dicht te doen
const int MotorPin1 = 5;
const int MotorPin2 = 6;

//Omdat ik niet over een RTC beschik denk ik dat ik dit met behulp van timers dit op zou kunnen lossen

SecondenTussenOpenDicht = (LuikDicht-LuikOpen)/100 //Berekening voor het aantal seconden tussen tijd open en dicht (1930-930=1000 1000/100= 10uur = 36000 seconden)
SecondenTussenDichtOpen = 86400-SecondenTussenOpenDicht //Berekening voor het aantal seconden tussen tijd dicht en open (24 uur = 86400 seconden 86400-36000= 50400 seconden)

//Inschakelen Arduino + Programma (Dit moet nu de eerste keer op de LuikOpen tijd) (Dit gebeurd handmatig door spanning op de arduino te zetten)

//Start Functie Luik Open Doen
OpenLuik();

//Functie Luik Open Doen
//Geef signaal naar de motor om het luik te openen voor LuikOpenDoen aantal seconden
void OpenLuik(void) {
  //timer starten om luik dicht te doen SecondenTussenOpenDicht
  digitalWrite(MotorPin1, LOW);
  digitalWrite(MotorPin2, HIGH);
  //timer LuikOpenDoen, na deze timer alles LOW zetten
  digitalWrite(MotorPin1, LOW);
  digitalWrite(MotorPin2, LOW);
}

//Functie Luik Dicht Doen
//Geef signaal naar de motor om het luik dicht te doen voor LuikDichtDoen seconden (zelfde motor andersom lopen)
void DichtLuik(void){
  //timer starten om luik open te doen SecondenTussenDichtOpen
  digitalWrite(MotorPin1, HIGH);
  digitalWrite(MotorPin2, LOW);
  //timer LuikDichtDoen, na deze timer alles LOW zetten
  digitalWrite(MotorPin1, LOW);
  digitalWrite(MotorPin2, LOW);
}

Hoi.

Ik zou het nog geen code noemen, eerder een concept.

En ik zou eens gaan nadenken over de relatie tussen het getal 20 en het getal 1930 in jouw concept.

MAS3: Hoi.

Ik zou het nog geen code noemen, eerder een concept.

En ik zou eens gaan nadenken over de relatie tussen het getal 20 en het getal 1930 in jouw concept.

Je bedoelt hiermee dat 1930 een tijd is en 20 is een getal in seconden? Ik vergeet dan dus ook bij SecondenTussenOpenDicht het aantal uren te delen door 3600? Of is er een goede/betere manier om met tijden te rekenen?

ik zou me eens verdiepen in het gebruik van de time library in combinatie met een real time clock. Dat zal je een hoop miserie besparen. Maar misschien eerst een paar simpele voorbeeldsketches uit de Arduino IDE doorgronden om wat elementaire basiskennis op te bouwen. Die zal goed van pas komen voor je project. Succes.

Inderdaad, je maakt het jezelf veel gemakkelijker als je met dezelfde grootheden werkt.

En ik heb al vele malen geroepen (maar nog niet direct tegen jou) wat ArdLab_Gent net ook al riep, dat je beter eerst eens wat van de voorbeelden doorneemt. En dat is dan niet even overheen lezen, maar er werkelijk mee aan de slag gaan. Dus de micro projectjes waar die uit bestaan echt maken en er dingen in veranderen. En dan gaan uitzoeken waarom dat niet doet wat je dacht dat die verandering zou doen; want dat is leuk en eenvoudig leren.

ArdLab_Gent: ik zou me eens verdiepen in het gebruik van de time library in combinatie met een real time clock. Dat zal je een hoop miserie besparen. Maar misschien eerst een paar simpele voorbeeldsketches uit de Arduino IDE doorgronden om wat elementaire basiskennis op te bouwen. Die zal goed van pas komen voor je project. Succes.

Beschik helaas nog niet over een RTC, daarom probeer ik het op te lossen met timers. Heb al gelezen dat dit over lange tijd niet nauwkeurig is. Maar omdat ik maar maximaal een aantal uurtjes nodig heb dacht ik dat dit niet zo'n probleem zou zijn.

MAS3: Inderdaad, je maakt het jezelf veel gemakkelijker als je met dezelfde grootheden werkt.

En ik heb al vele malen geroepen (maar nog niet direct tegen jou) wat ArdLab_Gent net ook al riep, dat je beter eerst eens wat van de voorbeelden doorneemt. En dat is dan niet even overheen lezen, maar er werkelijk mee aan de slag gaan. Dus de micro projectjes waar die uit bestaan echt maken en er dingen in veranderen. En dan gaan uitzoeken waarom dat niet doet wat je dacht dat die verandering zou doen; want dat is leuk en eenvoudig leren.

Heb al wel wat voorbeelden doorgelezen, maar kan ze helaas nog niet testen omdat de Arduino nog niet binnen is. Verder hoef ik (zeker voorlopig) niet de hele programmeertaal te kennen/begrijpen, maar snap dat je hier niet onderuit komt als je zelf wat wil programmeren.

Ik hoop dus eigenlijk dat jullie mij wat functies kunnen geven die ik zou kunnen gebruiken. Ik heb bijvoorbeeld deze functie gevonden om de secondes tussen 2 tijden uit te rekenen, maar kan niet zo goed vinden hoe ik daar precies de tijden in zet.

//double difftime(time_t end, time_t start);
double difftime(19:30,09:30)

Ook zou ik graag wat meer weten over de 'timers', maar kan hierin niet direct een goede uitleg vinden.

Hopelijk kunnen jullie mij wat op weg helpen met deze 2 functies?

Een hardware timer is geen functie zoals we die hier graag benoemen in software.

Je hebt nu 4 keer een antwoord van mij gezien, plus een (indirecte) verwijzing naar een onderwerp dat hier in het Nederlandstalige deel staat. In al mijn antwoorden kaart ik aan wat jij een timer noemt (en dat is ook niet geheel onterecht), want ik heb er iets over in mijn handtekening staan. Dus lees ook mijn handtekening hier onder, en neem m ter harte.

Ben ondertussen ook echt met de video tutorials bezig.

Zou graag alleen 2 dingen duidelijk willen hebben nl.:

  • Denk nu dat ik niet over een timer moet praten, maar dat ik de functie delay() moet gebruiken. Dit houdt in dat ik mijn SecondenTussenOpenDicht,SecondenTussenDichtOpen,LuikOpenDoen,LuikDichtDoen om zal moeten zetten naar ms en deze op de juiste plaats in de code zal moeten toevoegen, correct?
  • Is de double difftime() de juiste functie om het aantal seconden tussen 2 tijden te berekenen, of is hier nog een andere (betere) functie voor? Of bestaat er geen goede functie en moet ik dit op een andere manier oplossen?

Gebruik van een RTC is echt een stuk simpeler, maar zonder kan het ook door millis() te gebruiken. en dus 3600000 gebruiken per uur. Ga uit van een starttijd die altijd hetzelfde is en bijv 8 uur smorgen. als je die millis() weer opvrgaad kunje na 3600000+1800000 dan is het dus 9.30 enz.

bierens42: Beschik helaas nog niet over een RTC, daarom probeer ik het op te lossen met timers. Heb al gelezen dat dit over lange tijd niet nauwkeurig is. Maar omdat ik maar maximaal een aantal uurtjes nodig heb dacht ik dat dit niet zo'n probleem zou zijn.

Hangt er van af wat je met "over lange tijd" bedoelt maar de interne Arduino klok is nog veel minder nauwkeurig. Erger nog dat is de onnauwkeurige interne Arduino tijd veel meer impact heeft op je project dan je denkt. Ik veronderstel dat je de Arduino doorlopend wil laten werken, en om 19:30 het luik wil laten openen. Na enkele dagen onafgebroken werken (en dat is dus wel een lange tijd) zal je zien dat je Arduino tijd afwijkt van de juiste tijd, zonder nauwkeurige externe tijdsbron valt daar weinig tegen te doen. Het luik zal dus wel voor de juiste duur openen (want dat is een korte korte tijd) maar helaas op een langzaam steeds meer afwijkend moment. De afwijking is voor een stuk vast en voor een stuk temperatuurafhankelijk, dus moeilijk zomaar te compenseren.

Je kan perfect iets bestuderen zonder het te bezitten, het internet maakt dat snel goedkoop en gemakkelijk.

Nogmaals succes met je project.

ArdLab_Gent bedankt voor de reactie.

Het gaat me eigenlijk niet zo zeer om die tijd van 19:30 maar om de tijd tussen de 2 opgegeven tijden. Hier zou ik dan een timer of delay of hoe ik dat dan op zou kunnen lossen van het aantal seconden tussen willen zetten. Bijvoorbeeld delay(1000000). Of zou hier dan ook veel afwijking in zitten?

Later als ik een RTC bezit en wat verder ben met de programmeertaal zal ik gaan kijken naar de verwerking van een RTC.

's ochtends rond 09:30 gaat het luik openen, eerste keer dat ik hem start

void Loop {
   LuikOpenDoen(); //Dit zou dus rond 09:30 zijn
   delay(36000000); //eventueel -20000 omdat de motor 20 seconden draait en daarna het programma pas verder gaat, of niet?
   LuikDichtDicht(); //Dit zou dus rond 19:30 zijn
   delay(50400000); //eventueel -20000 omdat de motor 20 seconden draait en daarna het programma pas verder gaat denk ik?
}

void LuikOpenDoen(void) {
Motor aan
delay(20000); Het luik openen duurt 20 seconden
Motor uit
}

void LuikDichtDoen(void) {
Motor aan
delay(20000); Luik dicht duurt 20 seconden
Motor uit
}

Hopelijk begrijp je de bedoeling een beetje. Waar het me vooral om gaat nu is of en hoe ik het aantal milliseconden tussen de 2 tijden kan berekenen en of de werking van delay() hier ook doet wat ik er van verwacht.

Ik begrijp de bedoeling een beetje, maak je daar geen zorgen over, helaas denk ik dat jij de bedoeling niet begrijpt van de reacties.

Als je dit project tot een goed einde wil brengen en onmiddellijk op de best mogelijke manier wil starten dan is er 1 sketch (blink_without_delay) die je grondig moet bekijken, ontleden, laten doordringen, perfect begrijpen en kunnen aanpassen zodat die exact doet wat je er van verwacht.

Eens je die sketch volledig beheerst zal je zien hoe dicht je bij de oplossing staat als je dat samen met de Time library combineert. Je gebruikt de aangepaste versie van de blink_without_delay schets om de openingsduur van het luik in te stellen, de Time library om het moment te bepalen waarop dat moet gebeuren.

Zolang je delay() wil gebruiken om dit op te lossen komt het nooit goed.

Ok, duidelijk :) Delay overboord dan!

Dan ga ik me toch maar eens focussen op de blink_without_delay sketch

Led aan doen = luik openen Led uit doen = luik sluiten

Ok, maar dan krijg ik dus een hele grote interval op mijn millis (10 uur in dit geval tussen open en dicht)? Het aansturen van de motor voor bijvoorbeeld 20 seconden, los ik dat ook niet op met delay dan? Want dit pauzeert mijn hele programma dan?

Delay zal dit ook doen, maar het is een bijzonder inefficiënte manier om dit te doen. Je kunt dit zelf testen, en ik raad je aan dat ook te doen. Want dan ben je dus jezelf aan het leren hoe dit soort dingen werkt. Wanneer je het voorbeeld blink iets abstracter bekijkt, zul je zien dat dat ding exact doet wat jij wil. Alleen hang jij dan aan pin 13 nog een relais (of zo) waarmee je je luik bedient, en jij gaat straks met je luik niet 2 standen hebben, maar 4 (dus 2 uitgangen).

Dit is werkelijk exact wat ik gedaan heb toen ik een paar jaar geleden mijn 1e Arduino ontving en daar het weekend mee gevuld heb. Eerst heb ik een LEDje toegevoegd, en zondagavond had ik met 6 LEDjes een cirkel gemaakt waarmee ik via een potmeter kon bepalen of ze linksom of rechtsom moesten oplichten en doven, en hoe snel achter elkaar dat dan moest gebeuren. Zo heb ik destijds dus mijn weekend met veel plezier gevuld, en ongelofelijk veel geleerd.