View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Afficher la taille des variables du langage Arduino

Par X. HINAULT - Page créée le : 12/2/2011.

(cliquer sur l'image pour agrandir)

1.  Présentation

Ce programme affiche dans la fenêtre Terminal la taille des principales variables du langage Arduino, à partir de l'instruction sizeof(). Ce programme est à visée essentiellement didactique pour aider à bien comprendre la taille occupée en mémoire par les différents types de données du langage Arduino.

Pour plus d'infos sur les types de variables du langage Arduino, voir : Synthèse des types de données du langage Arduino

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC

Ressources utiles associées à ce programme :

  • La librairie Serial - pour les communications séries entre la carte Arduino et l'ordinateur ou d'autres composants

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • Aucun

3.  Instructions de montage

  • La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)

4.  Le schéma théorique du montage

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

6.  Fonctionnement du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Explication du programme

7.1  Au niveau de la partie déclarative :

  • On déclare plusieurs variables de types différents.

7.2  Au niveau de la fonction d'initialisation setup( ) :

  • On affiche la taille des différentes variables à l'aide de l'instruction sizeof() du langage Arduino.

8.  Mise en oeuvre du programme

8.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

8.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
  • La fenêtre « Terminal » s'ouvre alors :
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

8.3  Fonctionnement

  • Après un reset sur la carte, on obtient les messages suivants dans la fenêtre Terminal :

(cliquer sur l'image pour agrandir)

9.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 12/2/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Ce programme affiche dans la fenêtre Terminal la taille des
principales variables du langage Arduino, à partir de l'instruction sizeof() */


// --- Fonctionnalités utilisées ---

// Utilise la connexion série vers le PC

// -------- Circuit à réaliser ---------

// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)


// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

// --- Déclaration des constantes utiles ---

// --- Déclaration des constantes des broches E/S numériques ---


// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---



//---- variables 1 octet (8 bits)----
boolean myBoolean; // déclare une variable boolean (1 octet = 8 bits)
char myChar=0; // déclare une variable char (1 octet = 8 bits)
byte myByte=0; // déclare une variable byte (1 octet = 8 bits)

//---- variables 2 octets (16 bits) ---
int myInt=0; // déclare une variable int (2 octets = 16 bits)
word myWord=0; // déclare une variable word (2 octets = 16 bits)

//----- variables 4 octets (32 bits) ----
long myLong=0; // déclare une variable long ( 4 octets = 32 bits )
float myFloat=0; // déclare une variable float ( 4 octets = 32 bits )
double myDouble=0; // déclare une variable double ( 4 octets = 32 bits )

//----- chaine de caractère ----
char maChaine[]="Arduino"; // déclare une chaine de caractère (tableau de char)

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---


// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission


// ------- Broches en sorties numériques -------  

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// ------- Initialisation des variables utilisées -------  

//------- affiche la taille des variables

Serial.println("*** Taille des variables Arduino avec sizeof() ***");
Serial.println();

Serial.print("Taille du type Boolean = "), Serial.print(sizeof(myBoolean)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myBoolean)*8), Serial.println(" bits.");

Serial.print("Taille du type Char = "), Serial.print(sizeof(myChar)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myChar)*8), Serial.println(" bits.");

Serial.print("Taille du type Byte = "), Serial.print(sizeof(myByte)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myByte)*8), Serial.println(" bits.");

Serial.println();

Serial.print("Taille du type Int = "), Serial.print(sizeof(myInt)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myInt)*8), Serial.println(" bits.");

Serial.print("Taille du type Word = "), Serial.print(sizeof(myWord)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myWord)*8), Serial.println(" bits.");

Serial.println();

Serial.print("Taille du type Long = "), Serial.print(sizeof(myLong)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myLong)*8), Serial.println(" bits.");

Serial.print("Taille du type Float = "), Serial.print(sizeof(myFloat)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myFloat)*8), Serial.println(" bits.");

Serial.print("Taille du type Double = "), Serial.print(sizeof(myDouble)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(myDouble)*8), Serial.println(" bits.");

Serial.println();

Serial.print("Taille de la chaine "), Serial.print(maChaine), Serial.print(" est de ");
Serial.print(sizeof(maChaine)), Serial.print(" octet(s) soit ");
Serial.print(sizeof(maChaine)*8), Serial.println(" bits.");
Serial.println("(La taille d'une chaine de caracteres est le nombre de caracteres + 1 octet fin de chaine)");


} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()


// --- ici instructions à exécuter par le programme principal ---




} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////


// ////////////////////////// Fin du programme ////////////////////