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 |

Test d'une mémoire Eeprom externe SPI type AT25256

Par X. HINAULT - Page créée le : 2/11/2010. Path:

1.  Présentation

Test d'une mémoire Eeprom externe SPI type AT25256 de 256 Kbits soit 32 KBytes en utilisant la librairie SPI.

Ce programme utilise les fonctionnalités suivantes :

Ressources utiles associées à ce programme :

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é

  • une plaque d'essai pour montage sans soudures,
  • des straps,

3.  Instructions de montage

connecter les broches de l'EEPROM de la façon suivante :

  • broche 1 (Chip Select - CS ) à la broche 10 de l'Arduino
  • broche 2 (MISO) à la broche 12 de l'Arduino
  • broche 5 (MOSI) à la broche 11 de l'Arduino
  • broche 6 (Sérial Clock - SCK) à la broche 13 de l'Arduino

Les broches /HOLD et /WP sont à connecter au +5V

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 :

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

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

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  Fonctionnement

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 : 2/11/2010.

// ------- 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 ? ---------
 /*  Test de l'écriture/écriture dans une  eeprom SPI externe
     de type AT25256 soit 32 Kbytes..
 */


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

// Utilise la connexion série vers le PC
// Utilise la communication SPI


// -------- 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 <SPI.h> // Librairie pour communication SPI


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

// --- les codes des instructions de l'eeprom SPI
const int WREN=B110; // code instruction Write Enable
const int WRDI=B100; // code instruction Write Reset
const int RDSR=B101; // code instruction Read Status Register
const int WRSR=B001; // code instruction Write Status Register
const int READ=B011; // code instruction Read Data from memory
const int WRITE=B010; // code instruction Write Data to memory


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

//const int DATAOUT=11; //MOSI
//const int DATAIN=12; //MISO
//const int SPICLOCK=13; //sck
const int chipSelectPin=10; //ss (Slave Select)


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


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

unsigned int adresse=2000; // adresse 16 bits
byte adresseMSB, adresseLSB; // variables pour adresse
byte data=0;
long memoMillis=0; // pour mémoriser valeur renvoyée par millis


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

// start the SPI library:
  SPI.begin();
  // Arduino configuré en maitre et broches SPI configurées... ?

  //-------- sens bits ----
  SPI.setBitOrder(MSBFIRST); // fixe le sens de la communication

  //------- Configuration Mode (Impulsion horloge inactive  et Front validation données
  //   Mode        Horloge inactive    Front validation donnée
  //   SPI_MODE0   0                    0
  //   SPI_MODE1   0                    1
  //   SPI_MODE2   1                    0  
  //   SPI_MODE3   1                    1  
  SPI.setDataMode(SPI_MODE0); // l'eeprom AT25256 fonctionne en mode 0

  //-------- configuration de l'horloge ----
  SPI.setClockDivider(SPI_CLOCK_DIV4); // le plus rapide

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

//---- met en sortie la broche de sélection de l'eeprom
  pinMode(chipSelectPin, OUTPUT);

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

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

// take the chip select low to select the device:
  digitalWrite(chipSelectPin, LOW); // sélection l'eeprom
  SPI.transfer(WREN); // active l'écriture - à faire au début séquence écriture
  digitalWrite(chipSelectPin, HIGH); // dé-sélectionne l'eeprom

   delay(10); // pause

//----- message debug
memoMillis=millis(); // mémorise valeur millis()
Serial.print("Millis debut ecriture: "),Serial.println(memoMillis);


// ---- écrit donnée dans l'EEPROM
    digitalWrite(chipSelectPin, LOW); // sélection l'eeprom

    SPI.transfer(WRITE); // instruction écriture

    //adresse=70;
    adresseMSB=adresse>>8; // isole les 8 bits forts
    adresseLSB= adresse; // isole les 8 bits faibles

    SPI.transfer(adresseMSB); // envoie MSB adresse en 1er
    SPI.transfer(adresseLSB); // envoie LSB adresse  

    data=data+1; // donnée à écrire valeur 0 - 255
    SPI.transfer(data); // écriture donnée eeprom

    digitalWrite(chipSelectPin, HIGH); // dé-sélectionne l'eeprom - obligatoire pour lancer l'écriture


    //---- teste la fin du cycle écriture ---
    digitalWrite(chipSelectPin, LOW); // sélection l'eeprom

    while(bitRead(SPI.transfer(RDSR),0)!=0); // attend que le bit Ready passe à 0

    digitalWrite(chipSelectPin, HIGH); // dé-sélectionne l'eeprom

//----- message debug
memoMillis=millis(); // mémorise valeur millis()
Serial.print("Millis fin ecriture: "),Serial.println(memoMillis);

   delay(5); // pause pour laisser temps eeprom travailler

//---- lecture donnée eeprom
  digitalWrite(chipSelectPin, LOW); // sélection l'eeprom
  SPI.transfer(READ); // active la lecture

    //adresse=70;
    adresseMSB=adresse>>8; // isole les 8 bits forts
    adresseLSB= adresse; // isole les 8 bits faibles

    SPI.transfer(adresseMSB); // envoie MSB adresse en 1er
    SPI.transfer(adresseLSB); // envoie LSB adresse  

  data=0;
  data=SPI.transfer(0xFF); // lecture de la donnée...
  // pourquoi 0xFF ? en fait la fonction attend une valeur qui peut etre quelconque
  // NB : avant écriture, les emplacements mémoires valent 0xFF

  digitalWrite(chipSelectPin, HIGH); // dé-sélectionne l'eeprom

  Serial.print("Valeur lue en Eeprom : "),Serial.println(data, DEC);

  //while(1);
  delay(1000); // entre 2 passages


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