Eerste probeersel. Werkt niet zoals verwacht. Waar ga ik fout

Allereerst Nico, Excuus als mijn eerste reactie was lomp overkwam.
Ik heb altijd wat moeite met antwoorden waarvan ik niet kan inschatten waar het een antwoord op is. :slight_smile:

@Mas3,
Je uitleg is helder. Ik kan dit meteen weer vertalen naar PICbasic, waarin je middels de code "Symbol" kon aangeven welke naam er gekoppeld moest worden aan welke waarde of variabele.
Ik begrijp dat je een variabele kunt maken (Int), waar meteen een "alias" aan gehangen wordt (middels Const) en een vooringestelde waarde...

Ik kan in de voorbeeldsketches waar ik mijn eigen sketch uit schrijf niet meteen opmaken waar de koppeling of verwijzing van RXLED naar een bepaalde poort wordt gemaakt.

Even tussendoor een antwoord op Septilion's vraag... Ik heb de ProMicro. Om nog niet nader te noemen redenen. :slight_smile: In ieder geval zit daar poort 17(?) verbonden met de RXLED.
Ik baseer me even op voorbeelden die ook gestoeld waren op die ProMicro's.
Ik pak een voorbeeld voor dat printje en ga er aanpassingen in maken en bekijken wat dat doet. :wink:

Met Die Const int key = 5, wilde ik aangeven dat Key op poortje 5 zat.
Uit jullie uitleg maak ik iig op dat dat niet de manier is om een naam aan een poort toe te kennen.

Als jullie me dat kunnen uitleggen, kan ik daar even op doorborduren.
Het verklaar iig dat er niets gebeurd als ik poortje 5 naar null trek. En dát was net waar ik op vast kwam te zitten.

Tot slot, Mas3, weet ik niet waarom men een variabele wilde hangen aan een gegeven wat toch nooit veranderde. Ik snap nu je uitleg over het gebruik van kostbaar geheugen.
Daar kan ik ook verder mee.

@Septillion, voor zover ik jou nog niet heb beantwoord in bovenstaande, las ik je visie op de While statement.
Ik ken de While uit mijn "PICbasic-tijd" en daar werd de While loop altijd met een "Wend" afgesloten.
Dat gebeurt hier natruurlijk met de Brackets. Maar wat C niet leek te slikken was een poging om een oneindige loop te maken met "While 1 = 1". Dat trok hij niet. Maar wel wanneer ik er "While 1 == 1" van maakte.
Ik zou zo niet weten hoe ik andere loops kan bouwen, waar ik onder bepaalde condities uit kan springen.
Middels een Break of wanneer er andere zaken spelen.
Even los ervan dat ik die condities in de While loop kan plaatsten, wil ik wel weten hoe je simpele, oneindige loops kunt maken.

@GijKieken.
Ik ken die cursus... Ik ben er niet gecharmeerd van, ondanks de beste bedoelingen.
Hij is vertaald, maar lang niet alles is overgezet. Er zitten cruciale fouten in en er worden stukken overgeslagen, waardoor ik nog niet weet waarom men "iets" doet.
Ik denk de bekende fout van een tutorial: Er (onbewust) vanuitgaan dat men bepaalde zaken wel begrijpt zodat dit niet wordt benoemd.
Net als autorijden. Je kunt iemand zeggen dat hij een eindje naar voren kan rijden. Maar als diegene niet weet dat de auto in de versnelling moet staan, kom je er nog niet. :slight_smile:

Dan maar een tweede poging,
Begining C for Arduino Jack purdum.

@ftmz : Ik heb allang opgegeven om me daar nog druk over te maken. Ik weet van mijzelf wat ik wel en niet aan kennis in huis heb en hoe die is opgebouwd. Wat een ander daar mee doet is zijn/haar keus. Dus no hard feelings.

Er zijn een paar manieren om de pinnummers in je programma te zetten, ik gebruik liefst define rxpin=17
betekent dus dat als ik ergens in het programma Digitalwrite(rxpin,HIGH) ik eigenlijk schrij Digitalwrite (17,HIGH)
dat maakt het programma leesbaarder ipv dat je overal 17 neerschrijft. want dat kan van alles betekenen.
In Basic deden we dat ook zo hoor. Bovenaan een stelo pinnamen aan nummers hangen.
Het kan dus ook door een INT te benoemen. Is hetzelfde, behalve als define.

het mag natuurlijk ook een constante zijn dan wordt het in een ander stuk geheugen gezet.

Hallo Mensen,
Even een update. Als ik schrijf:

const RXLED = 17

slikt hij dat niet.

Ik krijg daar een foutmelding op bij het compileren:
exit status 1
'RXLED' does not name a type

Misschien dat jij, MAS3, het zo bedoelde: ?

const int RXLED = 17

Gezien jouw terechte punt dat je dan onnodige datacapaciteit gebruikt, leek me dat onwaarschijnlijk.

Die optie "Define" van Shooter heb ik ook wel meer voorbij zien komen. Misschien is dat de "Symbol" die ik als alias bedoelde.
Ga ik zo eens mee experimenteren.

Inderdaad, dat is wat ik had moeten schrijven.

Const is dus een afkorting van constante (de definitie van iets dat niet verandert), precies het tegenovergestelde van een variabele (de definitie van iets dat zal veranderen).
Zoals shooter al aangaf, kun je hetzelfde bereiken door "define" te gebruiken.

Je zal hierdoor nog steeds geen geheugen van de Arduino gebruiken en alleen geheugen van je PC lenen tijdens het compileren.

Je kunt in de reference (klik !) veel zo niet alles terugvinden over C/C++ dat we hier gebruiken.

In zoverre ben ik een stuk meer gaan begrijpen. Mijn dank voor de input. :wink:
Intussen weet ik ook hoe poorten worden "gedeclareerd".
Eerst wordt de "constante variabele" gemaakt (het lijkt inderdaad onlogisch, maar het neemt inderdaad geen ruimte in).
Vervolgens kan ik die waarde koppelen aan een poort.

pinMode(key,INPUT_PULLUP); waarbij "key" eerder een waarde toegekend heeft gekregen.

Check! Leuk man, dit!

Nog wel verradelijk om een enkel "= teken" te gebruiken voor "is gelijk aan", waar dat eigenlijk "==" moet zijn.

Ik had nog wat verder gekeken naar define. Het is inderdaad een oplossing. Maar het is weer een code die je nét weer anders wegzet. "#" ervoor en geen ";" erachter. Waarom, weet ik niet... Maar verrekte lastig om dat weer even onder de knie te krijgen. "Const Int" is dan toch gemakkelijker...

Ik reageer even terwijl ik lees:

FTMZ:
Ik begrijp dat je een variabele kunt maken (Int),

Een variabele is niet per definitie een int! In C/C++ ken je een hele verzameling aan verschillende type variabelen en je kan ze zelfs zelf definiëren. Dit maakt het en mogelijk andere taken te doen met verschillende variabele (tekst anders behandelen dan een nummer bijvoorbeeld) en het geheugen gebruik ligt vast.

FTMZ:
waar meteen een "alias" aan gehangen wordt (middels Const) en een vooringestelde waarde...

Dat is geen alias, maar een type qualifier. Het geeft iets extra's aan voor de variabele. In dit geval dat hij niet te wijzigen valt.

FTMZ:
Ik kan in de voorbeeldsketches waar ik mijn eigen sketch uit schrijf niet meteen opmaken waar de koppeling of verwijzing van RXLED naar een bepaalde poort wordt gemaakt.

Zoals gezegd gebeurd dat als je een functie aan roept die iets met een pin (niet poort!) doet. Binnen Arduino zijn de meest gebruikte digitalRead() en digitalWrite().

FTMZ:
Even tussendoor een antwoord op Septilion's vraag... Ik heb de ProMicro. Om nog niet nader te noemen redenen. :slight_smile: In ieder geval zit daar poort 17(?) verbonden met de RXLED.

Ahh, kijk. Ben niet heel bekend met de Pro Micro maar dat lijkt inderdaad te kloppen.

FTMZ:
Met Die Const int key = 5, wilde ik aangeven dat Key op poortje 5 zat.

Dat kan. Maar variabelen hebben alleen voor jou een betekenis, niet voor de compiler. Pas als jij de variabele gaat gebruiken om ergens een pin mee aan te passen zal het ook een functie krijgen voor de compiler.

Tipje voor goed programmeren, geef een variabele een duidelijke en beschrijvende naam en gebruik het kleinst mogelijke datatype wat alle mogelijke waardes kan bevatten. Zou dus hier

const byte KeyPin = 5;

FTMZ:
Tot slot, Mas3, weet ik niet waarom men een variabele wilde hangen aan een gegeven wat toch nooit veranderde. Ik snap nu je uitleg over het gebruik van kostbaar geheugen.

Vooral voor de duidelijkheid voor jezelf :slight_smile: Ook kan je zo op één plek het ook ooit veranderen naar bijvoorbeeld pin 7. Door const toe te voegen laat je de compiler weten dat de waarde nooit wordt aangepast. Dit helpt jou dat als je dat ergens in je programma toch probeert je een error krijgt (immers is dat iets wat je dus niet wilt) maar de compiler weet daarmee ook dat hij die waarde niet in het "kostbare" werkgeheugen hoeft te zetten.

FTMZ:
Maar wat C niet leek te slikken was een poging om een oneindige loop te maken met "While 1 = 1". Dat trok hij niet. Maar wel wanneer ik er "While 1 == 1" van maakte.

Dat is ook logisch als je het verschil tussen = en == snapt. a = b staat voor het toewijzen van een waarde b aan variabele a (a is nu dezelfde waarde als b). a == b is de controle op gelijkheid (is a gelijk aan b?).

FTMZ:
Ik zou zo niet weten hoe ik andere loops kan bouwen, waar ik onder bepaalde condities uit kan springen.
Middels een Break of wanneer er andere zaken spelen.
Even los ervan dat ik die condities in de While loop kan plaatsten, wil ik wel weten hoe je simpele, oneindige loops kunt maken.

Even los van het feit dat er nog een paar andere type loops zijn. Maar voornaamste is dat je zelden(!!!) een oneindigen loop wilt hebben! In de regel heb je er genoeg aan één om je hele programma maar te herhalen. En deze is er al! Dat is namelijk loop() :slight_smile: Laat voor de rest het herhalen van het programma over aan loop() en sluit je programma niet ergens anders op een een oneindige loop.

MAS3:
Zoals shooter al aangaf, kun je hetzelfde bereiken door "define" te gebruiken.

Gebruik van define hiervoor raad ik ten strengste af. Grootste nadeel, zeker voor een beginner, is de vaak wazige errors die je krijgt als er een fout in zit. Naast dat je wat andere gekke effecten kunt krijgen als je dingen niet in haakjes hebt en het feit dat het niet type safe is. Dingen die een beginner niet gelijk snapt (of hoeft te snappen) maar hem juist wel kan helpen (aan de hand van nuttige errors) betere code te schrijven.

Top, mensen!
Ik begin steeds meer te begrijpen.
Met wat gepuzzel kan ik het inderdaad af doen met één loop.
Punt is dat ik enkele routines heb waarbij de uitkomst gebruikt moet worden om samen met de uitkomst van andere routines tot een eindwaarde te komen.
Deze eindwaarde wordt overigens middels de KEYboard (HID) functie op het scherm geprojecteerd.
Daarom ook een ProMicro. Dit was een van de weinige (simpele) Arduino's die dit aankon.

Anyway,
Om de uitkomsten die beurtlings uit de verschillende routines komen, steeds weer te verwerken, had ik het plan gevat om dat in een subroutine te doen, die vanuit elke loop benaderd wordt.
Vroegah, ging dat met een Gosub/Return. Ik zie dat dit niet bestaat bij Arduino/C?

Hoe kan ik dan steeds naar de subroutine gaan om daar de verse gegevens te verwerken en weer terug te keren?

BTW, even over je laatste reactie.
Ik had een regel die wel werkte, maar die nu erg knullig lijkt...

const bool RXLED = 17; //variabele om te aan te geven dat poortje 17 de RXLED is

[edit]
Oioioi... Ga ik hier even mank... Was in de war met een Bit... :frowning:
[/edit]
Jij gebruikte daar Byte voor... Beide keren 1 of 0. Mijn oplossing werkte wel. Maakt het iets uit?
Of heb ik mazzel dat het werkt? (in de remarks staat nog steeds dat het een variabele is. Negeer dat maar even. :slight_smile: )

Zijn dat dan taken die veel tijd kosten om te berekenen? Maar begint zo wel een beetje een XY probleem te worden.

FTMZ:
Vroegah, ging dat met een Gosub/Return. Ik zie dat dit niet bestaat bij Arduino/C?

Iets soortgelijks is er in C ook maar blijf er ver van weg. Nu heb je gewoon functies :slight_smile:

FTMZ:
Hoe kan ik dan steeds naar de subroutine gaan om daar de verse gegevens te verwerken en weer terug te keren?

Functies dus :slight_smile:

FTMZ:
BTW, even over je laatste reactie.
Ik had een regel die wel werkte, maar die nu erg knullig lijkt...

const bool RXLED = 17; //variabele om te aan te geven dat poortje 17 de RXLED is

Lijkt me sterk dat het werkt. :wink: Ja, het zal wel compilen maar doet niet wat je wilt. Een bool is namelijk een variabele type van 1-bit. Kan dus alleen een 0 of 1 bevatten. En je schrijft er 17 in, dat is geen 0, dus je bool is nu 1.

Je wilt een het type byte hebben. Die is 8-bit (unsigned) en kan daarmee een waarde tot 255 bevatten.

En zelf zou ik hem iets anders noemen:

const byte RxLedPin = 17;

Is het eigenlijk al duidelijk wat het is zonder commentaar.

Of je kunt de ingebakken variant gebruiken.

pinMode(LED_BUILTIN_RX, OUTPUT); //LED_BUILTIN_RX is al gedefinieerd als 17 voor een Pro Micro :)

Dank weer voor je verduidelijkende antwoorden, Septilion!
Excuus dat ik wat laat reageer... Ik zag te laat dat de Treath doorliep op een tweede pagina.

Nog even terugkomend op het verhaal van de RXLEDpin 17 en zo...
Dat dit 17 was, haalde ik uit een ander programma, geënt op de ProMicro.
Dat de waarde van deze pin door de BOOL slechts 1 of 0 kon zijn, was eigenlijk geen probleem.
Het was een indicatieLED. Of 1 of 0.
Het is een erfenisje van mijn onkunde over hoe een pin toe te wijzen.

Het alternatief op Gosub heb ik even onhold gezet. Dat is misschien niet meer aan de orde. Anders heb ik deze forumtreath als naslagwerk.

Het begint me allemaal steeds meer te dagen.
Echter loop ik nu tegen totaal wat anders aan.
Regelmatig geeft mijn laptop aan dat hij geen board op de toegewezen Compoort ziet.
Terwijl ik een paar tellen ervoor nog wat heb geupload naar de ProMicro. Gevolg is wel dat het apparaatje niet werkt en dat ik ook niets kan zien op de seriele monitor.

Het lijkt erop dat deze melding komt, wanneer ik de seriele monitor open (CTRL/Shift/M).
Als het daarna zou werken, zou wat vertraging geen probleem zijn. Maar er gebeurd dan helemaal niets.
Ik moet dan eerst weer de code uploaden, waarna het meestal weer werkt. Tot ik die Seriele monitor er weer bij betrek.
De volgende melding kon ik copieren:

Arduino:1.8.8 (Windows 10), Board:"Arduino Leonardo"
De schets gebruikt 4996 bytes (17%) programma-opslagruimte. Maximum is 28672 bytes.
Globale variabelen gebruiken 173 bytes (6%) van het dynamisch geheugen. Resteren 2387 bytes voor lokale variabelen. Maximum is 2560 bytes.
Kan op de geselecteerde poort geen board vinden. Controleer of u de correcte poort hebt geselecteerd. Indien deze correct is, druk dan op de resetknop van het board nadat u de upload hebt geïnitialiseerd.
Dit rapport zou meer informatie bevatten met
"Uitgebreide uitvoer weergeven tijden compilatie"
optie aan in Bestand -> Voorkeuren.

Ik heb een keer de compiler en de Seriele monitor tegelijk open gehouden in mijn scherm (ipv te maximaliseren). Ik behoefde dus geen SM meer te openen. Dat leek goed te gaan.
Is dit een bugje wat ik niet ken?

Misschien zijdelings... Maar wat mij ook opvalt is dat het programma niet meteen start wanneer ik de (reeds geprogde) ProMicro aan de spanning (lees: USB van de laptop) hang.
Is dit gerelateerd aan het eerdergenoemde probleem?
Of is dit een ander dingetje wat ik mis?

De Usb aansluiting op je bordje slechte las?
Wat ook kan is dat bij sommige laptops de Usb spanning geen 5 volt haalt,,,

De Pro Micro is een Leonardo variant.
Dat ding heeft native USB ondersteuning op de chip, en daarmee niet een extra USB naar serieel adapter aan boord.
Dat kan er toe leiden dat je Arduino zich eerst als een Arduino aanmeldt, maar even later (als er niets geupload word naar het ding), zich als een ander USB device meldt.
Dat is dan in jouw geval een HID toetsenbord, want eerder gaf je aan dat te willen gaan gebruiken.
En een toetsenbord is geen Arduino.

FTMZ:
Nog even terugkomend op het verhaal van de RXLEDpin 17 en zo...
Dat dit 17 was, haalde ik uit een ander programma, geënt op de ProMicro.
Dat de waarde van deze pin door de BOOL slechts 1 of 0 kon zijn, was eigenlijk geen probleem.
Het was een indicatieLED. Of 1 of 0.
Het is een erfenisje van mijn onkunde over hoe een pin toe te wijzen.

Het gaat daar nog steeds fout.
Jij wil aangeven dat je pin 17 wil gebruiken, omdat daar een LED op is aangesloten.
Dat doe je eerst (met je aangepaste code) hier:

const bool RXLED = 17;

Je maakt hier de term RXLED gelijk aan de boolean die overeenkomt met de waarde 17.
Zoals septilion al aangaf (en ik ook in een antwoord dat ik uiteindelijk maar niet heb geplaatst), werkt het bij booleans iets anders als je mogelijk zou verwachten.
Want daar is een nul een nul (das nog niet zo verrassend).
Maar alles wat niet een nul is, is een 1.
Dus als je een stukje verderop in je code dit doet:

  pinMode(RXLED, OUTPUT);

Dan is dat gelijk aan dit:

  pinMode(1, OUTPUT);

En vertel je dus jouw code dat je pin 1 wil gebruiken als een uitgang om weer iets verderop een LEDje mee te laten knipperen.

Ik zou niet weten wat er aan pin 1 van een ProMicro zit (zou ik moeten opzoeken), maar het doet in ieder geval niet wat jij dacht dat het zou doen.
Dat jij uiteindelijk op pin 17 waar je LEDje in werkelijkheid wel aan zit, een 1 of een nul (dus de keuzes die booleans je bieden) wil zetten heeft daar dus verder weinig mee te maken,

FTMZ:
Dat de waarde van deze pin door de BOOL slechts 1 of 0 kon zijn, was eigenlijk geen probleem.
Het was een indicatieLED. Of 1 of 0.

Daar maak je een denkfout! Er is een verschil tussen een variabele die het pinnummer bevat en de variabele die de staat van de pin bevat :wink: Zie bijvoorbeeld ook digitalWrite(). Eerste parameter is het pin nummer, tweede parameter is de pin staat.

Oeps, MAS3 was me voor. :smiley:

MAS3:
Het gaat daar nog steeds fout.
Jij wil aangeven dat je pin 17 wil gebruiken, omdat daar een LED op is aangesloten.
Dat doe je eerst (met je aangepaste code) hier:

const bool RXLED = 17;

Je maakt hier de term RXLED gelijk aan de boolean die overeenkomt met de waarde 17.
Zoals septilion al aangaf (en ik ook in een antwoord dat ik uiteindelijk maar niet heb geplaatst), werkt het bij booleans iets anders als je mogelijk zou verwachten.
Want daar is een nul een nul (das nog niet zo verrassend).
Maar alles wat niet een nul is, is een 1.

Dat wist ik. Ik had ook geen problemen met het feit dat het een 1 of 0 was. Ik verwachtte een on/off situatie te maken. Daar heb ik de fout gemaakt door een (ik meende dat dat alias heette) verwijzing naar een pin, te behandelen als de status van de pin.
Nu realiseer ik me ook dat dat de reden is dat ik niks meer zag knipperen.

Dus als je een stukje verderop in je code dit doet:

  pinMode(RXLED, OUTPUT);

Dan is dat gelijk aan dit:

  pinMode(1, OUTPUT);

En vertel je dus jouw code dat je pin 1 wil gebruiken als een uitgang om weer iets verderop een LEDje mee te laten knipperen.

Inderdaad... Zo fout dit... :frowning:
Het stomme was dat ik dit achteraf wel wist en het ook zou aanpassen (nav een eerdere reactie van jullie).

Dat jij uiteindelijk op pin 17 waar je LEDje in werkelijkheid wel aan zit, een 1 of een nul (dus de keuzes die booleans je bieden) wil zetten heeft daar dus verder weinig mee te maken,

Idd. Ik wijs op een andere manier een pin toe, snap ik nu.

Wat de functie van die pin 1 versus pun 17 betreft, maakt dat voor het projectie niet zoveel uit.
Het is slechts een indicatie ledje om te zien waar een programma zich bevindt.

Even terug naar de ProMicro in zijn hoedanigheid als HID.
Dat stukje code heb ik uitgeschakeld omdat ik eerst de voorwaarden/condities wil creeeren waaronder de ProMicro zijn waardes als toetsenbord moet gaan "typen".

Ik zou dus verwachten dat de ProMicro USB poort constant een verbinding heeft met mijn laptop.
Of is het zo dat seriele data naar de serial-monitor conflicteert met het proggen van de code in de ProMicro?

En daarbij blijf ik het lastig vinden dat het apparaatje het niet lijkt te doen zónder aangesloten te zijn op mijn laptop. (wacht even... Ik bedoel dit anders, maar ik weet niet meer hoe. Zonder USB geen spanning op de print. Dat was het niet...)

Je moet even opletten met de Leonardo varianten wanneer je een seriële verbinding initialiseert.
Ik kan je nu niet direct een link geven, maar ik weet wel (ook weer niet van de hoed en de rand) dat daar een specifieke stap voor gezet moet worden (serial.available, zo even uit het hoofd), anders blokkeert de hele boel.

Waarvan Akte, MAS3,

Ik doe nog niet zoveel met het uiteindelijke plan om een stukje tekst te genereren, afhankelijk van berekende waardes.
Ik wil me eerst maar eens vastbijten in hoe die formules binnen schappelijke loopjes kunnen blijven en ik geen Goto of Gosub acties nodig heb.

Als ik dat in de vingers heb, kan ik de HID funktie aanroepen om de stukjes tekst op het beeld te krijgen.
Voor nu (gebaseerd op jullie adviezen) laat ik dat seriële achterwege.
Tenzij het meekijken met de seriële monitor daar ook onder valt. Want die zal nodig zijn tijdens het programmeren om te zien of alles naar wenst verloopt. Uiteindelijk kan ik die regeltjes wel laten vervallen.

Ja, het meekijken via de seriële poort valt daar ook onder.
Want om dat te faciliteren, moet je eerst de verbinding opzetten en vervolgens iets naar die verbinding sturen, zodat je ook wat hebt on mee te kijken met de seriële monitor.

Wat dat aangaat was ik zo nu en dan te haastig met het starten van het programma.
Terwijl de dataupload nog niet leek te zijn voltooid.

Ik maak een keuze tussen het gebruik van de seriële poort, of van een tijdelijk toegevoegd display.
Het gaat mij er daarbij dan om wat voor mij op dat moment het beste uitkomt.
Wanneer ik iets maak waar een display bij hoort, dan probeer ik slechts een gedeelte van het display te gebruiken voor het debuggen.

Soms is het ook mogelijk meerdere displays te gebruiken.
Ik kan me wel voorstellen dat wanneer je geen pins over hebt, dat dat dan allemaal wat lastig is.

Houd er rekening mee dat bij de meeste Arduinos het opzetten van een seriële verbinding met de PC, de Arduino een reset krijgt.
Je kunt dat meestal wel voorkomen, maar dan word het uploaden van nieuwe code weer lastig (want daarvoor is een reset noodzakelijk).