Arduino knop en adafruit 815

Na lang zoeken naar antwoord op mijn vraag op google heb ik het opgegeven.

Ik ben van mening dat oplossing heel simpel moet zijn als je hem ziet, maar goed.

Een arduino uno en een adafruit 815 servo shieldje.
Heb als beginner eerst 2 sketches gemaakt en proberen te begrijpen en dat is gelukt.
Ledje aan met knopje en servos draaien met het shieldje.

Nu wil ik de servo's laten bewegen als ik de knop indruk maar dat ging nog niet zo simpel als ik dacht.

Heb de sketch niet bij de hand staat op andere locatie helaas.

Ik had de pins 4 en 5 waar het shield op aangesloten zit als output ingesteld voor de knop maar toen gebeurde er helemaal niks. Al mijn andere pogingen kon ik niet eens testen omdat het niet eens geschreven kon worden.

Ik hoop dat iemand mijn begrijpt en zegt hoe ik het oplos.

Morgen avond kan ik bij de sketch en zal ik hem uploaden als dat nog nodig is.

Alvast bedankt, henk

dag henk
Welkom op het forum.
Eerst en vooral niet opgeven :slight_smile:
Probeer eerst je oplossing/product/project resultaat zo goed mogelijk te omschrijven. Zoals je het nu omschrijft is het niet te verstaan.
Misschien zit dat al niet snor en dan gaat de rest ook niet.
Probeer daarna je project in stukjes te kappen. Kleine dingen zijn makkelijker dan grote dingen. Dan de dingen samen combineren en je bent waarschijnlijk vertrokken.
Met vriendelijke groet
Jantje

Oke sorry dat het onduidelijk is. Ik zal vanavond de sketch online knallen dat zegt waarschijnlijk al genoeg over de bedoelingen.

Ik heb ze in 2 geknipt ik heb eerst het ledje met druk knop gemaakt (standaard sketch) iets aangepast dat het beter werkt.
En ik heb de standaard test sketch van adafruit shield gedownload en die aangepast naar mijn smaak.

Ik heb dus 2 werkende sketches, nu wil ik het shield dus aansturen met de druk knop.

1 druk op de knop en de servo's gaan in positie.

Denk dat het probleem zit in dat ik het shield niet of verkeerd aanspreek.

Enne opgeven ? Nee dat gaan we niet doen :stuck_out_tongue: ik ben ermee begonnen omdat ik het niet ken en ik een uitdaging wilde. Naar mijn idee heb ik die genoeg snap er vaak niks van maar het is mooi als je er toch uitkomt :smiley:

heb er net snel nog wat aan geknutselt maar ook dit werkte niet dus bij deze de sketch.

ik hoop dat het niet een te groot rommeltje is wat ik heb gemaakt en dat ik goed op weg ben hoop ik :slight_smile:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

const int button = 2;

int val = 0;

int old_val = 0;

int state = 0;

void setup() {
pwm.begin();

pwm.setPWMFreq(60); // Analog servos run at ~60 Hz updates

pwm.setPWM(0, 1600, 2000); //kanaal 0
pwm.setPWM(1, 1650, 2000);

pinMode(button, INPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
}

void loop() {
val = digitalRead(button);

if ((val == HIGH) && (old_val == LOW))
{

state = 1 - state;
delay(10);
}

if (state == 1) {
analogWrite(4, HIGH);
analogWrite(5, HIGH);
} else {
analogWrite(4, LOW);
analogWrite(5, LOW);
}
}

valt best mee
ik mis (en dat is volgens mij je bug)

old_val =val;

Het is algemeen aanvaard dat het geen goed idee is om methodes te mengen.

int old_val = 0;
...
old_val == LOW

gebruik 0 en 1 of LOW en HIGH maar gebruik ze niet door elkaar.

Volgens mij is de code juist maar ik zou voor state een boolean gebruiken en hem stateOn (of zo) noemen
dan kan je zeggen.

stateOn=!stateOn;

en

if (stateOn) {
  analogWrite(4, HIGH);
  analogWrite(5, HIGH);
} else {
  analogWrite(4, LOW);
  analogWrite(5, LOW);
}

probeer ook eens te kijken hoe je kan debuggen met Serial. Daarmee zou je deze bug zo moeten kunnen vangen.

Met vriendelijke groet
Jantje

bedankt voor de reactie ik ga er naar kijken en eerst uitzoeken hoe werkt om te leren en dan in de sketch zetten om resultaat te zien:)

debuggen met serial????

Een bug is een fout, debuggen is de fouten opsporen en eruit halen.

Om een fout te vinden, moet je kunnen zien wat er gebeurt.
Aangezien je niet in de controller van de Arduino kunt kijken, moet je dus iets anders bedenken om door te krijgen wat er zoal gebeurt.
De Arduino heeft een seriële verbinding beschikbaar, en het is niet heel moeilijk die te gebruiken (maar je moet dat wel ff door hebben).
Je kunt je Arduino waardes naar de seriële verbinding laten sturen.
Dus de waardes die je gebruikt in je programma kun je dan over die verbinding heen sturen.
In de IDE heb je de mogelijkheid om een seriële monitor te openen.
Dat doe je door te klikken op het icoontje rechts, dat wel wat weg heeft van een vergrootglas, en waarbij staat Seriële-monitor (dûhh)
En dan opent er zich een nieuw schermpje waarin (nadat de Arduino zich automatisch reset) de gegevens verschijnen die je met je Arduino verstuurt.

Nu kun je dus zien of er wel gebeurt wat jij dacht dat er zou gebeuren.
En das een heel grote hulp als je dit goed aanpakt.

dank je MAS voor de uitleg :slight_smile:

ahhh klinkt heel belangrijk om te weten als ik het goed begrijp dan zou het daarmee heel simpel moeten zijn om het eruit te vissen. zal er zo effe naar opzoek gaan. dit is de sketch die ik nu heb

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

const int button = 2;

int val = LOW;

int old_val = LOW;

int state = LOW;

void setup() {
pwm.begin();

pwm.setPWMFreq(60); // Analog servos run at ~60 Hz updates

pwm.setPWM(0, 1600, 2000); //kanaal 0
pwm.setPWM(1, 1650, 2000); //kanaal 1

pinMode(button, INPUT);
pinMode(A4, OUTPUT);
pinMode(A5, OUTPUT);
}

void loop() {
val = digitalRead(button);

if((val == HIGH) && (old_val == LOW))
{
state = HIGH - state;
delay(10);
}
old_val = val;

if (state == HIGH) {
analogWrite(A4, HIGH);
analogWrite(A5, HIGH); }
else{
analogWrite(A4, LOW);
analogWrite(A5, LOW);
}
}

het werkt nog steeds niet wat er gebeurt is de servo's schieten meteen in de opgegeven stand zonder bijkomst van de knop.

ik ga nu even kijken naar die monitor functie !

Graag gedaan jantje :wink:

Zoals al vaker gezegd, dit soort zaken zet me vaak aan het denken.
Daarom heb ik zojuist uitgezocht hoe je bij een terminal programma (dus niet met de serial monitor van de IDE), het scherm kunt wissen alvorens je er nieuwe waardes heen stuurt.
Op die manier zie je dus als je in bijvoorbeeld hyperterm (ik weet het, dat impliceert windows XP en is per gisteren hopeloos verouderd en vragen om een apocalyps) bekijkt wat er binnen komt, de waardes netjes updaten in plaats van een schermpje dat elke keer scrollt als er nieuwe waardes binnen komen.
Wat mij betreft is dat net ff wat overzichtelijker, als de data tenminste niet heel erg snel ververst worden.

Overigens, dat doe je door ASCII code 12 (of 0xC als je hexadecimaal prefereert) te verzenden.
Die staat in de ASCII tabel als FF en/of NP

Enneh Hvdh:
Heel simpel is weer een beetje te optimistisch, maar het is wel een machtig hulpmiddel.

Ik weet het.... het is reclame ... maar kijk eens naar men eclipse plugin (die werk ook nog steeds onder xp)
die heeft een scope functie en zo kan je het verloop van waarden heel makkel?k opvolgen.
Hier zie je bv een plot van een motor test (oplopen van de temperatuur met verschillende pwm frequenties)

Dat zegt toch veel meer dan een hoop waarden (zelf al staan ze op dezelfde plaats :wink: ).
Met vriendelijke groet
Jantje

Het ligt er aan wat je wil weten.
Maar ik ken vanuit mijn dagelijkse werk wel dat zo'n grafiekje toch wel heel handig kan zijn om in één oogopslag te kunnen zien wat de verschillende signalen ten opzichte van elkaar doen.

klinkt mij allemaal erg moeilijk in de oren op moment :stuck_out_tongue:

ik probeer eerst maar dit opzetje aan de praat te krijgen en dan proberen ik later deze dingen nog is te begrijpen ziet er erg ingewikkelt uit allemaal hahah

Laat je vooral niet afschrikken.
Inderdaad, concentreer je maar lekker op de dingen waar je nu mee bezig bent.

Maar lees ondertussen ook eens her en der hier op het forum.
Want daar kun je serieus van leren, ook van dingen waar je nog helemaal niet mee bezig bent.

ja dat ben ik zeker van plan.

ik denk zelf overigens dat de fout in mij code zit dat die verkeerd is opgebouwd denk ik omdat hij in een stand schiet zonder dat de knop wordt ingedrukt.

snap het niet maar dat komt denk wel goed

en vind het zeer interessant allemaal wat ik voorbij zie komen hier op forum

Ik heb je code even bekeken.
Ik zal beschrijven wat ik er vreemd aan vind, en waarom.
Daarvoor kijk ik alleen naar de loop() functie, van de rest neem ik aan dat dat correct is en dat je dat ergens van hebt over genomen.

state = HIGH - state;

Wat is de bedoeling van deze regel ?
Als state HIGH is, dan is ie 1.
Als state LOW is, dan is ie 0.
Andere waardes zijn er niet.
In die regel maak je state HIGH als ie LOW was (want das dan een min nul), maar LOW als ie al HIGH was, want een min een is nul.
Het kan zijn dat je dit ook wil.
Want het betekent dat je van je druktoets een omschakelaar maakt.
Dan heb je 1 keer drukken is aan, en een tweede keer drukken is uit.
Dus kan zijn dat je dit wil (das in ieder geval wat daar staat).

Dan zie ik nog wat anders, waarvan ik me afvraag of dat wel klopt.
Je maakt analoge pinnen 4 en 5 HIGH of LOW.
Ik vraag me dan af waarom dat analoge pinnen zijn, maar goed die kun je net zo goed digitaal besturen zoals je nu doet.
Maar je doet dat wel een beetje ingewikkelder dan nodig.
Want je hoeft namelijk niet te kijken hoe state er voor staat.
Dus die if... die hoef je helemaal niet te doen.
Enige wat je moet doen is de waarde van state naar die pinnen kopieren.
Dat kun je dus al zo doen:

  analogWrite(A4, state);

Hoef je dus geen if.. en daarom ook de bijbehorende else.. te doen.
Maar weet je wel zeker dat dit is wat je wil ?
Ik heb geen idee van wat die Adafruit shield doet.

wat ik zie is

if((val == HIGH) && (old_val == LOW))

dit betekend dat je enkel van HIGH naar LOW kan en nooit andersom.
wat je volgens mij wilt is

if(val != old_val )

Jantje

Volgens mij is het andersom.
Dus dat je van LOW naar HIGH wil.
Daarom neem ik aan dat ie de schakelaar aan 5 volt heeft zitten, met een weerstand naar GND aan de input pin als pulldown.
In dat geval gaat ie dus iets doen als de schakelaar word ingedrukt, en ie het vorige rondje niet was ingedrukt.
Nu gaat ie dus de uitgang inverteren telkens als de schakelaar word ingedrukt.

Als je zoals in jouw regeltje kijkt of de schakelaar van status veranderd is, dan zet je de uitgang aan zolang de schakelaar is ingedrukt, en das een wezenlijk verschil, maar het kan natuurlijk zijn dat dat de bedoeling is.

Oh en dan iets anders.
Als je van LOW naar HIGH gaat, dan ga je van 0 naar 1.
Maar in analogWrite kun je van 0 tot 255 gaan.
Hier is het dus handig als je kunt zien wat er gebeurt zoals we eerder hadden aangekaart.
Als je wil dat A4 en A5 gewoon HIGH worden en niet op ongeveer een half procent van de tijd HIGH zijn, dan moet je digitalWrite toepassen op die pinnen.
Wat je wil met die pinnen ligt er natuurlijk aan wat die shield met de informatie uit die pinnen doet.

Ik heb het even snel gelezen om even wat antwoorden te kunnen geven zal later beter door lezen om het ook echt te begrijpen.

De bedoeling is inderdaad aan en uit te kunnen. De a4 en a5 zit shield op aangesloten dit omdat ik dat zo op internet tegen kwam dus ik denk dat moet. Analogwrite leek mij logisch zijn analoge pinnetjes.

En deze sketch is samen gesteld uit een druk knop voor een led die werkte en uit de test sketch van het shield.

Ik heb nog even de tijd genomen dit boven staande goed te lezen.

Als ik goed begrijp kan deze sketch nergens opslaan als ik niet weet wat de in/uitvoer op a4/5 is naar het shield?

Het werkt op zichzelf wel namelijk op die kanalen en ik heb van de site hier afgekeken hoe men een motorshield uit thinkerkit aanspreekt en dat was op de standaard kanalen zeg maar van de test sketch. Dit heb ik daarom ook toegepast op deze sketch ik dacht dat hoort zo maar ik denk dan blijkbaar te simpel als ik dit zo lees.

Hoi.

Ik vind je postings lastig te lezen, heb het idee dat je ze wat gehaast opstelt.
Zo snap ik niet wat je wil zeggen met deze zin:

Als ik goed begrijp kan deze sketch nergens opslaan als ik niet weet wat de in/uitvoer op a4/5 is naar het shield?

Ik hoop dat je het me niet kwalijk neemt dat ik dat zeg (vind dat dat moet kunnen).

Maar goed.
Ik heb maar even opgezocht wat die Adafruit shield nou eigenlijk voor 'n ding is.
En het blijkt dat dat een shield is waarmee je 16 servo's kunt bedienen via I2C, een communicatie protocol.
En daar zit 'm nou net het probleem.
Alle Arduino varianten hebben pinnen die voor meerdere dingen gebruikt kunnen worden.
Zo kun je meer met maar weinig pinnen, alleen niet allemaal tegelijk.
Zo kunnen de pinnen A4 en A5 van de Uno gebruikt worden om een 1 of een 0 te maken of te lezen, of een analoge waarde te lezen, maar ze zijn ook de pinnen die gebuikt worden om hardwarematige I2C communicatie te doen.
En dàt is de reden waarom je ze aan die shield moet koppelen om 'm te laten werken.
Wanneer je die pinnen voor I2C gebruikt, kun je ze dus niet voor iets anders tegelijk gebruiken.
Je kan dus niet waardes naar die A4 en A5 pins gaan schrijven terwijl ze in gebruik zijn voor I2C.

Je bemerkt niet dat die pins in gebruik zijn omdat je zelf geen code schrijft die die pins aanstuurt.
Want dat gedoe neemt de library voor je uit handen.

Nu je dit weet, kun je je aanpak ook gaan aanpassen zodat je dit aan het werken gaat krijgen.
Probeer niet zelf iets naar de A4 en A5 pinnen te schrijven, stuur de betreffende commando's naar de library.