Vandaag ben ik met een project gestart met een lagswitch.
voor mensen die niet weten wat een lagswitch is hier:meer info
Het doel is dat als je een knop indrukt die aangesloten op de arduino zit het signaal geeft dat het relais open moet gaan voor 'x' seconden.
Het doel is om jezelf vast te laten lopen in een shooter op bijvoorbeeld: ps3/4 en dat je de knop loslaat dat je weer zichtbaar. Bent voor je mede-spelers.
waarom ik de lag-switch met de arduino wil verbinden is dat ik de knop 1 malig in hoef te drukken en bij de arduino de tijd dat het relais open blijft aan kan geven en kan veranderen voor andere games!
Vals spelen dus.
Daar houd ik wel van, maar dan niet als er een wedstrijdelement bij betrokken is.
Als ik het goed begrepen heb, zet je jezelf niet vast, maar juist de anderen.
Die anderen zullen je dus ergens zien hangen (en zouden je aan kunnen vallen), terwijl je in werkelijkheid al verder bent en ze dus vanaf een iets andere positie in de val kan laten lopen.
Niet eerlijk, en uitermate onsportief.
Wellicht leuk om jezelf te oefenen in het maken van de gadget, maar niet erg ethisch om daadwerkelijk te gaan gebruiken.
MAS3 heeft gelijk, je zet jezelf stil voor anderen. Ik vind uitermate vervelend als mensen dat gebruiken, maar het kan je helpen om te 'boosten' (veel punten scoren om sneller level up te halen).
Ik wens je veel succes met je project, en hoop eigenlijk dat je het niet veel gaat gebruiken
Ik ben het ook niet van plan om online te gebruiken maar meer als iets om een snellere reactie-tijd de creëren en die online toe te passen zonder de lag-switch. En om relais uit te testen want dit is mijn eerste project met relais.
Oja en natuurlijk m'n broertje pesten om z'n laptop
een knopje heb je nodig en een relaisbordje (met aparte voeding)
if (knopjepin==LOW){
relaispin=HIGH;
delay(pizza);
}
else{
relaispin=LOW;}
nadeel is natuurlijk wel dat je ook je tegenstanders niet ziet bewegen.
en Online gaan ze snel klagen dat je niet eerlijk bent.
opdracht1: uitschakelen als je in de delay tijd op het knopje duwt (dat werkt met blink without delay)
opdracht2: de tijdsinstelling bepalen door de tijd dat je het knopje vasthoud.
Bestudeer "blink without delay".
Dan leer je hoe je een bepaalde tijd kunt laten verlopen, zonder dat andere handelingen uitgesteld moeten worden.
Houd zo bij dat die knop de door jou gewenste tijd is ingedrukt, en trek daaruit je conclusies.
Daarvoor heb je behalve deze techniek, ook een aantal variabelen nodig.
Je moet bijhouden wat je aan het doen bent.
Goedeavond, ik heb hieronder mijn code tot nu toe bijgevoegd met de vraag of iemand deze code kan checken of het klopt en eventueel uittesten, ik ben nu in spanje en heb geen laptop/pc en heb daarom niet de mogelijkheid om te testen.
Bij voorbaat dank,
Thomas
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
// Variables will change:
int ledState = HIGH; // the current state of the output pin
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
// the following variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 50; // the debounce time; increase if the output flickers
void setup() {
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
// set initial LED state
digitalWrite(ledPin, ledState);
}
void loop() {
// read the state of the switch into a local variable:
int reading = digitalRead(buttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited
// long enough since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
// whatever the reading is at, it's been there for longer
// than the debounce delay, so take it as the actual current state:
// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;
// only toggle the LED if the new button state is HIGH
if (buttonState == HIGH) {
ledState = !ledState;
}
}
}
// set the LED:
digitalWrite(ledPin, ledState);
// save the reading. Next time through the loop,
// it'll be the lastButtonState:
lastButtonState = reading;
while(digitalRead(buttonPin)==LOW);
digitalWrite(ledPin,HIGH);
delay(5000);
digitalWrite(ledPin,LOW);
}
Dit is het onderste stukje van jouw code.
Dat onderste stukje maakt mij duidelijk dat je weliswaar blink without delay hebt toegepast, maar dat je het niet hebt begrepen.
Heb je wel geprobeerd het te begrijpen, of heb je gewoon 2 stukjes code gecombineerd ?
Wat er fout is aan deze code, is dat je eerst met blink without delay probeert om blokkerende code te voorkomen, om vervolgens twee verschillende zwaar blokkerende codes toe te passen.
Ten eerste vertel je aan het einde tegen de controller dat ie 5 seconden lang helemaal niets mag doen.
Alleen mag ie ademen en zijn hartslag laten slaan, en wel voor maar liefst tachtig miljoen hartslagen !
Dat kan nooit de bedoeling zijn.
Ten tweede is er de while instructie.
Daar vertel je dat de controller weer dat ie helemaal niets anders mag doen dan zolang de knop is ingedrukt, telkens maar weer de uitgang HIGH moet maken gedurende die 5 seconden die je nog een keer weggooit.
Daarmee maak je zelfs een nesting blocking code; dubbelop blokkerende code dus.
Als de while niet blokkeert, dan is de delay binnen die while wel aan het blokkeren.
Je kan dat grondig werken noemen, maar ik ben het daar dan niet mee eens.
De while is echt helemaal nergens voor nodig en de delay ook niet.
Maak die delay op dezelfde manier als hoe je de debouncing hebt gedaan (goed dat je dat hebt toegepast).
Het is echt precies hetzelfde, alleen een factor 100 groter.
En gooi de while maar gewoon weg.
In die while haal je buttonPin binnen.
Maar had je die waarde nog niet binnen dan ?
En zelfs al ergens opgeslagen ?
En had je jezelf ook nog niet afgevraagd waarom het eigenlijk nodig is om de uitgang op twee plaatsen in je code aan te sturen (dat doe je nu) ?
Niet nodig, dus weg ermee.
Wel even kijken welke je er het beste uit kunt halen natuurlijk.
Nou nog even kijken wat dat allemaal is met blink without delay.
En de code een beetje bijschaven.
Als je daar niet uitkomt, gewoon even vragen hier.
Wel duidelijk erbij vermelden wat je wel begrijpt (of denkt te begrijpen), en wat niet want dan kan er beter een passend antwoord gegeven worden.
Bedankt voor je uitgebreidde maar leerzame reactie!!
ik ga er naar kijken en als ik het heb begrepen maar nog vragen heb zal ik mijn code weer uploaden!
Dit is de nieuwe code maar kan hem helaas niet uittesten en kijken of hij werkt
Bij deze code moet je de knop wel inhouden maar na 5 seconden springt hij terug
Je hebt het jammer genoeg nog niet begrepen.
Met deze code gooi je het kind met het badwater weg.
Deze code doet mogelijk wel wat je wil, maar het is echt geen goed idee het zo te doen.
De code is nog net zo blokkerend en je gooit nog steeds tachtig miljoen instructies overboord.
Misschien niet erg als dit alles is wat je code moet doen.
Maar netjes is het allerminst.
Waar is de les uit 'blink without delay' gebleven, en waar is de debouncing heen gestuiterd ?
Met deze code hoef je de knop maar een fractie van een seconde in te drukken, om vervolgens 5 seconden lang niets anders meer te kunnen doen.
In zekere zin is dat precies wat je wilde doen, alleen zit de 'lag' hier ineens in je Arduino en geen idee of het ook in je spel terecht zal komen.
De volgende code die je plaatst moet het woord delay hooguit in het //commentaar hebben staan.
Anders krijg je weer een antwoord dat op deze voorgaande antwoorden lijken.
Dat betekent dat je dus met het bovenste gedeelte van je oude code moet verder werken, en het onderste gedeelte bijna helemaal weg mag gooien (je hebt het nu net andersom gedaan).
Laat je niet uit het veld slaan door mijn opmerkingen. maar gebruik ze om verder te komen.
Bijt je erin vast totdat je het te pakken hebt en je weer een stukje bagage voor de toekomst hebt.
Ik heb je berichtje ontvangen.
Ik vind het geen goed idee om voor jou code te gaan schrijven, want ik weet heel zeker dat je er veel meer van opsteekt als je het zelf doet.
Dat gaat dan zelfs nog beter als je dingen eerst niet helemaal goed doet, daar zul je van leren en des te leuker als je het dan uiteindelijk voor mekaar krijgt.
Wat me eerder trouwens niet direct was opgevallen, is dat met die oude code, de LED (of het relais) telkens anders word gezet als er op de knop gedrukt word.
Dus een keer drukken betekent aan.
Loslaten en nog een keer drukken betekent dan uit, enzovoorts.
Dat is volgens mij niet wat je wil.
Als je zelf code schrijft, dan moet je die code later ook weer terug kunnen lezen en dan begrijpen wat er staat.
Als je nog meer net begonnen bent, dan is dat nog een beetje lastig.
Daarom is het aan te raden om //commentaar bij je code te zetten.
Dat staat om die reden ook veelvuldig in de diverse voorbeelden die je vind.
Door dat commentaar is het bovendien eenvoudiger voor iemand anders om te zien of je weet wat de code doet.
Ik wil je best wel wat meer helpen met je code maar ik ga 'm niet voor je schrijven.
Verder heb ik het ook nogal druk, en dus niet de tijd om dat uitgebreid te gaan doen (zie het tijdstip van dit bericht).
Wellicht heb ik later deze week wat tijd om er in te steken, maar ik beloof je niks.
/* Blink without Delay
Turns on and off a light emitting diode (LED) connected to a digital
pin, without using the delay() function. This means that other code
can run at the same time without being interrupted by the LED code.
The circuit:
* LED attached from pin 13 to ground.
* Note: on most Arduinos, there is already an LED on the board
that's attached to pin 13, so no hardware is needed for this example.
created 2005
by David A. Mellis
modified 8 Feb 2010
by Paul Stoffregen
modified 11 Nov 2013
by Scott Fitzgerald
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
*/
// constants won't change. Used here to set a pin number :
const int ledPin = 13; // the number of the LED pin
// Variables will change :
int ledState = LOW; // ledState used to set the LED
// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0; // will store last time LED was updated
// constants won't change :
const long interval = 1000; // interval at which to blink (milliseconds)
void setup() {
// set the digital pin as output:
pinMode(ledPin, OUTPUT);
}
void loop() {
// here is where you'd put code that needs to be running all the time.
// check to see if it's time to blink the LED; that is, if the
// difference between the current time and last time you blinked
// the LED is bigger than the interval at which you want to
// blink the LED.
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
De kern van blink without delay is om een timer te creeren die alleen iets doet als deze is verlopen. Niet dat ik alles ga doorlezen, maar:
a) Wanneer wordt de teller weer gereset?
voorbeeld timer code: starten timer
#define TIJD_DIE_WE_WILLEN 5000 // stel we willen dat de timer 5 seconden loopt
//
// als de timer gezet wordt
//
timer = millis();
in de loop testen of deze is verlopen
//
// eerst kijken of de timer loopt
//
if (timer != 0){
//
// hij loopt dus nu klijken of deze is verlopen
//
if ((millis() - timer) > TIJD_DIE_WE_WILLEN){
//
// de timer is verlopen dus doe wat we moeten doen
//
.................
//
// reset de timer
//
timer = 0;
}
}
