Este programa se basa en la escritura de un array en una memoria EEPROM 93c66 ( microwire) y su posterior lectura para la comprobacion del dato grabado. Este programa lo he realizado yo, con motivos de aprendizaje por lo que desconozco si existen más funciones o librerias para programar memoiras microwire ( 3 cables). He visto algo sobre SPI pero no me convence mucho. No descarto traspasar o modificar el programa para que se adapte a SPI pero ya debo de modificar tambien los pines de conexion hacia el SPI de arduino.
/*Programa que toma una tabla de datos de un array y lo
* graba en la memoria eeprom 93c66.Para le escritura de un
* byte se necesita habilitar el chip con una instruccion
* EWEN porque al conectarlo a alimentación está desactivada
* la escritura y borrado.
* Despues de la escritura de todos los datos, protegemos con
* la instruccion EWDS.
*/
const int CS=5;
const int DI=3;
const int DO=2;
const int CLK=4;
const byte OPcode_Lectura=2;
const byte OPcode_Escritura=1;
byte Buffer;
void setup()
{
pinMode(CS, OUTPUT);//Pin CS como salida
pinMode(DI, OUTPUT);
pinMode(CLK, OUTPUT);
pinMode(DO, INPUT);// Pin DO como entrada
Serial.begin(9600);//Velocidad de conexion terminal
//condicion de inicio
startBit();
EWEN();//Habilitamos para escritura
}
void EWEN()
{
int datoEWEN=0x0180;//intruccion ewen+direccion
byte contador=11;
escribe(datoEWEN,contador);
}
void EWDS()
{
int datoEWDS=0;//intruccion ewds+direccion
byte contador=11;
escribe(datoEWDS,contador);
}
void startBit()
{
digitalWrite(CS, LOW);//condicion de inicio
delayMicroseconds(1);
digitalWrite(CLK, LOW);
digitalWrite(DI, LOW);
digitalWrite(CS, HIGH);
delayMicroseconds(1);
digitalWrite(DI, HIGH);
delayMicroseconds(1);
digitalWrite(CLK, HIGH);//Flanco de subida de reloj
delayMicroseconds(1);//Se ha escrito el bit SB
digitalWrite(CLK,LOW);
delayMicroseconds(1);
}
void ProcesoEscritura(int direccion,byte dato)
{
startBit();
escribe(OPcode_Escritura,2);
escribe(direccion,9);
digitalWrite(CLK,LOW);
escribeByte(dato);
comprobarBusy();
digitalWrite(CS,LOW);
}
void escribe(int dato, byte contador)
{
while(contador>0)//repite el ciclo tantas veces
{
delayMicroseconds(1);
digitalWrite(DI, bitRead(dato,(contador-1)));
//Posicionamos el bit a leer de dato y lo copiamos a DI
delayMicroseconds(1);
digitalWrite(CLK, HIGH);
delayMicroseconds(1);
digitalWrite(CLK,LOW);
delayMicroseconds(1);
contador--;//necesario para el ciclo se repita
}
}
void escribeByte(byte Byte)
{
shiftOut(DI,CLK,MSBFIRST,Byte);
}
void leeMemoria()//solo para 8 bits de datos
{
Buffer=0;//limpia el Buffer
Buffer=shiftIn(DO,CLK,MSBFIRST);
/*
Esta funcion obtiene el dato por DO, utiliza como reloj CLk
y se recepciona primero el MSB desde la memoria. El resultado
es un byte que se almacena en una variable tipo byte que he
llamado Buffer.
*/
Serial.print("Resultado de la lectura: ");
Serial.println(Buffer);
delayMicroseconds(1);
}
void comprobarBusy()
{
delay(10);//RETARDO para autoescritura de la EEPROM.
Serial.println("Dato grabado correctamente");
}
void leeAutomatico(int inicio, int alcance)
{
int direccionInicio=inicio;
startBit();//condicion de inicio CS,DI y CLK A 1
escribe(OPcode_Lectura,2);//mandamos el codigo op que es de 2 bits
Serial.println("Mandamos la direccion");
escribe(direccionInicio,9);//9 bits de direccion
if (alcance>direccionInicio)
{
while(direccionInicio<=alcance)//Tope de dirección a leer ( el máximo)
{
leeMemoria();
delay(10);
digitalWrite(CLK,LOW);
delayMicroseconds(1);
digitalWrite(DI,LOW);
Serial.print("Direccion leida: ");
Serial.println(direccionInicio);
direccionInicio++;
}
}
else
{
Serial.println("ERROR.Alcance debe ser mayor que inicio. Se imprime solo inicio");
leeMemoria();
delay(10);
digitalWrite(CLK,LOW);
delayMicroseconds(1);
digitalWrite(DI,LOW);
Serial.print("Direccion leida: ");
Serial.println(direccionInicio);
}
}
void loop()
{
Serial.println("");
Serial.println("Inicio del programa");
byte midato[6]={15,20,22,33,25,7};
int direccion=0;
for(int i=0; i<6; i++)
{
direccion=i;
Serial.print("direccion es: ");
Serial.println(direccion);
Buffer=midato[i];
Serial.print("midato[] vale: ");
Serial.println(Buffer);
startBit();
ProcesoEscritura(direccion,Buffer);
delay(10);
}
startBit();
EWDS();
Serial.println("leemos...");
int inicio=0;//Direccion de inicio de la lectura.
int alcance=10;//POsicion final.DEBE SER MAYOR QUE inicio.
//El numero maximo es 511 ya que la memoria no tiene mas capa
//cidad por lo que si pasamos de este valor, volemos al
//principio.
leeAutomatico(inicio,alcance);
digitalWrite(CS, LOW);
delayMicroseconds(1);
Serial.println("Fin del programa");
}