Arduino sketch writing - Historique des versions

Jc.forton le 20 décembre 2025 à 16:14

2025-12-20T16:14:09Z

Jc.forton : /* Les types numériques */

2024-08-10T10:00:41Z

Les types numériques

← Version précédente		Version du 10 août 2024 à 12:00
Ligne 355 :		Ligne 355 :
	Quand on code en C, il est bon d'utiliser la norme [https://en.wikipedia.org/wiki/C99 C99] qui spécifie plusieurs types numériques de taille fixe. Cette norme à été introduite pour palier les différences qu'il y a entre les compilateurs et les plateformes pour lesquels ils sont écrits (processeur 32bit, microcontrôleur 8bits, etc...) :		Quand on code en C, il est bon d'utiliser la norme [https://en.wikipedia.org/wiki/C99 C99] qui spécifie plusieurs types numériques de taille fixe. Cette norme à été introduite pour palier les différences qu'il y a entre les compilateurs et les plateformes pour lesquels ils sont écrits (processeur 32bit, microcontrôleur 8bits, etc...) :
	*''int8_t'' pour un nombre sur 8 bits (1 octet) ;		*''int8_t'' pour un nombre sur 8 bits (1 octet) ;
	*''int16_t'' pour un nombre sur 16 bits (2 ~~octet~~) ;		*''int16_t'' pour un nombre sur 16 bits (2 octets) ;
	*''int32_t'' pour un nombre sur 32 bits (4 ~~octet~~) ;		*''int32_t'' pour un nombre sur 32 bits (4 octets) ;
	*''int64_t'' pour un nombre sur 64 bits (8 ~~octet~~).		*''int64_t'' pour un nombre sur 64 bits (8 octets).

	Les types de tailles variables restent disponible :		Les types de tailles variables restent disponible :
Ligne 375 :		Ligne 375 :
	void setup() {		void setup() {
	Serial.begin(9600);		Serial.begin(9600);
	Serial.println(F("Types ~~numerique a~~ taille variable : "));		Serial.println(F("Types numeriques à taille variable : "));
	byte b = 0;		byte b = 0;
	Serial.print(F("byte\t : "));		Serial.print(F("byte\t : "));
Ligne 391 :		Ligne 391 :
	Serial.print(F("long\t : "));		Serial.print(F("long\t : "));
	Serial.println(sizeof(l));		Serial.println(sizeof(l));
	Serial.println(F("Types ~~numerique a~~ taille fixe (C99): "));		Serial.println(F("Types numeriques à taille fixe (C99): "));
	int8_t i8 = 0;		int8_t i8 = 0;
	Serial.print(F("uint8_t : "));		Serial.print(F("uint8_t : "));
Ligne 411 :		Ligne 411 :
	Il donne le résultat suivant :		Il donne le résultat suivant :
	<pre>		<pre>
	Types ~~numerique~~ a taille variable :		Types numeriques a taille variable :
	int : 2		int : 2
	float : 4		float : 4
Ligne 417 :		Ligne 417 :
	long : 4		long : 4
	long long : 4		long long : 4
	Types ~~numerique~~ a taille fixe (C99):		Types numeriques a taille fixe (C99):
	uint8_t : 1		uint8_t : 1
	uint16_t : 2		uint16_t : 2

Jc.forton : /* Interruptions */

2021-09-20T10:14:37Z

Interruptions

@@ Ligne 671 : / Ligne 671 : @@
    interrupts();
    // retour à la normale !
+}
 </source>

Jc.forton : /* attachInterrupt() / detachInterrupt() */

2021-09-17T09:48:55Z

attachInterrupt() / detachInterrupt()

← Version précédente		Version du 17 septembre 2021 à 11:48
Ligne 628 :		Ligne 628 :
	Permet d'attacher et détacher des interruptions externes. Les interruptions sont des éventements qui arrivent de manière non prédictive et dont on souhaite être prévenu.		Permet d'attacher et détacher des interruptions externes. Les interruptions sont des éventements qui arrivent de manière non prédictive et dont on souhaite être prévenu.

	Cela peut-être ~~inintéressant~~ pour déclencher du code à l'appuie d'un bouton ou encore pour ''réveiller'' l'ATMega.		Cela peut-être intéressant pour déclencher du code à l'appuie d'un bouton ou encore pour ''réveiller'' l'ATMega.
	*[https://www.arduino.cc/en/Reference/AttachInterrupt attachInterrupt(interrupt, ISR, mode)]		*[https://www.arduino.cc/en/Reference/AttachInterrupt attachInterrupt(interrupt, ISR, mode)]
	**''interrupt'': correspond au numéro d'interruption, en relation avec une broche, généralement déterminé par la fonction ''digitalPinToInterrupt(pin)''. Cependant, il est possible d'utiliser directement le numéro d'interruption, par exemple, la broche deux sur un UNO correspond à l'interruption 0.		**''interrupt'': correspond au numéro d'interruption, en relation avec une broche, généralement déterminé par la fonction ''digitalPinToInterrupt(pin)''. Cependant, il est possible d'utiliser directement le numéro d'interruption, par exemple, la broche deux sur un UNO correspond à l'interruption 0.
Ligne 657 :		Ligne 657 :
	</source>		</source>
	\|}		\|}

	===interrupts() / noInterrupts()===		===interrupts() / noInterrupts()===
	{\|		{\|

Jc.forton : /* Limiter l'utilisation de la mémoire */

2018-09-20T09:43:24Z

Limiter l'utilisation de la mémoire

← Version précédente		Version du 20 septembre 2018 à 11:43
Ligne 822 :		Ligne 822 :
	*Utiliser des fonctions : lorsque c'est possible, il faut essayer de factoriser le code qui se répète dans des fonctions. En plus d'augmenter la lisibilité, cela permet de faciliter la correction de bug.		*Utiliser des fonctions : lorsque c'est possible, il faut essayer de factoriser le code qui se répète dans des fonctions. En plus d'augmenter la lisibilité, cela permet de faciliter la correction de bug.
	*Supprimer le code mort : le plus compliqué, dans des programmes de plusieurs millier de lignes, c'est de s’apercevoir du code qui ne sert plus.		*Supprimer le code mort : le plus compliqué, dans des programmes de plusieurs millier de lignes, c'est de s’apercevoir du code qui ne sert plus.
	*Supprimer le ''bootloader'' : quand on à atteint les limites et que plus aucune optimisation n'est possible, il faut penser à supprimer le ''bootloader''. Cela va permettre à votre programme de s'exécuter plus rapidement mais il n'est plus possible d'utiliser l'Arduino tel quel.		*Supprimer le ''bootloader'' : quand on à atteint les limites et que plus aucune optimisation n'est possible, il faut penser à supprimer le ''bootloader''. Cela va permettre à votre programme de s'exécuter plus rapidement mais il n'est plus possible d'utiliser l'Arduino tel quel, il faut utiliser un Arduino ISP (In-System Programer) comme celui ci-contre.

	Il faut utiliser un Arduino ISP (In-System Programer) comme celui ci-contre.
	\|		\|
	[[Fichier:Arduino isp.jpg\|centré\|250px]]		[[Fichier:Arduino isp.jpg\|centré\|250px]]

Jc.forton : /* Limiter l'utilisation de la mémoire */

2018-02-18T21:01:14Z

Limiter l'utilisation de la mémoire

← Version précédente		Version du 18 février 2018 à 23:01
Ligne 820 :		Ligne 820 :
	\|valign="top"\|		\|valign="top"\|
	Lorsque le programme est conséquent, par exemple à cause de l'import de libraires, la mémoire flash commence à manquer cruellement. Il n'y a pas vraiment de miracle mais, suivre les préceptes suivants peut aider :		Lorsque le programme est conséquent, par exemple à cause de l'import de libraires, la mémoire flash commence à manquer cruellement. Il n'y a pas vraiment de miracle mais, suivre les préceptes suivants peut aider :
	*Utiliser des fonctions : lorsque possible il faut essayer de factoriser le code qui se répète dans des fonctions. En plus d'augmenter la lisibilité, cela permet de faciliter la correction de bug.		*Utiliser des fonctions : lorsque c'est possible, il faut essayer de factoriser le code qui se répète dans des fonctions. En plus d'augmenter la lisibilité, cela permet de faciliter la correction de bug.
	*Supprimer le code mort : le plus compliqué, dans des programmes de plusieurs millier de lignes, c'est de s’apercevoir du code qui ne sert plus.		*Supprimer le code mort : le plus compliqué, dans des programmes de plusieurs millier de lignes, c'est de s’apercevoir du code qui ne sert plus.
	*Supprimer le ''bootloader'' : quand on à atteint les limites et que plus aucune optimisation n'est possible, il faut penser à supprimer le ''bootloader''. Cela va permettre à votre programme de s'exécuter plus rapidement mais il n'est plus possible d'utiliser l'Arduino tel quel.		*Supprimer le ''bootloader'' : quand on à atteint les limites et que plus aucune optimisation n'est possible, il faut penser à supprimer le ''bootloader''. Cela va permettre à votre programme de s'exécuter plus rapidement mais il n'est plus possible d'utiliser l'Arduino tel quel.

Jc.forton : /* Compilation conditionnelle */

2017-01-21T12:16:02Z

Compilation conditionnelle

← Version précédente		Version du 21 janvier 2017 à 14:16
Ligne 489 :		Ligne 489 :
	==Compilation conditionnelle==		==Compilation conditionnelle==
	La compilation conditionnelle permet de choisir les lignes de codes qui vont faire partie du programme final en fonction d'assertions.		La compilation conditionnelle permet de choisir les lignes de codes qui vont faire partie du programme final en fonction d'assertions.
	Celle est particulièrement utile pour modifier le code, par exemple, en fonction ~~de la plaquette~~ utilisée (~~UNO~~, ~~Mega~~, etc...).		Celle est particulièrement utile pour modifier le code, par exemple, en fonction du microcontrôleur utilisée (328p-pu, mega2560, etc...).

	<source lang="c">		<source lang="c">
	#if defined(~~AVR_UNO~~)		#if defined(__AVR_ATmega328P__)
	// Code du UNO		// Code du UNO
	#elif defined(~~AVR_MEGA~~)		#elif defined(__AVR_ATmega1280__)
	// Code du Mega 1280		// Code du Mega 1280
	#elif defined(~~AVR_MEGA2560~~)		#elif defined(__AVR_ATmega2560__)
	// Code du Mega 2560		// Code du Mega 2560
	~~#elif defined(AVR_LEONARDO)~~
	~~// Code du Leonardo~~
	~~#elif defined(AVR_MICRO)~~
	~~// Code du Micro~~
	~~#elif defined(AVR_PRO)~~
	~~// Code du Pro~~
	~~#elif defined(AVR_NANO)~~
	~~// Code du Nano~~
	#endif		#endif
	</source>		</source>

Jc.forton : /* Compilation conditionnelle */

2017-01-21T12:05:01Z

Compilation conditionnelle

← Version précédente		Version du 21 janvier 2017 à 14:05
Ligne 488 :		Ligne 488 :

	==Compilation conditionnelle==		==Compilation conditionnelle==
			La compilation conditionnelle permet de choisir les lignes de codes qui vont faire partie du programme final en fonction d'assertions.
			Celle est particulièrement utile pour modifier le code, par exemple, en fonction de la plaquette utilisée (UNO, Mega, etc...).

			<source lang="c">
			#if defined(AVR_UNO)
			// Code du UNO
			#elif defined(AVR_MEGA)
			// Code du Mega 1280
			#elif defined(AVR_MEGA2560)
			// Code du Mega 2560
			#elif defined(AVR_LEONARDO)
			// Code du Leonardo
			#elif defined(AVR_MICRO)
			// Code du Micro
			#elif defined(AVR_PRO)
			// Code du Pro
			#elif defined(AVR_NANO)
			// Code du Nano
			#endif
			</source>

	=Les fonctions spécifiques à Arduino=		=Les fonctions spécifiques à Arduino=

Jc.forton : /* Les fonctions spécifiques à Arduino */

2017-01-21T11:45:52Z

Les fonctions spécifiques à Arduino

← Version précédente		Version du 21 janvier 2017 à 13:45
Ligne 486 :		Ligne 486 :

	En plus de rendre le programme portable sur plusieurs plateforme, l'utilisation des types fixes permet de minimiser l'espace occupé par les variables en mémoire vive. Cela force le programmeur à réfléchir à la taille des données qu'il va manipuler et, par la même, augmente la robustesse du programme (débordement de tampon, etc...).		En plus de rendre le programme portable sur plusieurs plateforme, l'utilisation des types fixes permet de minimiser l'espace occupé par les variables en mémoire vive. Cela force le programmeur à réfléchir à la taille des données qu'il va manipuler et, par la même, augmente la robustesse du programme (débordement de tampon, etc...).

			==Compilation conditionnelle==

	=Les fonctions spécifiques à Arduino=		=Les fonctions spécifiques à Arduino=

Jc.forton : /* Variables globales */

2017-01-08T20:17:58Z

Variables globales

← Version précédente		Version du 8 janvier 2017 à 22:17
Ligne 49 :		Ligne 49 :
	\|}		\|}
	== Variables globales ==		== Variables globales ==
			{\|
			\|valign="top"\|
	Les variables globales servent, à l'inverse de leurs homologues locales, à plusieurs endroit dans le sketch. Il peut aussi être intéressant, surtout pour les gros objets, de les faire instancier pendant la phase de démarrage de la puce plutôt que de le faire lors du premier appel. L’intérêt ici n'est pas une utilisation à plusieurs endroit mais un gain de temps.		Les variables globales servent, à l'inverse de leurs homologues locales, à plusieurs endroit dans le sketch. Il peut aussi être intéressant, surtout pour les gros objets, de les faire instancier pendant la phase de démarrage de la puce plutôt que de le faire lors du premier appel. L’intérêt ici n'est pas une utilisation à plusieurs endroit mais un gain de temps.

	Ci-~~dessous~~ un exemple de variable globale accessible dans tout le sketch :		Ci-contre un exemple de variable globale accessible dans tout le sketch :
			\|valign="top"\|
	<source lang="c">		<source lang="c">
	// Variable statique (portée sketch) et constante (sa valeur ne change pas)		// Variable statique (portée sketch) et constante (sa valeur ne change pas)
	static const char METHOD[] = "GET";		static const char METHOD[] = "GET";
	</source>		</source>
			\|}

	== Fonction setup() ==		== Fonction setup() ==

Arduino sketch writing - Historique des versions

Jc.forton le 20 décembre 2025 à 16:14

Jc.forton : /* Les types numériques */

Jc.forton : /* Interruptions */

Jc.forton : /* attachInterrupt() / detachInterrupt() */

Jc.forton : /* Limiter l'utilisation de la mémoire */

Jc.forton : /* Limiter l'utilisation de la mémoire */

Jc.forton : /* Compilation conditionnelle */

Jc.forton : /* Compilation conditionnelle */

Jc.forton : /* Les fonctions spécifiques à Arduino */

Jc.forton : /* Variables globales */

Jc.forton : /* Les types numériques */

Jc.forton : /* Interruptions */

Jc.forton : /* attachInterrupt() / detachInterrupt() */

Jc.forton : /* Limiter l'utilisation de la mémoire */

Jc.forton : /* Limiter l'utilisation de la mémoire */

Jc.forton : /* Compilation conditionnelle */

Jc.forton : /* Compilation conditionnelle */

Jc.forton : /* Les fonctions spécifiques à Arduino */

Jc.forton : /* Variables globales */