Le code source de la fonction main présente le « squelette » minimal de définition d'une fonction codé ci‑dessous :

int main(void)  // void -> no argument
{

  /* some code here */

  return 0;     // 0 = conventional value of normal ending
}

sachant que, par défaut :

• on code la fonction main sans argument (on parle aussi de paramètre), d'où la liste vide explicite (void) (elle peut aussi se coder implicitement (), mais la forme explicite est à privilégier en langage C) ;

la fonction main retourne (c'est‑à‑dire, fournit comme valeur) un nombre entier, d'où :
• le descripteur de type int (début du mot anglais integer qui signifie « entier »),
• et l'instruction simple return 0; qui spécifie la valeur retournée, ici 0 ;
la valeur retournée par la fonction main est interprétée comme un code d'erreur, la valeur 0 signifiant par convention l'absence d'erreur, c'est‑à‑dire le fait que l'exécution du programme s'est terminée normalement.

Hors du bloc de définition de la fonction main – aussi bien avant qu' après – les éléments de code du fichier source ne peuvent être que :

• des directives destinées au préprocesseur – c'est le composant de la chaîne de compilation qui agit en premier sur le fichier source, avant même le compilateur (cf. chap. C1‑II ) ;
(Les directives sont faciles à repérer : elles sont codées par des lignes de contrôle toujours précédées par le symbole # dit croisillon.)
• des déclarations de types, de variables, de fonctions ;
(Les déclarations commencent toujours par un descripteur de type, comme int, float, etc.)
• d'autres définitions de fonctions (cf. infra ) ;

mais il ne peut pas y avoir d'instructions au sens strict du terme (cf. chap. C2‑II ), ni simples, ni structurées.

Ces directives permettent d'employer dans le fichier source où elles sont inscrites les éléments de code (types, variables, fonctions) définis dans les modules de bibliothèque spécifiés.

C'est un aspect essentiel de la modularité du langage C.

Dans le cadre d'un programme multi‑fichier, il est d'usage que le fichier source principal qui contient la fonction main soit nommé main.cpp. L'extension .cpp (pour « C plus plus ») permet d'identifier le langage C++ employé, sans confusion possible avec le langage C.

La notion de fonction auxiliaire correspond ce qu'on appelle communément un sous‑programme, c'est‑à‑dire une partie de code déportée de la fonction principale (voire d'une autre fonction auxiliaire) afin d'alléger le code de cette dernière.

Dans un programme, on peut coder plusieurs appels d'une fonction auxiliaire (avec éventuellement des valeurs différentes pour les arguments), à condition :

• que la fonction appelée ait fait l'objet d'une déclaration préalable ;
• que tout appel soit lui même codé dans une fonction (par exemple, la fonction main) – dite fonction appelante.

Le squelette minimal d'un programme Arduino est donc constitué de la définition respective de ces deux fonctions :

/* here, no ordinary statement can be coded
 * only directives, declarations and definitions
 */


void setup() 
{ // <- BEGINNING of the "setup" function def. bloc

  /* here, any kind of directives and statements 
   * can be coded 
   */

} // <- END of the "setup" function def. bloc


/* here, no ordinary statement can be coded
 * only directives, declarations and definitions
 */


void loop() 
{ // <- BEGINNING of the "loop" function def. bloc

   /* here, any kind of directives and statements 
   * can be coded 
   */

} // <- END of the "loop" function def. bloc


/* here, no ordinary statement can be coded
 * only directives, declarations and definitions
 */

Ces deux fonctions sont de type void (cf. chap. C3‑I ). Sauf cas très particuliers, il ne faut surtout pas coder d'instruction return dans leur bloc de définition.

C'est par cette homonymie que procède l'identification automatique du fichier principal, car le répertoire de projet peut éventuellement contenir d'autres fichiers sources d'extension .ino (ainsi que des fichiers .cpp .h …), dans le cadre d'une programmation multi‑fichiers.

Essentiellement, il compile un fichier déjà codé nommé main.cpp, issu du noyau du framework (cf. G pour les microcontrôleurs à cœur AVR). Dans ce fichier se trouve le code source de définition de la fonction main où l'on observe :

• que la fonction setup n'est appelée qu'une seule fois A ;
• que la fonction loop est appelée dans une structure de boucle sans fin (forever), ce qui fait qu'après exécution de sa dernière instruction, elle reprend à sa première instruction, etc. A.