AVR Freaks

The overriding idea to keep in mind- you are compiling a single source file (typically a .c file, but compiler doesn't care about names). You normally compile more than 1 source file, but the compiler is only interested in 1 (at a time) and has no concerns about the other 99 (those are 99 separate 'compiles').

Since the compiler has no idea about the other 99 source files, it needs some way of being able to use functions/vars from other files, so you tell it someFunc will exist, and it looks like 'void someFunc(void)'. The compiler will believe you and be happy (it knows the name and how to use it).

The linker has to put it all together, so if you lied to the compiler and there is no 'someFunc' as you said there would be, the linker will complain (undefined reference...).

So, in the end your job is simply to compile a single source file, and ideally the source file is only provided the info it needs. Same for each source file. If you can keep that idea in mind, it goes a long way to understanding how to organize files/headers.

Simple example-

//timers.h - for those that want to use functions/vars from timers.c, include this file

#pragma once //prevents including this file more that once

#include <stdbool.h> //since we use bool in this header

void Timers_Initialize(); //these are the only things we

extern bool isTimersInit; //allow others to know about what is in timers.c

//timers.c

#include "timers.h" //not needed, but makes sure what we do below matches what we tell others

#include <stdbool.h> //although currently provided in timers.h, we also use a bool for a static var

                     //so if we change the header (no longer needs bool), we will still be ok here

bool isTimersInit; //var we told others about

static bool inProgress; //local var, only we know about

void Timers_Initialize(){ inProgress = true; /* init timers */ isTimersInit = true; inProgress = false; }

//init.h - for those that want to use functions/vars from init.c, include this file

#pragma once

void init(); //this is all they need to know

//init.c

#include "init.h" //not needed, but makes sure what we do below matches what we tell others

#include "timers.h" //we want to use timers things

void init(){ if( ! isTimersInit ) Timers_Initialize(); }

//main.c

#include "init.h" //this is all we need to know

int main(){

    init();

}

Notice each source file is only provided what it needs to compile. Timers.c basically needs nothing external, init.c needs to know about a var and function in timers.c, and main.c just needs to know about init in init.c. Each file compiled individually, and when each file compiles without error the linker can 'add' them all together. If you forgot to add init.c to the compile list, you will get an 'undefined reference to init' error since you lied to the compiler in main.c (there is no init function since you didn't compile init.c).

Also note that '#include' simply places the file you specified 'inline', so each source file looks like this (I removed comments)-

//main.c

void init();

int main(){

    init();

}

//timers.c

#include <stdbool.h> //this is also inlined here, I'm just not showing it

void Timers_Initialize();

extern bool isTimersInit;

#include <stdbool.h> //this would not be inlined here as it would have been 'include guarded'

bool isTimersInit;

static bool inProgress;

void Timers_Initialize(){ inProgress = true; /* init timers */ isTimersInit = true; inProgress = false; }

//init.c

void init();

#include <stdbool.h> //this is also inlined here, I'm just not showing it

void Timers_Initialize();

extern bool isTimersInit;

void init(){ if( ! isTimersInit ) Timers_Initialize(); }

Now you may be able to see that each source file does not depend on other source files to compile. For example, if we had no init.h header you can see that simply providing a declaration of 'void init()' would be enough to use init in init.c (assuming init was not a static/local symbol that prevented others from using).

You can also see any header 'system' is simply to relive you from the tedious work of providing your source file with all the info it needs, but in the end it is still a single source file.