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 |

Stocker en mémoire Eeprom une valeur saisie dans le Terminal Série

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

(cliquer pour agrandir)

1.  Présentation

Ce programme stocke en mémoire Eeprom interne de la carte Arduino une valeur saisie dans le Terminal Série du PC. La valeur enregistrée est ensuite lue et envoyée sur le port Série.

L'utilisation du stockage de valeur en Eeprom est intéressant pour faire face à des coupures de l'alimentation par exemple, afin de mémoriser les valeurs utiles avant la mise hors-tension.

Note technique : ATTENTION, le nombre possible d'écriture/lecture en EEPROM est limité...

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC
  • Utilise le stockage de données en mémoire Eeprom interne

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 matériel supplémentaire.

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.  Explication du programme

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

  • On réalise un affichage initial de la valeur de l'Eeprom à l'adresse utilisée pour connaître la valeur au démarrage du programme : ceci permet de visualiser le dernier changement effectué, même après mise hors-tension.

6.2  Au niveau de la boucle principale, la fonction loop ( ) :

  • On écoute le port série : si des caractères sont disponibles, on appelle une fonction dédiées pour lire la valeur numérique saisie.
  • Ensuite, on écrit la valeur reçue en Eeprom puis on relit l'Eeprom à la même adresse.
  • Des messages permettent de visualiser les opérations effectuées.
  • Pour plus de détails : voir les commentaires du programme.

7.  Mise en oeuvre du programme

7.1  Préparation du montage 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

7.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 :

7.3  Fonctionnement

  • Saisir des valeurs dans le champ de saisie de la fenêtre Terminal puis clic sur <send> : la valeur saisie est stockée en Eeprom.

(cliquer pour agrandir)

  • Il peut être intéressant de modifier la valeur en Eeprom puis de mettre hors tension la carte Arduino et de relancer le programme. On se rend compte que la valeur enregistrée en Eeprom a bien été mémorisée malgré la mise hors tension.

8.  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 : 7/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 stocke en mémoire Eeprom interne de la carte Arduino une valeur saisie
dans le Terminal Série du PC.
La valeur enregistrée est ensuite lue et envoyée sur le port Série */


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

// Utilise la connexion série vers le PC
// Utilise le stockage de données en mémoire Eeprom interne

// -------- 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 ---

#include <EEPROM.h> // Librairie pour le stockage de données en mémoire Eeprom interne

// --- 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 ---

 int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
 long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
 long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série

int adresse = 0; // adresses entre 0 et 1023 pour Arduino UNO - 1024 octets
byte valeur=0; // variable pour octets à stocker/lire en Eeprom

// --- 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 valeur initiale en Eeprom
Serial.print("Valeur en Eeprom a l'adresse ");
Serial.print(adresse);
Serial.print(" = ");
Serial.println(int(EEPROM.read(adresse))); //conversion format int pour affichage valeur numérique

} // 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 ---


//--- réception valeur sur port Série par fonction dédiée ---
        if (Serial.available()==true) nombreReception=recevoirNombre(); // si caractères présents sur port Série appel de la fonction recevoirNombre

        nombreReception=constrain(nombreReception,0,255); // Oblige valeur entre 0 et 255

        if (nombreReception!=nombreReception0) { // si un nombre a été reçu

                Serial.print("Valeur saisie = ");
                Serial.println(nombreReception);

                nombreReception0=nombreReception; // RAZ nombreReception0

                // --- écrit la valeur saisie en Eeprom
                valeur=nombreReception;
                EEPROM.write(adresse, valeur); // écrit une valeur en mémoire Eeprom à l'adresse indiquée

                //---- relit la valeur en Eeprom
                valeur = EEPROM.read(adresse); // lit une valeur en mémoire Eeprom à l'adresse indiquée

                // ----- affiche valeur lue en Eeprom
                Serial.print("Valeur en Eeprom a l'adresse ");
                Serial.print(adresse);
                Serial.print(" = ");
                Serial.println(int(valeur)); // conversion format int pour affichage valeur numérique

        } // fin si nombreReception


} // 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 ////////////////////

//---- fonction de réception valeur entière sur le port série ---

long recevoirNombre() { // fonction de reception d'un nombre sur le port série

        int octetRecu=0; // variable pour octet recu
        int compt=0; // variable locale comptage caractères reçus
        boolean signe=true; // variable locale signe nombre recu
        long nombreRecu=0; // variable locale nombre recu

        while (Serial.available()>0) { // tant qu'un octet en réception

                octetRecu=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

                if (octetReception==10) { // si Octet reçu est le saut de ligne
                        break; // sort de la boucle while
                }
                else { // si le caractère reçu n'est pas un saut de ligne

                        if ((octetRecu=='-') && (compt==0))signe=false; // si Octet reçu est le - et si c'est le 1er caractère reçu - signe négatif
                        compt=compt+1; // incrémente compt

                        octetRecu=octetRecu-48; // transfo valeur ASCII en valeur décimale

                        // calcul du nombre à partir des valeurs reçues

                        if ((octetRecu>=0)&&(octetRecu<=9)) nombreRecu = (nombreRecu*10)+octetRecu;

                } // fin else if

                delay(1); // pause pour laisser le temps à la fonction available de recevoir octet suivant

        } // fin tant que octet réception

        //----- une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

        if (signe==false) nombreRecu=nombreRecu*(-1); // prise en compte signe négatif

        return(nombreRecu); // renvoie le nombre calculé - type long

} // fin fonction recevoirNombre


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