Experimentos con Arduino: 8051 : Interfase at89S51 con eeprom 24C512

Los micros de la familia 8051/8052 no incluyen memoria eeprom; en el caso de los micros Atmega si se dispone de este tipo de memoria.

En el mercado hay disponibles memorias eeprom de interfase serial. Son chips muy económicos con capacidades de hasta 128KB y cuya conexión con el micro es a través del protocolo IC2 (serial basado en dos lineas de comunicación).

La memoria eeprom es útil cuando necesitamos guardar información y que la misma perdure aunque no tengamos conectada la fuente de alimentación al circuito. Un ejemplo muy conocido es un medidor de temperatura que registra las medidas durante un período de tiempo para luego realizar las observaciones pertinentes. La desventaja de estos chips es que la velocidad de escritura/lectura está en el orden de los milisegundos.

En nuestro ejemplo deseamos conectar una memoria Atmel 24C512 (64KB) con un micro at89s51.
En la imagen tenemos tres mini-protobroard . De izquierda a derecha:

Micro atmega644 funcionando como programador ISP (pueden observarse los cuatro cables) conectado a un ordenador a través del puerto serial (primera interfase serial/USB)
Micro at89S51 a 20MHz conectado mediante el puerto serie a un ordenador (segunda interfase serial/USB)
eeprom 24C512 con la dirección A0H (todos los pines a tierra).

La conexión de la memoria con el micro es la siguiente:

Pines 1,2,3,4 y 7 a tierra (GND)
Pin 8 a 5Voltios (Vcc)
Pin 5 a puerto P2.1 del micro ( se requiere una resistencia pullup de 10KOhms a Vcc)
Pin 6 a puerto P2.0 del micro ( se requiere una resistencia pullup de 10KOhms a Vcc)

A continuación un ejemplo de código en pascal que nos permite leer la memoria eeprom (el programa utiliza las unidades I2C y eeprom de Igor Funa Turbo51)

//  eeprom reader
//  Baud  Bits Parity Stop FlowControl
//  xxxx     8    N      1  none 
//  Led conected to port P0.0
//  20MHz -> 7200*2 = 14400 bauds

Program Calculator;
{$O+} 

Uses I2C,eeprom;

Const
  Osc = 20000000; 
  BaudRateTimerValue = Byte (- Osc div 12 div 32 div 7200);
 
Var 
    Led0: Boolean absolute P0.0;
    SerialPort: Text;
    range0,range1,range,y: longint;
    i,j,dec:byte; 
    address:word;
    hex: Array [0..1] of char;
    
    I2C.SCL:          Boolean absolute P2.1; Volatile;
    I2C.SDA:          Boolean absolute P2.0; Volatile;

Procedure WriteToSerialPort; Assembler;
Asm
  CLR   TI
  MOV   SBUF, A
  @WaitLoop:
  JNB   TI, @WaitLoop
end;
 
Function ReadFromSerialPort: Char;
Var ByteResult: Byte absolute Result;
begin
  While not RI do;
  RI := False;
  ByteResult := SBUF;
  { Echo character }
  Asm
    MOV    A, Result
    LCALL  WriteToSerialPort
  end;
end;

Procedure dec2hex;
const HexChar: Array [0..15] of Char  = '0123456789ABCDEF';
var   d0,r: integer;
begin
  d0:=dec div 16;
  r :=dec mod 16;
  hex[0]:=HexChar[r];
  hex[1]:=HexChar[d0];
end;
  
Procedure Init;
begin
  TL1  := BaudRateTimerValue;
  TH1  := BaudRateTimerValue;
  TMOD := 100001;     
  SCON := %01010000;     
  TI   := True;         
  TR1  := True;  
  PCON := PCON or $80; //SMOD=1   baud doubled to 9600        
end;

{$DefaultFile On}
begin
  Init;
  Assign (CurrentIO, ReadFromSerialPort, WriteToSerialPort);
  Repeat
    Writeln ('');
    Write  ('eeprom initial address: ');
    Read   (range0);Writeln('');
    Write  ('eeprom final address  : ');
    Read   (range1);Writeln('');
    range:=(range1 - range0) div 10;
    address:=range0;
    j:=1;
    for y:= 0 to range do   begin
      write (address:6 ,': '); 
      for  i:= 1 to 10 do   begin
        dec:=ReadByteFromEEPROM (address);
        dec2hex;
        write (hex[1],hex[0],' '  );
        address:=address+1;                                                              
      end;
      address:=address-10 ;
      write('  ');
      for  i:= 1 to 10 do   begin
        dec:=ReadByteFromEEPROM (address);
        if (dec>31)  then write (chr(dec)) 
        else              write ('.') ;
        address:=address+1;
      end;
      j:=j+1;
      if (j>40) then begin
         writeln('');
         read(hex);
         j:=1;
      end;
      writeln('');
      Led0:=not(Led0);
    end;  
  until False;
end.

A continuación la unidad I2C:

{
    This file is part of the Turbo51 examples.
    Copyright (C) 2008 - 2011 by Igor Funa

    http://turbo51.com/

    This file 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.
}

Unit eeprom;

Interface

Uses I2C;

Procedure Check_EEPROM_Status;
Procedure WriteByteToEEPROM (Address: Word; D: Byte);
Function ReadByteFromEEPROM (Ad: Word): Byte;
Function ReadBytesFromEEPROM: LongInt;

Implementation

Const eeprom_add = $A0;

Procedure Check_EEPROM_Status;
Var EEPROM_Counter: Word;
begin
  For EEPROM_Counter := 1 to 2000 do
    begin
      Start_I2C;
      Send_I2C_Byte (eeprom_add);
      If Ack then Exit;
      Asm
        NOP
        NOP
      end;
    end;
end;

Procedure WriteByteToEEPROM (Address: Word; D: Byte);
begin
  Check_EEPROM_Status;
  Send_I2C_Byte (Hi (Address));
  Send_I2C_Byte (Lo (Address));
  Send_I2C_Byte (D);
  Stop_I2C;
end;

Function ReadByteFromEEPROM (Ad: Word): Byte;
begin
  Check_EEPROM_Status;
  Send_I2C_Byte (Hi (Ad));
  Send_I2C_Byte (Lo (Ad));
  Start_I2C;
  Send_I2C_Byte (eeprom_add or $01);
  ReadByteFromEEPROM := Receive_I2C_Byte;
  Stop_I2C;
end;

Function ReadBytesFromEEPROM: LongInt; Assembler;
Asm
  LCALL     Check_EEPROM_Status

  MOV       Send_I2C_Byte.Data2Send, DPH
  LCALL     Send_I2C_Byte

  MOV       Send_I2C_Byte.Data2Send, DPL
  LCALL     Send_I2C_Byte

  LCALL     Start_I2C

  MOV       Send_I2C_Byte.Data2Send, #0A3H
  LCALL     Send_I2C_Byte

  LCALL     Receive_I2C_Byte
  MOV       R0, A
  LCALL     Send_I2C_Ack;
  LCALL     Receive_I2C_Byte
  MOV       R1, A
  LCALL     Send_I2C_Ack;
  LCALL     Receive_I2C_Byte
  MOV       R4, A
  LCALL     Send_I2C_Ack;
  LCALL     Receive_I2C_Byte
  MOV       R5, A
  LCALL     Send_I2C_ClockPulse;
  MOV       R2, AR0
  MOV       R3, AR1

  LCALL     Stop_I2C
end;

end.

A continuación la unidad eeprom:

{
    This file is part of the Turbo51 examples.
    Copyright (C) 2008 - 2011 by Igor Funa

    http://turbo51.com/

    This file 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.
}

Unit I2C;

Interface

Const HighLevel = True;
      LowLevel  = False;

Var Ack: Boolean;
    SDA: Boolean absolute Forward; Volatile;
    SCL: Boolean absolute Forward; Volatile;

Procedure Start_I2C;
Procedure Stop_I2C;
Procedure Send_I2C_Byte (Data2Send: Byte);
Function  Receive_I2C_Byte: Byte;
Procedure Send_I2C_Ack;
Procedure Send_I2C_ClockPulse;

Implementation

Procedure Start_I2C;
begin
  SCL := HighLevel;
  Asm
    NOP
  end;
  SDA := LowLevel;
  Asm
    NOP
  end;
  SCL := LowLevel;
  Asm
    NOP
  end;
end;

Procedure Stop_I2C;
begin
  SDA := LowLevel;
  Asm
    NOP
  end;
  SCL := HighLevel;
  Asm
    NOP
  end;
  SDA := HighLevel;
  Asm
    NOP
  end;
end;

Procedure Send_I2C_Byte (Data2Send: Byte);
Var BitCounter: Byte;
begin
  For BitCounter := 1 to 8 do
    begin
      SDA := Data2Send and $80 <> 0;
      Asm
        NOP
      end;
      SCL := HighLevel;
      Asm
        NOP
      end;
      SCL := LowLevel;
      Asm
        NOP
      end;
      Data2Send := Data2Send shl 1;
    end;
  SDA := HighLevel;
  Asm
    NOP
  end;
  SCL := HighLevel;
  Asm
    NOP
  end;
  Ack := not SDA;
  SCL := LowLevel;
  Asm
    NOP
  end;
end;

Function Receive_I2C_Byte: Byte;
Var Data: Byte;
    BitCounter: Byte;
begin
  Data := 0;
  For BitCounter := 1 to 8 do
    begin
      SCL := HighLevel;
      Asm
        NOP
      end;
      Data := Data shl 1;
      Data := Data or Byte (SDA);
      SCL := LowLevel;
      Asm
        NOP
      end;
    end;
  Receive_I2C_Byte := Data;
end;

Procedure Send_I2C_Ack;
begin
  SDA := LowLevel;
  Asm
    NOP
  end;
  SCL := HighLevel;
  Asm
    NOP
  end;
  SCL := LowLevel;
  Asm
    NOP
  end;
  SDA := HighLevel;
  Asm
    NOP
  end;
end;

Procedure Send_I2C_ClockPulse;
begin
  SCL := HighLevel;
  Asm
    NOP
  end;
  SCL := LowLevel;
  Asm
    NOP
  end;
end;

end.

Ambas unidades deben ser compiladas y los archivos con extensión .u51 deben copiarse en la misma carpeta donde se encuentra el ejecutable turbo51.exe
En la imagen un ejemplo de lectura de los posiciones 100 a 400 (decimal) mostrado en el terminal:

Experimentos con Arduino

Páginas

domingo, 21 de septiembre de 2014

8051 : Interfase at89S51 con eeprom 24C512

No hay comentarios:

Publicar un comentario