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