Een vraagje die ik misschien beter in een Arduino-specifiek forum zou plaatsen, maar gezien op dit forum heel wat Arduino-kenners zitten ...
Pas recent ben ik het Arduino platform beginnen ontdekken, en ik probeer het één en ander uit.
Blijkbaar niet altijd op de juiste manier.
Een goed voorbeeld is het gebruiken van "Serial.print" instructies, bij het checken van de juiste werking van het programma.
Deze methode blijkt wel veel GlobalVariable memorySpace te gebruiken.
Hoe debuggen jullie je eigen programma's ?
Ik ben ook nog niet zo lang bezig Jean, Dani heeft me een heel eind op weg geholpen.
Maar ik debug ook via de Serial.print methode.
En tijdens het compileren gemaakte fouten volgens de trial en error methode.
Inderdaad de Serial.print is een geheugen vreter, in de finale versie commentarieer ik ze allemaal uit.
Misschien een makkelijker methode is
#define DEBUG 1
#ifdef DEBUG
Serial.print(de te inspecteren variabele);
// Meer debug code...
#endif
Dan kun je op één plek de debug aan of uit zetten.
Ik heb er geen ervaring mee of het efficienter met geheugen om gaat, maar zie het dikwijls in sources.
grt Piet.
er zijn wel enkele manieren denk ik...
* met een display op de Arduino dat de status aangeeft (maar dat vreet zowel geheugen als ook nog eens outputs)
* met de Serial.print of (iets efficienter) Serial.write
* met status LEDs of zo
wat ik meestal doe is een functie "void LogIt(boolean druk)" definiëren die ook Serial.Print doet, maar dan met behulp van 1 enkele globaal gedefinieerde variabele met de tekst er in en een "true" of "false" om effectief serial te gebruiken.
vb
char LogRegel;
.....
LogRegel="Debug information goes here";
LogIt(true);
...
void LogIt(boolean druk)
{if (druk) {Serial.println(LogRegel);}}
Als je dan het loggen wil afzetten voor je definitief programma dan vervang je "if (druk)" door if (!druk)".
Sowieso zal het gebruik van de subroutine je een beetje memory besparen. Mar je blijft met je teksten zitten.
een console is veruit de meest uitgebreide mogelijkheid om informatie weer te geven (tenzij je een display in je projectje hebt, kun je dat ook gebruiken). Een debug led die je op specifieke plaatsen in het programma aanzet om te kijken of een stuk code wordt uitgevoerd kan ook zijn diensten bewijzen.
@Piet & Dani: twee nuttige tips om het geheugenverbruik te beperken, lijkt me. Probeer ik deze avond uit.
@Rian: de console is natuurlijk zeer nuttig voor de informatie weegave.
Mijn probleem is echter het geheugenverbruik van het programma (om die informatie te genereren) te beperken, en blijkbaar is de Arduino omgeving niet zo String-vriendelijk ...
Daarom ben ik nieuwsgierig naar jullie tips & tricks ;)
Ik gebruik ook steeds de Serial.print() methode,
maar ik test steeds elke stuk dat ik schrijf grondig, pas als dat ok is schrijf ik het volgende stuk.
Dit heeft als gevolg dat je in de eerste delen reeds de Serial.print() in commentaar kan plaatsen en zo steeds maar een klein stuk code moet debuggen.
Er zijn blijkbaar tools (vooral onder windows) waar je uw project kan in ontwerpen, code schrijven en dan alles op het scherm simuleren... Maar ik heb er nog nooit gebruik van gemaakt.
die simulators zijn vooral "sexy looking" maar om echt te debuggen verkies ik toch een echte arduino..
Ik heb er al eentje of 2 getest en deden niet echt wat ik wou, maar ik heb ze dan ook niet helemaal "RTFM" gedaan...
Ofwel zijn ze zo omsclachtig dat het sop de kool niet waard is. Ofwel zijn ze DUUR
proton debugt het programma terwijl je het schrijft en nadien run ik het in real pic simulator en als het daar in werkt dan werkt het ook in de pic
enig probleem heb ik met de functie generator die krijg ik niet aan het werken
daar ik op mijn baan alle signalen met pwm verbingigen aan elkaar brei zou dit wel handiger zijn als ik de pulsen in real pic simulator zou kunnen simuleren
maar buiten dat ben ik zeer tevreden van beide programma's
gr raf
Het gaat over ARDUINO Raf ! En trouwens, "debuggen" is wat anders dan spellchecking en sybntax checking "terwijl je programmeert". Dat doet bijna elke development omgeving.
On topic aub
Ik heb geen Arduino, maar gebruik wel dezelfde AVR-chips. Kan je een Arduino op een andere manieren programmeren (met een STK-500 of zo)?
In dat geval gebruik je natuurlijk een andere programmeeromgeving (Bascom, AVR-Studio, ...) maar die hebben wel goeie simulatie ...
Arduino via STK-500? Moet ik eens uitzoeken ...
Ik gebruik vooral status leds bij praktijktests. Op een bepaald moment in het programma moet een ledje aan, of uit gaan ...
Eens dat stukje goed werkt, worden die led-instructies verwijderd en verderop gebruikt ...
Soms gebruik ik ook een (zelfbouw) extern kastje met eigen µC en display, via RS232 kan ik dan data lezen.
ik geloof wel dat dat mogelijk is...
https://www.arduino.cc/en/Hacking/Programmer
De Arduino kan je op meerder manieren programmeren... ICSP, STK500, USBASP, AVR, ...
Ik gebruik voor mijn "losse" chips meestal de USBASP programmer, dat werkt prima.
Uiteindelijk is en blijft die "externe programmer" toch maar een interface voor het "branden" (overzetten) van je code op je chip, een hardware interface tussen je SDK (sftware development kit) en je chip.
Ook AVRDUDE heeft mogelijkheden, maar niet voor het debuggen denk ik.
STK-500 om de arduino te programmeren: ok, maar kun je dan dat ding debuggen ? ? ?
Dan kan je een andere programmeeromgeving gebruiken, met betere simulatiemogelijkheden
Praktijk-debuggen zal nog steeds via leds, terminal-emulator of displays of zo moeten
neen....
Het debuggen gebeurt zoals Gerolf al aanhaalde in de SDK , in dit geval in bvb BASCOM/AVRSTUDIO.
Maar of die rechtstreeks Arduino code aan kan dat weet ik niet.
*edit* Gerolf postte gelijktijdig
Arduino-code is een soort van C, niet? AVRStudio gebruikt dat.
Wie weet heeft die ook een Arduino-compilatie-omgeving ...
Ik gebruik zelf geen Arduino maar debuggen is debuggen.
Ik gebruik (zoals reeds door anderen gezegd) vaak een simpel ledje (je gebruikt maar één poort) ofwel de seriële interface.
Als je Serial.print() teveel geheugen verbruikt, is er dan geen mogelijkheid om rechtstreeks in de seriële buffer te schrijven en op die manier een byte te versturen. Op die manier stuur je telkens maar één byte maar je hebt toch wel al 256 verschillende 'meldingen' die je kan sturen. Eventueel twee keer na elkaar: een vaste byte en dan vb de inhoud van een variabele?
Ik denk maar luidop.
OK.
Voorlopig ga ik al gebruik maken van enkele goeie tips hier:
- uitsturen van debug-berichten via één routine
- bepaalde routines kunnen gecodeerd (byte-waarde), waardoor geen lange strings de boel vervuilen
- conditionele debug statements
- routine per routine grondig uittesten, waarna debug statements daar niet langer vereist zijn.
Blijven natuurlijk ook de status-ledjes, die ik ook al veelvuldig gebruikte
Enkele testjes gisterenavond bevestigen dat ik zo héél wat minder geheugen versmos :)
Het programma draait al terug op de arduino Nano (maar nog niet foutvrij ::) ;)
Aan iedereen hartelijk dank voor de tips !
Ik kan weer even verder.
Dradje blijft natuurlijk open voor verdere tips en tricks ;)
Nu moet ik toegeven dat de praktische kant van het Arduino gebeuren aan mij voorbijgaat maar ik stel me toch de vraag of het niet mogelijk is om gebruik te maken van één van de debuggers die commerciëel verkrijgbaar zijn (bvb. www.visualmicro.com (http://www.visualmicro.com), maar er zijn ook plugins voor bvb Visual Studio Free edition).
Toegeven, kost enkele Euro's (40-tal) maar op die manier ontwikkel je toch op een ander niveau.
Het kan allemaal met Ledjes en print statements maar met dergelijke betaalbare oplossing gaat er m.i. snel een andere wereld open.
mvg,
Patrick Smout
Ik kan Patrick alleen maar bij staan, met VisualMicro kan je tenminste "echt" debuggen.
Betalen is zelfs niet nodig, met de Free edition kom je al een heel eind :-)
Citaat van: sn00zerman op 18 februari 2016, 15:13:04 PM
Ik kan Patrick alleen maar bij staan, met VisualMicro kan je tenminste "echt" debuggen.
Betalen is zelfs niet nodig, met de Free edition kom je al een heel eind :-)
Blijkbaar moet je wel bij elke wijziging van breakpoint de boel terug compileren en opladen.
VisualMicro is waarschijnlijk een hele verbetering, maar het lijkt ook niet ideaal.
Voorlopig kan ik verder met beperkte Serial.print instructies ...
Zeker ook niet ideaal ...
Citaat van: Steam.N op 18 februari 2016, 15:24:37 PM
VisualMicro is waarschijnlijk een hele verbetering, maar het lijkt ook niet ideaal.
Een van de grootste nadelen vind ik is dat je Visual C nodig hebt.
En ik heb een beetje bezwaar tegen alle visual produkten van MS, ze gebruiken mij te veel resources.
Voor mij, met relatief eenvoudige programma's vind ik het debuggen met de middelen die voorhanden zijn in de IDE echt geen crime.
Misschien dat ik ooit nog eens zover kom dat ik enige honderden code regels ga schrijven, vooropgesteld dat het past in een UNO, en dat ik dan zeg: "dit is niet te doen!!"
grt Piet.
Jean,
hier op het nederlandse Arduino forum (http://arduinoforum.nl/) is er iemand die veel Eclipse gebruikt.
http://playground.arduino.cc/Code/Eclipse
Misschien iets dat jij zoekt?
Zelf heb ik er geen ervaring mee, dus ik kan je niet vertellen of het aan jouw vraag beantwoord.
grt Piet.