Programator pamięci FLASH

[Leoneq]

Zabierając się za rozbudowane projekty, jest szansa że zabraknie nam pamięci. Jeżeli potrzebujemy przechować np. dużą tablicę zmiennych, możemy ją załadować do zewnętrznej pamięci RAM. Co jednak, gdy potrzebujemy przechować duże dane, ale stałe? Najlepiej podpiąć zewnętrzną kość pamięci. Co prawda, nie będzie możliwości zapisu danych (a przynajmniej tak łatwo) ale nasz mikrokontroler uzyska nawet kilka megabitów (!) dodatkowej pamięci. Może to być program, tekst, a nawet obrazek. 

Programując mikrokontroler najprawdopodobniej wgrywasz program do pamięci FLASH. Do dyspozycji możesz mieć także małą, dodatkową pamięć EEPROM. Czym się one różnią? Pamięć FLASH to ewolucja pamięci EEPROM. Same pamięci PROM są dość stare, mają ok. 50 lat. Są one jednorazowe - można je zaprogramować tylko raz.  Ich nowocześniejszą wersją jest pamięć UVEPROM - które łatwo rozpoznać po okienku, które pozwala światłu ultrafioletowemu kasować całą pamięć. Pamięć EEPROM można skasować i zaprogramować elektrycznie, lecz zwykle z pomocą 12V. Z racji tego że te pamięci są stare jak komputery, interfejs jest równoległy; do podłączenia mamy, zwykle ośmiobitową, szynę danych, oraz szynę adresów - jej długość będzie zależeć od pojemności kości. 

Rozwój elektroniki sprawił, że powstał kolejny rodzaj pamięci: FLASH. Do programowania nie wymagają wysokiego napięcia, a do kasowania światła UV. Aby je zaprogramować, muszą być najpierw wyczyszczone, co można robić co najmniej stronami (nie pozwalają czyścić pojedynczych bajtów). Pamięci te zaczęto masowo stosować jeszcze pod koniec XX wieku.

Kości pamięci. Od lewej: PROM, UV EPROM, FLASH (w dwóch obudowach), EEPROM (po I2C)

Do podstawowych rozwiązań powinny wystarczyć małe pamięci EEPROM, które podłączymy po I2C. Trochę większe pamięci można podłączyć przez SPI. Lecz do niektórych rozwiązań najlepiej wykorzystać właśnie te starsze kości. I właśnie do nich zrobiłem programator, który dedykuję kościom FLASH (ponieważ tych mam najwięcej... ) przeróbka na EPROM/EEPROM jest możliwa oczywiście, należy zaopatrzyć płytkę w wyższe napięcie i odpowiedni MOSFET. Następnie najlepiej zapoznać się z notą katalogową wybranej pamięci, i przerobić program. Wracając do pamięci FLASH - zajrzyjmy do noty katalogowej wybranej kości - tutaj 29F002, w której był przechowywany BIOS komputera PC.

Wiemy zatem, że jest to kostka o pojemności dwóch megabitów, wyprodukowana w technologii CMOS (jest wrażliwa na ładunek elektrostatyczny). Posiada dość niski czas odczytu (120ns), pobiera mało prądu, i co najważniejsze - nie wymaga wysokiego napięcia do programowania/kasowania. 

Ilość pinów może przerażać, lecz nie ma się czego bać. VCC i GND to zasilanie, na które podajemy 5V. Pin CE (Chip Enable) uaktywnia kość. Jeżeli z szyn korzysta więcej urządzeń niż jedno, to nasza kość pamięci nie będzie im przeszkadzać. Kreska nad nim oznacza, że jest on aktywny w stanie niskim - czyli żeby włączyć czip, musimy podciągnąć ten sygnał do masy. W programatorze będzie on zwarty do masy, jako że to jedyny układ korzystający z szyn. Pin OE (Output Enable) pozwoli na odczyt danych. W chwili podpięcia tego sygnału do masy, na szynę danych ustawiany jest bajt z podanego adresu. Pin WE (Write Enable) pozwala na zapis. Bajt który w chwili zapisu będzie na szynie danych, zostanie zapisany do podanego adresu. Pozostałe piny (D0..D7) to szyna danych, a A0..A17 to szyna adresu. Liczby na tych szynach są zapisywane w systemie binarnym - co oznacza że możemy operować na 262 144 (2^18) liczbach, a każda liczba może mieć wartość z zakresu 0-255. 

Jeżeli wiemy jak podłączyć naszą kość, możemy to już zrobić: przygotowałem także schemat układu.

Sercem programatora jest Atmega 8, z racji tego że 328 nie miałem żadnej wolnej (nie ma powodu żeby jej nie stosować). Wokół niej powinien się znajdować przycisk reset z rezystorem podciągającym, kondensator do filtrowania zasilania. Przejdźmy do połączenia pamięci z atmegą - dlaczego między nimi są 2 układy? Są to dwa rejestry przesuwne, 74HC595. Dzięki trzem pinom z mikrokontrolera możemy obsłużyć aż 16 (a nawet więcej, bo rejestry można łączyć) pinów. Jeżeli dana pamięć ma szerszą szynę adresów, nieużyte piny powinniśmy połączyć z masą. Co do szyny danych, tą podłączyłem bezpośrednio do Atmegi. Piny RX i TX są zarezerwowane dla konwertera USB-UART, w celu komunikacji z komputerem. Tak wygląda układ zmontowany przeze mnie:

Niebieski, podłużny element to drabinka rezystorowa, zastępująca 8 rezystorów podciągających szynę danych do masy. Dałem na wszelki wypadek.

Teraz należy odpowiednio zaprogramować mikrokontroler.

Obecnie dane do wgrania są przechowywane w pamięci mikrokontrolera, co będzie działać dopóki chcemy wgrywać małe dane. Pracuję nad programem w VS, który będzie przekazywał dane z komputera do Atmegi - w razie czego zaktualizuję post. Gotowa paczka z kodem i generatorem są na dole do pobrania.

Kod napisałem w VS Code, z wtyczką Platformio (kod powinien być w 100% kompatybilny z Arduino IDE). Zacznijmy od zdefiniowania pinów:

#include <Arduino.h>
#define SHIFT_DATA 2
#define SHIFT_CLK 3
#define SHIFT_LATCH 4
#define D0 5
#define D7 12
#define WRITE_EN 13
#define OUTPUT_EN A0

Pierwsze 3 piny są dla rejestru przesuwnego. Podaliśmy także Pierwszy i ostatni pin szyny danych - będziemy operować na pętlach for(), więc nie musimy podawać wszystkich pinów (ważne żeby były podłączone po kolei). Kolejne dwa piny to WE i OE (CE jest zwarty do masy).

Przejdźmy do właściwego kodu. Zaczniemy od napisania funkcji niezbędnych do działania urządzenia:

void setAddress(int address) {
  shiftOut(SHIFT_DATA, SHIFT_CLK, MSBFIRST, address >> 8);
  shiftOut(SHIFT_DATA, SHIFT_CLK, MSBFIRST, address);

  digitalWrite(SHIFT_LATCH, LOW);
  digitalWrite(SHIFT_LATCH, HIGH);
  digitalWrite(SHIFT_LATCH, LOW);
}

Funkcja ta ustawi wybrany adres na szynie adresów. Najpierw wysyłamy do rejestrów pierwsze 8 bitów zmiennej. potem 8 kolejnych, ponieważ funkcja shiftOut() może wysłać tylko ośmiobitowy bajt. Po wysłaniu bitów zatwierdzamy je, ustawiając na chwilę latch w stan wysoki.

void setDataBusOut()
{
  for(int i = D0; i <= D7; i++)
    pinMode(i, OUTPUT);
}

void setDataBusIn()
{
  for(int i = D0; i <= D7; i++)
    pinMode(i, INPUT);
}

Z racji tego, że na szynie danych będziemy zapisywać i odczytywać dane, te funkcje umożliwią ustawić szynę jako wejście lub wyjście.

void setByte(byte out)
{
  for(int i = D0; i <= D7; i++)
    digitalWrite(i, bitRead(out, i - D0));
}

byte readByte()
{
  byte bajt = 0;
  for(int i = D0; i <= D7; i++)
    if(digitalRead(i))
      bitSet(bajt, i - D0);
  return bajt;
}

Funkcja setByte() ustawi dany bajt na szynie danych. Z kolei readByte() zwróci bajt, który jest obecnie na szynie danych. Wykorzystałem tutaj funkcje bitSet i bitRead, które pozwalają na operacje na bitach (odsyłam do dokumentacji Arduino). 

Jeżeli chodzi o podstawowe funkcje - to tyle. Teraz przeanalizujmy poszczególne arkusze noty katalogowej:

Wygląda skomplikowanie, ale nie ma się czego bać. W celu odczytania bajtu z pamięci, musimy ustawić docelowy adres. Pin CE musi być zwarty do masy (u nas jest), a pin WE do dodatniej szyny zasilania. Następnie krótko po podpięciu OE do masy, dostajemy dane na szynie danych. Zróbmy zatem funkcję, która zwróci odczytany bajt:

byte readData(int adr)
{
  byte bajt = 0;
  setDataBusIn();

  digitalWrite(WRITE_EN, HIGH);
  digitalWrite(OUTPUT_EN, HIGH);

  setAddress(adr);
  digitalWrite(OUTPUT_EN, LOW);
  delayMicroseconds(1);
  bajt = readByte();
  digitalWrite(OUTPUT_EN, HIGH);

  return bajt;
}

Najpierw ustawiamy szynę danych jako wejście. Upewniamy się, że WE i OE są w stanie wysokim. Wysyłamy docelowy adres, ustawiamy OE na stan niski, czekamy chwilę, odczytujemy bajt, i ustawiamy OE z powrotem na stan wysoki. Zwracamy odczytany bajt.

Teraz czas na prawdziwą zabawę. Dlaczego nagle jakieś komendy mamy wysyłać? Otóż jest to zabezpieczenie przed przypadkowym skasowaniem/zapisaniem danych. Wysłanie komend polega na wysłaniu 3 odpowiednich danych w odpowiednie adresy. Kolejno AA do adresu 555, 55 do adresu 2AA, i A0 do 555. Literka 'H' oznacza że liczby te są zapisane w systemie heksadecymalnym - tutaj mocno polecam pobawić się kalkulatorem w trybie programisty:

Tak więc operacja zapisu sprowadza się do zapisania 4 bajtów. Zapiszmy funkcję zapisującą jeden bajt:

void writeByte(byte bajt, int adr)
{
  digitalWrite(OUTPUT_EN, HIGH);
  digitalWrite(WRITE_EN, HIGH);

  setAddress(adr);
  setByte(bajt);
  digitalWrite(WRITE_EN, LOW);
  digitalWrite(WRITE_EN, HIGH);
}

Myślę że objaśniać nie trzeba. Teraz zapiszmy funkcję zapisującą jeden bajt w pamięci:

void programData(byte bajt, int adr)
{
  setDataBusOut();
  writeByte(0xAA, 0x555);
  writeByte(0x55, 0x2AA);
  writeByte(0xA0, 0x555);
  writeByte(bajt, adr);
  delayMicroseconds(1);
}

Na końcu dodałem mały odstęp czasowy, ponieważ czip po zapisie przez chwilę jeszcze prowadzi wewnętrzne operacje. Do zrobienia została jeszcze jedna rzecz - nie można zapisywać zapisanej już pamięci. Dlatego patrzymy w notę jak wyczyścić kość: 

Całość się sprowadza do wysłania 6 bajtów. 

void chipErase()
{
  setDataBusOut();
  writeByte(0xAA, 0x555);
  writeByte(0x55, 0x2AA);
  writeByte(0x80, 0x555);
  writeByte(0xAA, 0x555);
  writeByte(0x55, 0x2AA);
  writeByte(0x10, 0x555);
  delayMicroseconds(1);
}

I jeżeli chodzi o kwestię techniczną - to tyle. Przejdźmy zatem do setup():

void setup()
{
  pinMode(SHIFT_DATA, OUTPUT);
  pinMode(SHIFT_CLK, OUTPUT);
  pinMode(SHIFT_LATCH, OUTPUT);
  pinMode(WRITE_EN, OUTPUT);
  pinMode(OUTPUT_EN, OUTPUT);
  digitalWrite(OUTPUT_EN, HIGH);
  digitalWrite(WRITE_EN, HIGH);
  writeByte(0xf0, 0x0000); //reset
  Serial.begin(115200);
  delay(3000);

  Serial.println("programator FLASH v1.0 - gotowy."); 
}

Piny sterujące ustawiamy jako wyjście (i od razu jako stan wysoki), oraz resetujemy czip. Do tego wystarczy jedna komenda jak widać. 

W loopie zaś sprawdzamy jedynie czy z serialu przyszły nowe dane:

void loop()
{
 if(Serial.available()) readSerial(Serial.read());
}

Jeżeli tak, wykonujemy dużego switcha:

void readSerial(byte bajt)
{
  switch(bajt)
  {
    case 'E':
      Serial.println("Czyszcze pamiec FLASH...");
      chipErase();
      delay(200);
      Serial.println("Wyczyszczono!");
      break;
    case 'W':
      Serial.println("Wgrywam przykladowy program...");
      for(int i = 0; i < sizeof(data); i++) programData(data[i], i);
      Serial.println("Wgrano pomyslnie!");
      break;
    case 'R':
      Serial.println("Odczytuje dane od adresu 0x0000...");
      for(int y = 0; y <= 249; y+=5)
      {
        for(int x = 0; x <= 4; x++)
        {
          Serial.print(readData(x+y), HEX);
          Serial.print("  ");
        }
        
        for(int x = 0; x <= 4; x++)
          Serial.print(char(readData(x+y)));

        Serial.println("");
      }
      break;
    case 'T':
      Serial.println("Resetuje pamiec...");
      setDataBusOut();
      writeByte(0xF0, 0x0000);
      setDataBusIn();
      break;
    default:
      Serial.println("Programator FLASH v1.0 - by Leoneq ;3");
      Serial.println("-------------------------------------------");
      Serial.println("E - Wyczysc pamiec");
      Serial.println("R - Odczytaj zawartosc pamieci");
      Serial.println("W - Wgraj przykladowy program");
      Serial.println("T - Zresetuj pamiec FLASH");
      break;
  }

}

Oczywiście te funkcje są przykładowe, zachęcam do samodzielnej zabawy z programem. Zostaje teraz kwestia samych danych do zapisu. Jak napisałem, docelowo mają one być nadawane z komputera PC, a obecnie są one przechowywane w pamięci uC:

//generated data
const byte data[11] = {B00100001, B11111111, B00000001, B11111001, B00111110, B00000001, B11010011, B00000000, B11000011, B00000100, B00000000};

Specjalnie do tego zadania napisałem generator w C++. Tworzy on z plików .bin (kod maszynowy) tablicę zmiennych.

#include <iostream>
#include <fstream>
#include <bitset>

using namespace std;

ifstream source;
fstream output;

//0x21 0xFF 0x01 0xF9 0x3E 0x01 0xD3 0x00 0xC3 0x04 0x00 
int main()
{
   cout << "FLASH code generator v1.0\nby Leoneq ;3\n" ;
   source.open("ROM.bin", ios::binary | ios::ate);
   if(source.good()) cout << "Successfully opened the file.\n";
   else cout << "Couldn't open the file. Put 'ROM.bin' in the same directory where .exe is.";
   int size = source.tellg();
   source.close();
   source.open("ROM.bin", ios::binary);
   char buffer[size];
   source.read (buffer, size);
   source.close();
   output.open("array.txt", ios::out);
   output << "//generated data\nconst byte data[" << size << "] = {";
   for(int i = 0; i < (size-1); i++) 
      output << "B" << bitset<8> (buffer[i]) << ", ";
   output <<"B" << bitset<8> (buffer[size]) << "};";
   cout << "The array is in 'array.txt'. Exit...";
   return 0;
}

Program wczytuje plik ROM.bin, który powinien znajdować się w tym samym miejscu co .exe, a wygenerowaną tablicę zapisze w array.txt.

Tą tablicę należy skopiować do kodu Atmegi, wgrać i... cieszyć się programatorem.

Linki:

• dokumentacja kości FLASH
• nota katalogowa rejestrów przesuwnych
• datasheet mikrokontrolera
• opis funkcji shiftOut(); bitSet(); bitRead();

------------------

W planach mam więcej poradników tego typu, dlatego prosiłbym o komentarze co jest dobrze napisane, a co źle. Dzięki ^^

box.zip

[slon]

Ogólnie bardzo fajny projekt. Jedyne co zapisał bym inaczej (bardziej arduinowo) to:

shiftOut(SHIFT_DATA, SHIFT_CLK, MSBFIRST, highByte(address));
shiftOut(SHIFT_DATA, SHIFT_CLK, MSBFIRST, lowByte(address));

Jak dla mnie jest to bardziej "human readable"

[ethanak]

Tyle że to ma być "machine executable" a nie "human readable".

[Leoneq]

Z tego co widzę, highByte(); i lowByte(); nie będzie działać, jeżeli szyna adresów będzie szersza od 16 linii (użyjemy zmiennej większej od int16_t, więc wyślemy tylko 8 bitów po lewej i 8 po prawej). Przesunięciem bitowym (>> i <<) można obsłużyć większe dane. Ale do małych pamięci jak najbardziej można użyć tamtych funkcji, chociaż przesunięcie bitowe mi się wydaje lepszym rozwiązaniem.

Edytowano Sierpień 2, 2020 przez Leoneq

[slon]

6 godzin temu, Leoneq napisał:

Z tego co widzę, highByte(); i lowByte(); nie będzie działać, jeżeli szyna adresów będzie szersza od 16 linii

Tak zgadza się. Aczkolwiek w tym projekcie jest

void setAddress(int address)

dlatego podałem możliwość użycia highByte() oraz lowByte.

6 godzin temu, Leoneq napisał:

chociaż przesunięcie bitowe mi się wydaje lepszym rozwiązaniem.

w twoim kodzie jest:

address >> 8

highByte() robi to samo

#define highByte(w) ((uint8_t) ((w) >> 8))

w przypadku lowByte() jest inaczej. Aczkolwiek trzymaj się tego co bardziej Ci odpowiada.

[ethanak]

2 godziny temu, slon napisał:

w tym projekcie jest

void setAddress(int address)

dlatego podałem możliwość użycia highByte() oraz lowByte.

A ile bitów ma int?