Beste allemaal,
Ik ben gister begonnen met mijn eerste AVR programma, ik heb ervaring in C, C++ en java etc.
Probleem is echter dat ik niet gewend ben om op een mb'tje meer of minder te kijken. De code moet snel lopen en overzichtelijk zijn, en dus gaat dat soms ten koste van grootte.
In het volgende project zit ik echter al over het interne geheugen van mijn ATtiny2313 heen, terwijl ik nog niet eens klaar ben
Ik heb de hele dag geprobeerd om te verbeteren, maar ik staar me nu gewoon blind ben ik bang.
Hier posten is zon beetje mijn laatste redmiddel, anders koop ik een grotere controller of strip ik functionaliteit eraf.
edit: onderaan link voor het bestand
Mod-edit: Code verwijderd, te lang
De code stuurt een RGB lamp aan, en heeft nu twee modes: automatisch door her RGB spectrum draaien en random kleuren in elkaar laten faden.
De grootste verspilling van geheugen wordt veroorzaakt door het aanroepen van een variabele delay_ms, zonder die functie zit ik op 80% van 2Kb en MET zit ik op 114%!
De compiler staat netjes ingesteld op Os optimalisatie en ik ben er zelf al de hele middag overheen geweest. Hopelijk kan iemand met veel ervaring mij hier helpen.
Hier is de .c file te downloaden, ik verwacht niet dat iemand er iets van kan zien zo zonder opmaak 
http://www.4shared.com/file/H-L9S8Qg/_2__RGBPWM.html
[Bericht gewijzigd door Henry S. op (0%)]
Op 4 juni 2010 16:34:52 schreef robint91:
void super_delay( int ms){ int i; for(i=0;i<ms;i++){ delay_ms(1); } }
void delay_ms(int ms){
while(ms--){
_delay_ms(1);
}
}
Ik heb ook al de code uit delay.h zelf gehaald en neergezet, maar dat heeft hetzelfde tot gevolg.
Hoe gaat die 'delay_1ms' ooit precies 1ms vertraging geven?
Probeer dit eens:
#define XTAL 16000000
/*************************************************************************
delay loop for small accurate delays: 16-bit counter, 4 cycles/loop
*************************************************************************/
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
"1: sbiw %0,1" "\n\t"
"brne 1b" // 4 cycles/loop
: "=w" (__count)
: "0" (__count)
);
}
void udelay (unsigned int us)
{
_delayFourCycles( ( ( 1*(XTAL/4000) )*us)/1000 );
}
void _delay_ms ( double __ms )
Als je delay tijd een constante is kan de compiler er iets moois van maken. Is het variabel zoals bij jou, dan krijg je floating point zooi. Dus zelf een asm delay schrijven, of iets verzinnen zodat er geen delays nodig zijn.
@Bas Smit:
Dat is niet waar.
Op 4 juni 2010 16:34:52 schreef robint91:
void super_delay( int ms){ int i; for(i=0;i<ms;i++){ delay_ms(1); } }
Hij gebruikt dit principe. Geen floats nodig!
@TS:
Als je van alles int (16bit vars) een char( byte). Zit ik aan 90%. Behalve die van random dat moet een int zijn in jouw code.
Zonder -lm linken (zodat je zeker weet dat je geen math include's hebt) wil ook wel schelen. Dan heb je nog de -O1 -O2 -O3 opties, en 'compileren voor kleinste binary' (zie de gcc manpage ergens).
Paar concrete tips:
Gebruik waar mogelijk het kleinst mogelijke type. Dus geen unsigned int maar waar mogelijk unsiged char. Int op de AVR is een 16-bits type. De AVR kan een 8-bits getal in 1 instructie vermenigvuldigen, maar heeft voor een 16-bits getal twee instructies nodig. Aangezien er in jouw code nogal wat vermenigvuldigingen voorkomen kan dat aardig schelen. Verder neemt pwmScale dan twee keer zo weinig ruimte in (100 bytes ipv. 200).
Verder moet je wat experimenteren met de verschillende compiler optimization settings. -O3 geeft in mijn geval bijv. een binary van 7550 bytes, terwijl -O1 maar 1774 bytes oplevert! "Optimization for size" doe je in gcc met de optie -Os, maar in dit specifieke geval leverde -O1 me een beter resultaat op.
Als je deze elementaire optimalisaties doorvoert kom ik op een binary die prima in de Attiny2313 zou passen.
free_electron
Silicon Member
Professioneel ElectronenTemmer - siliconvalleygarage.com - De voltooid verleden tijd van 'halfgeleider' is 'zand' ... US 8,032,693 / US 7,714,746 / US 7,355,303 / US 7,098,557 / US 6,762,632 / EP 1804159 - Real programmers write Hex into ROM
Op 4 juni 2010 16:31:03 schreef Sibylle:
Probleem is echter dat ik niet gewend ben om op een mb'tje meer of minder te kijken.

het grote probleem is dat je overal met vermenigvuldigengen zit.
maak van die '50' en '100' eens 64 en 128 ... dan kan je dat alvast met een shift bewerking oplossen... dat gaat een flink pak sneller gaan en je bent van die rot math libraries vanaf.
switch 16* random / 256 .. en dan kan dat gewoon random <<4 worden ...
en wat is dat gepruts met pgm_read_byte ?
die tabel staat toch in rom. kan je niet gewoon schrijven pwmscale[x] ? daar moet toch iets voor zijn ?
en wat voor koeterwaals is
void delay_ms(int ms){
while(ms--){
_delay_ms(1);
void delay_ms(int ms)
int loopctr ;
while ms{
loopctr = 10000;
while (loopctr) loopctr--;
ms--}
( voeg zelf puntcommas in waar nodig. ik kan me nooit herinneren waar ze moeten staan. veel te veel frullerij..
dat getal 10000 ga je moeten tweaken om op 1 milliseconee uit te komen
Waarom de delay routine niet in assembler schrijven, dan moet je niet tweaken. Zit in de GCC library in denk ik trouwens.
@F_E:
AVRs hebben een 8x8 hardware multiplier. Dat is 1 klokcyclus. Delen is gewoon rot. 16x16 is in 2 cyclussen.
Door het ontwerp("Harvard") kun je niet direct aan variabelen die in de flash staan aan. Je moet die betreffende byte eerst met een speciale instructie uitlezen. Dat doe je met pgm_read_byte.
_delay_ms(1); De compiler tweakt deze instructie al. Dat is gewoon het zelfde als:
loopctr = 10000;
while (loopctr) loopctr--;
@Uranium: Die instructie is al in assembler geschreven.
henri62
1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.
Een delay maak je per definitie niet met een loop, FOEI!!!
Alleen in het uitzonderlijke geval dat je een hele korte delay moet hebben van een paar uS of zo.
Gebruik een timer met INT (+evt een sleep).
Verder worden loops in AVR-GCC bijna altijd weg-geoptimaliseerd.
Dus loops in C zijn totaal waardeloos.
Tenzij je -O0 gebruikt maar dan krijg je er haast niks meer in.
free_electron
Silicon Member
Professioneel ElectronenTemmer - siliconvalleygarage.com - De voltooid verleden tijd van 'halfgeleider' is 'zand' ... US 8,032,693 / US 7,714,746 / US 7,355,303 / US 7,098,557 / US 6,762,632 / EP 1804159 - Real programmers write Hex into ROM
Op 4 juni 2010 19:36:05 schreef robint91:
Door het ontwerp("Harvard") kun je niet direct aan variabelen die in de flash staan aan.
Dat klopt niet. Er is een instructie die direct vanuit rom naar accumulator of register kopieert. (althans op de processoren die ik ken)
en als die delay routine zo gremakt is : hoe verklaar je dan dat ze zoveel rom vreet ? van 80 naar 114 .. das 34% van 2k ... 600 bytes voor een lusje ? Smijt die compiler maar in de vuilbak !
dat delen rot is weet ik ook . vandaar mijn hint om machten van 2 te gebruiken zo kan je schuiven.
[Bericht gewijzigd door free_electron op (31%)]
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
Je moet nog veel leren, zie ik... 
robint91 is nochtans duidelijk:
Je moet die betreffende byte eerst met een speciale instructie uitlezen. Dat doe je met pgm_read_byte.
"Speciaal" betekent hier uiteraard "een speciale c-instructie".
Dan die delay. Dat is simpel:
_delay_ms() kan je aanroepen met een double. _delay_ms(123.456) zeg maar. Als je dat zo in je programma zet, berekent de compiler zelf de best-passende lus, hetgeen in enkele regels assembly-code resulteert.
Dat noemt men optimaliseren.
Maar bij
unsigned int my_delay = weetikveel;
_delay_ms(my_delay);
kan de compiler op voorhand geen lus berekenen. Hij is dan verplicht om gans de berekenings-routine naar assebly te vertalen. Inclusief floating-point routines.
Heb je 'm?
@henri62: timers gebruiken voor een delay is niet erg zinvol als je ze al gebruikt om PWM-activiteiten uit te voeren. Dat was toch waar de TS mee bezig was, als ik me zijn openingspost goed herinner.
Echoflex
1
Op 4 juni 2010 20:36:48 schreef free_electron:
[...]en als die delay routine zo gremakt is : hoe verklaar je dan dat ze zoveel rom vreet ? van 80 naar 114 .. das 34% van 2k ... 600 bytes voor een lusje ? Smijt die compiler maar in de vuilbak !
Nee, het probleem is dat als je die delay.h include, er nog veel meer onzin ge include wordt wat je niet nodig hebt. Dus als je het klein wilt houden moet je je eigen delay functie maken.
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
Dat zou me sterk verbazen. Als je slechts één functie uit een include gebruikt, komt enkel ddie functie in je code terecht, toch?
zo, veel input, ik lees strax alles op mijn gemak door.
Ik wil graag zeggen dat ik ook gewoon de functie _delay_ms() uit delay.h heb gehaald. En de functie die _delay_ms() aanroept erin verwerkt heb, zo kreeg ik een delayms() functie die erg veel leek op:
http://www.circuitsonline.net/forum/view/message/1117374#1117374
Het geheugenprobleem bleef echter precies hetzelfde, gelukkig maar want anders was de compiler niet veel waard 
Daarna heb ik die functie weer gewoon vervangen door delay.h, zodat de code wat overzichtelijk blijft.
[Bericht gewijzigd door Sibylle op (12%)]
Echoflex
1
Op 4 juni 2010 21:25:13 schreef pros:
Dat zou me sterk verbazen. Als je slechts één functie uit een include gebruikt, komt enkel ddie functie in je code terecht, toch?
Dat zou je wel verwachten ja. Include de math lib maar eens.
henri62
1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.
Op 4 juni 2010 21:19:05 schreef Echoflex:
[...]
Nee, het probleem is dat als je die delay.h include, er nog veel meer onzin ge include wordt wat je niet nodig hebt. Dus als je het klein wilt houden moet je je eigen delay functie maken.
Een header file genereerd geen code (tenzij die bagger gemaakt is), een header file mag alleen defines/typen en function prototypes bevatten. Dus bovenstaande quote is onzin.
Maak maar een lege main() {} functie en include meerdere header files.
De uiteindelijke hex-code blijft gelijk.
pros: Verder is het wel degelijk mogelijk om de HW-timers te gebruiken, kwestie van meerder SW-timers op '1' HW-timer implementeren en de juiste SW-counters maken.
Hoe denk je anders dat een O/S honderden timers kan ondersteunen, dat gebeurd allemaal met behulp van een master timer-tick routine.
Edit: Toch even naar de code gekeken en het is me nu wel duidelijk waarom die code "opgeblazen" wordt:
1) De delay_ms() functie wordt door de avr-gcc inlined.
Is niet zo gedeclareerd maar weet dat de compiler dat gewoon doet.
2) De delay.h header file declareerd de _delay_ms() expliciet als inline waardoor het nog slechter (lees groter) wordt.
3) De eigen gemaakte functie: void delay_ms(int ms) {..} is totaal overbodig! Je kunt de _delay_ms(<value>) rechtstreeks gebruiken.
Een andere oplossing is een tweede C-file maken die delay_ms() bevat en direct het argument mee passed.
Die aan je code linken, dan zal de compiler NOOIT geen inlining doen. De delay functie wordt dan alleen daar 1 keer gexpandeerd.
[Bericht gewijzigd door henri62 op (29%)]
ok, de discussie over includen en hoe efficient dat is, is hier niet van toepassing. Ik heb de functies uit delay.h al in een eigen functie gezet en alles van float/double eruit gesloopt. Het geheugengebruik ging niet veel terug.
Op 4 juni 2010 17:09:04 schreef alex278:
Zonder -lm linken (zodat je zeker weet dat je geen math include's hebt) wil ook wel schelen. Dan heb je nog de -O1 -O2 -O3 opties, en 'compileren voor kleinste binary' (zie de gcc manpage ergens).
goede tip inderdaad, heeft hier niet zoveel geholpen maar is erg fijn om te weten 
Op 4 juni 2010 17:47:16 schreef kipmans:
Paar concrete tips:
[...]
Als je deze elementaire optimalisaties doorvoert kom ik op een binary die prima in de Attiny2313 zou passen.
Op 4 juni 2010 16:58:39 schreef robint91:
Als je van alles int (16bit vars) een char( byte). Zit ik aan 90%. Behalve die van random dat moet een int zijn in jouw code.
Ik heb alle 'int' vervangen door 'uint8_t' en het doet inderdaad wonderen 
Het gebruik van O1- verkleint verder van 90% naar 85%! woohoo
Op 4 juni 2010 18:59:18 schreef free_electron:
[...]
maak van die '50' en '100' eens 64 en 128 ... dan kan je dat alvast met een shift bewerking oplossen... dat gaat een flink pak sneller gaan en je bent van die rot math libraries vanaf.
[...]
en wat voor koeterwaals is
[...]
Ik heb inderdaad alles in machten van 2 nu, normaal let ik er niet op bij dit soort kleine berekeningen maar bij uC's is het wel aan te raden.
Mijn loopje doet hetzelde, alleen is de sub-loop in ASM geschreven en al getweaked.
Op 4 juni 2010 23:03:02 schreef henri62:
[...]
3) De eigen gemaakte functie: void delay_ms(int ms) {..} is totaal overbodig! Je kunt de _delay_ms(<value>) rechtstreeks gebruiken.Een andere oplossing is een tweede C-file maken die delay_ms() bevat en direct het argument mee passed.
Die aan je code linken, dan zal de compiler NOOIT geen inlining doen. De delay functie wordt dan alleen daar 1 keer gexpandeerd.
_delay_ms() doet het maar tot op iets van 30ms bij 8MHz, vandaar dat ik het zo doe.
Ik heb nu gemaakt:
delay_ms.c
#include "init_delay_ms.h"
#include <stdint.h>
void delay_ms(uint8_t ms){
while(ms--){
uint16_t __ticks = (uint16_t)(((8000000) / 4e3) * 1);
__asm__ volatile (
"1: sbiw %0,1" "\n\t"
"brne 1b"
: "=w" (__ticks)
: "0" (__ticks)
);
}
}
init_delay_ms.h
#include <stdint.h>
void hello (uint8_t ms);
En in de main.c ook de header included.
Het geheel is echter 5% groter geworden ipv kleiner 
Hier een zipje:
http://www.4shared.com/file/zuAm-uol/RGBPWM.html
Als ik zo test is het wel een stuk efficienter geworden
Als ik de hele inhoud van delay_ms() vervang door een lege while(ms--){}, scheelt dat niks in ruimte. Zonder deze loop scheelt het gelijk 10%, nu weet ik niet wat de compiler doet met een lege functie maar het is toch veel voor één loop 
maartenbakker
Golden Member
www.elba-elektro.nl | "The mind is a funny thing. Sometimes it needs a good whack on the side of the head to jar things loose."
Ik geloof dat ik het punt van free_electron begin te zien waarom gcc niet geschikt is voor microcontrollers... Kan je geen native AVR-compiler bemachtigen?
Echoflex
1
Dan is MikroC AVR nog minder geschikt voor microcontrollers terwijl deze compiler voor AVR gemaakt is. Als voorbeeld wil ik graag mijn nieuwe RDS encoder nemen die de gehele op 57kHz gemoduleerde biphase stream in software genereert.
Initieel heb ik deze encoder in de MikroC compiler geschreven en gecompileerd. Ik krijg het in deze compiler niet voor elkaar om de biphase stream binnen de 1.1875kHz cycle klaar te zetten alvorens een 114kHz interrupt hem op 57kHz moduleerd. Bij een clock van 4.332MHz werkt het niet, wanneer ik de clock verhoog naar 11.059200MHz werkt de encoder wel. Met de GCC compiler werkt de encoder wel op 4.332MHz (zowel optimalisatie -O3 en -Os).
Als ik de listing files van MikroC en GCC vergelijk zie ik op veel plekken wonderbaarlijke verschillen.
Als voorbeeld een array:
uint8_t ubBitStack[3] = {1,2,3};
uint8_t ubCurrentBit;
ubCurrentBit = ubBitStack[1];
ubCurrentBit = *(ubBitStack+1);
Bij GCC komt hier dezelfde assembly uit terwijl MikroC van ubCurrentBit = ubBitStack[1]; een behoorlijk circus maakt.
Ook bij het uitlezen van de 4 dimensionale biphase array doet GCC het nog niet zo gek.
Ik heb de code hier niet voorhanden maar ik zal Maandag de verschillen wel even posten.
AVR-GCC is zo native als je kan krijgen (de officiële AVR development tool gebruikt deze als standaard C compiler).
Als ik de code bekijk merk ik dat er wel een aantal zaken in zitten die efficiënter kunnen:
- "volatile" alleen gebruiken als dit echt nodig is. Nodig is in dit geval als de variabele zowel door interrupts als door main() gebruikt worden.
- Groeperen van bitfields. Soms doe je het goed (copy/paste?), maar anders niet. Hiermee bedoel ik dus: PCMSK |= (1<<PIND2); PCMSK |= (1<<PIND3); naar PCMSK |= (1<<PIND2) | (1<<PIND3);
- Ik zie een hele hoop sei() doorheen de code waarvan ik het nut niet snap.
- Interrupts kort houden. Je hebt nu delays van meerdere milliseconden, dat gaat tegen zowat alle "regels" in.
- Die "busy wait" delays zijn helemaal niet bedoelt om delays van milliseconden te doen. Ik zou een overflow interrupt van de timer gebruiken om een counter te verhogen en vervolgens deze waarde controleren in de wait routine.
- Voor de random gebruikt je wat wiskunde, helaas hebben AVR tiny's geen hardware multiplier, waardoor je een aantal extra functies nodig hebt. Als je hier enkel wat schifts, adds en xors gebruikt of een lookup tabel dan bespaar je een hoop ruimte.
- (Ik ben eerst even aan het testen of dit wel helpt). De fade() functie wordt waarschijnlijk efficiënter als je er een specifieke maakt per kleur.
Als ik de code compileer met een paar snelle wijziginen kom ik uit op 1420 bytes (69.3% Full)
[EDIT]
Verder kan het denk ik niet geoptimaliseerd worden zonder dingen serieus te herschrijven:
Original 1438 bytes (70.2% Full)
Small opts 1408 bytes (68.8% Full)
fade() 2 1228 bytes (60.0% Full)
fade() 3 1132 bytes (55.3% Full)
random() 2 1112 bytes (54.3% Full)
random() 3 1076 bytes (52.5% Full) <--Voor verdere optimalisatie kan je het volgende proberen. Ik merk dat er iedere keer een structuur in de aanroepen zit:
fade RED
fade GREEN
fade BLUE
delay
Als je dit in een flash array zet als "R, G, B, delay" en vervolgens een lus maakt waar je de juiste functies aanroept kan je nog een hoop ruimte besparen.
henri62
1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.
Op 5 juni 2010 03:52:16 schreef maartenbakker:
Ik geloof dat ik het punt van free_electron begin te zien waarom gcc niet geschikt is voor microcontrollers... Kan je geen native AVR-compiler bemachtigen?
Volgens Atmel is dat de IAR compiler, die is in samenwerking met de instructieset ontwikkeld voordat de AVR controllers klaar waren.
http://www.iar.com/website1/1.0.1.0/1785/1/
Het probleem met _delay_ms() is dat je deze alleen wilt gebruiken voor een constante vertraging die tijdens het compileren bekend is. Anders worden er namelijk floating-point berekeningen uitgevoerd, wat enorm veel instructies kost. Daarom is de oplossing met een loopje in dit geval aan te raden.
De maximaal te halen delay is niet gelijk aan slechts 30 ms, lees dit stukje in de handleiding maar eens goed door:
void _delay_ms ( double __ms )
Perform a delay of __ms milliseconds, using _delay_loop_2().
The macro F_CPU is supposed to be defined to a constant defining the CPU clock frequency (in Hertz).
The maximal possible delay is 262.14 ms / F_CPU in MHz.
When the user request delay which exceed the maximum possible one, _delay_ms() provides a decreased resolution functionality. In this mode _delay_ms() will work with a resolution of 1/10 ms, providing delays up to 6.5535 seconds (independent from CPU frequency). The user will not be informed about decreased resolution.
[Bericht gewijzigd door kipmans op (56%)]