====== AVR-GCC =====
====== Zufallszahlen erzeugen ======
Um Zufallszahlen mit der rand-Funktion (aus stdlib.h) zu erzeugen, ist ein Startwert (Seed) notwendig. Dieser wird durch srand(seed) gesetzt. Bei gleichem Seed ist die Folge immer gleich. Um unterschiedliche Folgen zu erhalten, ist ein veränderlicher Seed erforderlich. Dazu gibt es mehrere Ansätze:
  * [[http://www.rn-wissen.de/index.php/Zufallszahlen_mit_avr-gcc#Startwert_.28seed.29_besorgen|Werte aus dem unintialisierten SRAM lesen]]
  * Zeit bis zum ersten Tastendruck zählen
  * Wert eines "floatenden" ADC-Eingangs lesen     

====== Konstanten im Flash ablegen ======
Legt man eine Konstante mit <code c> const uint8_t constant = 2; </code> an, wird der Wert aus dem Flash in den RAM geladen und belegt dort unnötig   
Platz, denn verändert werden darf der Wert der Konstante sowieso nicht. Soll das automatische Laden in das RAM verhindert werden, muss das Schlüsselword PROGMEM verwendet werden:
<code c> const PROGMEM uint8_t constant = 2; </code> Diese Werte müssen dann mit ''pgm_read_byte()'', ''pgm_read_word()'', usw. gelesen werden. Soll eine Funktion Werte aus RAM und Flash verarbeiten, müssen zwei Versionen programmiert werden, denn innerhalb einer Funktion ist nicht zu erkennen, ob die Daten in RAM oder Flash liegen. Es ist üblich das Funktionen, die aus dem Flash lesen auf "_P" enden:
<code c>
const char stringInRAM[] = "Teststring im RAM";
const PROGMEM char stringInFlash[] = "Teststring im Flash";
lcd_string(stringInRAM);
lcd_string_P(stringInFlash);
</code>
Häufig werden Strings inline definiert. Diese werden auch vom Flash ins RAM geladen. Um das zu verhindern, aber die Inline-Definition beizubehalten, gibt es das PSTR-Makro:
<code c>
lcd_string("String im RAM");
lcd_string_P(PSTR("String im Flash");
</code>
Prinizipiell können alle Datentypen im Flash abgelegt werden. Bei structs sind einige Besonderheiten zu beachten.
<code c>
typedef struct{ 
  char text[20];
  uint8_t index;
 } struct1;
struct1 PROGMEM teststruct = { 
   .text = "String in RAM",
   .index = 0
};
</code>  
Hierbei liegt die Variable index und der Pointer auf den String im Flash, der String selbst liegt aber noch im RAM. Um das zu verhindern, muss er wie folgt definiert werden (eine Verwendung des PSTR-Makros ist hier nicht möglich):
<code c>
typedef struct{ 
  const char* text;
  uint8_t index;
 } struct1;
const PROGMEM char stringInFlash[] = "String in Flash"; 
struct1 PROGMEM teststruct = { 
   .text = stringInFlash,
   .index = 0
};
</code>
Der Zugriff auf die Elemente des Structs erfolgt dann so:
<code c>
lcd_string_P((char*) pgm_read_word(&teststruct->text)); //Cast zu Char Pointer
if (pgm_read_byte(&(teststruct->index))==curIndex)
		return true;
</code>  

  * [[http://www.github.com/abcminiuser/avr-tutorials/blob/master/Progmem/Output/Progmem.pdf?raw=true|Tutorial zu PROGMEM]]

====== Unbenutzte Funktionen entfernen ======
Da eine Compileunit in C immer nur eine Datei umfasst, kann der GCC im ganzen Projekt nicht benutzte Funktionen nicht erkennen und herausoptimieren. Man kann aber Funktionen mit
<code make>
CFLAGS += -ffunctions-sections
</code>
in eine eigene Section legen. Durch 
<code make>
LDFLAGS += -W1,--gc-sections
</code>
kann man dann den Linker anweisen, unbenutzte Sections zu entfernen, so dass das entstehende Binary kleiner wird.

<WRAP important round>
//**Achtung**//
Damit Interrupthandler nicht entfernt werden, müssen sie mit
<code c>
__attribute__ ((used))
</code>
gekennzeichnet werden.
</WRAP>

====== PIN, PORT und DDR mit einem define anpassen ======
Um einen Pin am AVR zu konfigurieren und zu benutzen, benötigt man die drei Variablen PINX, PORTX, DDRX.
Um dies konfigurierbar zu machen, kann man drei defines verwenden:
<code c>
#define SENSOR_DDR DDRA
#define SENSOR_PORT PORTA
#define SENSOR_PIN PINA
</code>
Möchte man den Port z.B. von A auf B ändern, muss man drei defines anpassen. Mit einem Makrotrick kann man das vermeiden. PINX, PORTX, und DDRX werden so definiert:

<code c>
#define SENSOR_DDR __CONCAT(DDR, SENSOR_PORT_LETTER)
#define SENSOR_PORT __CONCAT(PORT, SENSOR_PORT_LETTER)
#define SENSOR_PIN __CONCAT(PIN, SENSOR_PORT_LETTER)
</code>

Mit 
<code c>
#define SENSOR_PORT_LETTER A
</code>
lässt sich dann der Buchstabe für alle drei Variablen anpassen. Das Makro %%__CONCAT%% ist dabei wie folgt definiert:
<code c>
#define __CONCATenate(left, right)   left ## right
#define __CONCAT(left, right)   __CONCATenate(left, right)
</code>
Man kann diese Makros selbst definieren oder die Definition aus dem Header stdint.h benutzen, da man diesen sowieso fast immer inkludiert. 
===== Links =====
  * [[http://www.swwiki.e-dschungel.de/C|Hinweise zu C allgemein]]
  * [[https://godbolt.org/|Compiler-Explorer]]