MCUserver: Novinky / Komentáře / Má mcu malou paměť? Připojte pár set kilobajtů DRAM!

Řešil jsem otázku, jak uložit velký objem dat (záznamník fotek z CMOS kamery) a zjistil jsem, že Jesper Hansen to už za mne vyřešil. Jeho projekt popisuje připojení DRAM 512kB*8.

Důvod proč jsem chtěl připojit DRAM je ten, že je jich obvykle dostatek. Pokud nějakou nemáte, tak se podívejte raději pořádně do šuplíku po nějakém paměťovém modulu do PC, kde jsou hezky vedle sebe. A v nouzi nejvyšší zlikvidujte nějakou starou nepoužívanou VGA kartu.
Další důvod byl ten, že jsem potřeboval nízkou spotřebu. SRAM paměti mají obvykle dost vysokou spotřebu, pokud nejde o nějaký typ se Stand-by režimem. Paměť DRAM požaduje proud jen, když se něco děje, jinak má spotřebu nízkou. Při nízké frekvenci refresh (nepředpokládám, že by zde byl čtenář, který by chtěl připojit paměť a nevěděl co tento termín znamená, proto nezabíhám do podrobností) je spotřeba minimální, Jesper měl 2-3 mA. Pozor však na pomalou refresh, pokud budete používat zařízení za vyšších teplot (typicky třeba v automobilu na slunci může být uvnitř teplota až 60C).
Třetím důvodem je malý počet připojovacích vodičů, protože DRAM mají multilexovaná data a adresu, na rozdil od SRAM.
A čtvrtý, poslední důvod je ten, že jsem chtěl mít v zásobě nějaké řešení, které bych mohl potřebovat do masovější výroby, a tam se hodí DRAM, protože je výrazně levnější než SRAM.

Dále již Jesper:
Měl jsem spoustu Hitatchi M5M44800 DRAM pamětí, které jsem dostal skoro zadarmo, tak jsem se rozhodl to zkusit s jednou z nich. Jde o 512k DRAM x 8 bit. Využívá refresh cyklus 1024 (každý max 16 ms), a umožňuje CBR refresh dat (CAS-before-RAS).
Použitý procesor je At90S8515. Refresh je ošetřen periodickým přerušením přes Timer1. Počet je nastaven na -125 a předdělička na hodnotu fClk/1024 (8 MHz), to dává přerušení každých 16 ms. Při každém přerušení, se provede 1024 krát cyklus obnovy, a při každé iteraci se dělá CBR refresh. Cyklus trvá celkem cca 1,6 ms, na celou realizaci. To znamená, že obnova spotřebuje asi 10% času procesoru. Mohlo by to být horší

.
Situace je trochu horší, když začneme studovat RD / WR cyklus. Vzhledem k tomu, že musíte provádět multiplexing adresy a dat, při každém přístupu, tak čtení z paměti trvá asi 3,6 us, a zápis trvá 3 us. Takže to znamená, že je možné číst a zapisovat do paměti s rychlostí asi 300 kB / sec.
Ale vzhledem k tomu, že přístup do 512kB paměti je lineární, tak to není tak zlé.

Jesperův projekt, včetně zdrojového programu v C, je k dispozici zde.

Zdrojový kód:

 
Zdroj: Dram.c
/*
  Jesper Hansen <jesperh@telia.com>  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 2
  of the License, or (at your option) 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, write to the Free Software Foundation, 
  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
        DRAM Test Code
        --------------
        PIN assignements on STK200 board
        Port A  
                0..7    Data 0..7 and address 0..7
        Port C  
                0               A8
                1               A9R
                2               -RAS
                3               -CAS
                4               -OE
                5               -WR                     
*/
 
#include <io.h>  //
#include <progmem.h>  //
#include <signal.h>  //
#include <interrupt.h> //
 
#include "uart.h"
#include "delay.h"
 
// At 8 MHz clock, the clock period is 125 nS
// 
// 12.8 mS @ prescaler 5 (f/1024) (128 uS) requires
// a counter preload value of -125 = 0xff83
 
#define TI1_H   0xff
#define TI1_L   0x83
 
// Executes a 1024 cycle CAS-before-RAS refresh sequence 
// on every timer interrupt (every 16 mS)
// This takes about 1.6 mS @ 8 MHz, so the refresh overhead 
// is about 10 %
 
SIGNAL(SIG_OVERFLOW1)   //timer 1 overflow every 16 mS
{
        int i;
        outp(TI1_H, TCNT1H);                                    //reload timer 
        outp(TI1_L, TCNT1L);
        for (i=0;i<1024;i++)    // 1024 cycles
        {
                cbi(PORTC,PC3);         // CAS lo
                cbi(PORTC,PC2);         // RAS lo
                sbi(PORTC,PC3);         // CAS hi
                sbi(PORTC,PC2);         // RAS hi
        }
}
 
//
// Write a byte to a memory location
// This function executes in about 3 uS @ 8 MHz
//
void WRmem(unsigned long address, unsigned char data)
{
        register unsigned char alo,ami,ahi;
        
        alo = address;                  // split into addressing bytes
        ami = address >> 8;
        ahi = ami >> 2;
        
        // Port A as output
        outp(0xff, DDRA);
 
        cli();                                  // turn off refresh while writing data
 
        outp(alo, PORTA);               // lower address
        outp(ami|0xFC, PORTC);  // lower address
        cbi(PORTC, PC2);                // RAS lo
 
        outp(ahi, PORTA);               // high address
        cbi(PORTC, PC3);                // CAS lo
        
        outp(data, PORTA);              // data
        cbi(PORTC, PC5);                // WR lo
        outp(0xff,PORTC);               // WR, RAS, CAS hi      
 
        sei();
}
 
//
// Read a byte from a memory location
// This function executes in about 3.6 uS @ 8 MHz
//
unsigned char RDmem(unsigned long address)
{
        register unsigned char b;
        register unsigned char alo,ami,ahi;
 
        alo = address;                  // split into addressing bytes
        ami = address >> 8;
        ahi = ami >> 2;
 
        // Port A as output
        outp(0xff, DDRA);
 
        cli();                                  // turn off refresh while reading data
        
        outp(alo, PORTA);               // lower address
        outp(ami|0xFC, PORTC);  // lower address
        cbi(PORTC, PC2);                // RAS lo
 
        outp(ahi, PORTA);               // high address
        cbi(PORTC, PC3);                // CAS lo
 
        // port A input and activate pullups
        outp(0x00, DDRA);
        outp(0xff, PORTA);
 
        cbi(PORTC, PC4);                // OE lo
        asm volatile ("nop");
        b = inp(PINA);                  // data
        outp(0xff,PORTC);               // OE, RAS, CAS hi      
 
        sei();
        return b;
}
 
int main(void) 
{
        unsigned int  i;
        unsigned char c;
        unsigned long addr;
 
//------------------------------
// Initialize ports
//------------------------------
        // A-port set to all inputs, pullups activated
        outp(0xff, PORTA);
        outp(0x00, DDRA);
        // C-port set to all outputs, set to 1 
        outp(0xff, PORTC);
        outp(0xff, DDRC);
 
//----------------------------------------------------------------------------
// More init
//----------------------------------------------------------------------------
 
        // Timer initialization
        
        outp(0, TCCR1A);
        outp(5, TCCR1B);                // prescaler fClk/1024  tPeriod = 128 uS
        outp(TI1_H, TCNT1H);    // load counter register
        outp(TI1_L, TCNT1L);    // load counter register
        sbi(TIMSK, TOIE1);              // enable timer1 interrupt
 
        UART_Init();    // init RS-232 link
                                        // interrupts are also enabled here, starting refresh   
        // say hello
        PRINT("Memorytest 0.1\r\n");
 
 //----------------------------------------------------------------------------
 // Let things loose
 //----------------------------------------------------------------------------                        
        delay(20000);   // wait 20 mS to allow refresh to run at least once
        //
        // do a very simple memory test
        //
 
        addr = 0x1234;                  // some address
 
        for (i=0;i<100;i++)             // write a pattern
                WRmem(addr+i,i);
 
        while (1)                               // loop forever
        {
                for (i=0;i<50;i++)      // delay 5 seconds
                        delay(10000);   
        
                for (i=0;i<100;i++)             
                {
                        c = RDmem(addr+i);      // get a byte
                        UART_Printfu08(c);      // print to console
                        UART_SendByte(' ');     // print a space
                }
                EOL();                                  // print CR/LF
        }
 
}
 
-----------------------------------------------------------------------------
Zdroj: Delay.c
/*
  Jesper Hansen <jesperh@telia.com>  From code by: Volker Oth <volkeroth@gmx.de>  This file is part of the yampp system.
  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 2
  of the License, or (at your option) 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, write to the Free Software Foundation, 
  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
 
#include "delay.h"
 
// delay for a minimum of <us> microseconds 
// the time resolution is dependent on the time the loop takes 
// e.g. with 4Mhz and 5 cycles per loop, the resolution is 1.25 us 
 
void delay(unsigned short us) 
{
    unsigned short  delay_loops;
    register unsigned short  i;
 
    delay_loops = (us+3)/5*CYCLES_PER_US; // +3 for rounding up (dirty) 
 
        // one loop takes 5 cpu cycles 
    for (i=0; i < delay_loops; i++) {};
} 
 
-----------------------------------------------------------------------------
Zdroj: Delay.h
/*
  Jesper Hansen <jesperh@telia.com>    From code by: Volker Oth <volkeroth@gmx.de>  This file is part of the yampp system.
  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 2
  of the License, or (at your option) 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, write to the Free Software Foundation, 
  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
 
#ifndef DELAY_H
#define DELAY_H
 
/* constants/macros */
#define F_CPU                   11059200        /* CPU Clock Frequency */
#define CYCLES_PER_US ((F_CPU+500000)/1000000)  /* cpu cycles per microsecond */
 
/* prototypes */
void delay(unsigned short us);
 
#endif
 
 
 