[brendy]

Hehe no fajnie to ująłeś czytałem jak poezję
Jeśli chodzi o pamieć zapisu to chce dodać fram ze względu na używanie Supli w programie dochodzi szyfrowane połączenie i inne zasoby pożerania, w celu bezpieczeństwa i uniknięcia problemów z działaniem w przyszłości.
Jeśli chcesz to mogę wysłać mam 2 sztuki wyślę za darmo w celach naukowych fajnie że zainteresował cię temat sam jestem ciekaw bo wydać 46 zł na adafruit dobrze że chociaż działa, ale lepiej byłoby kupić kości więcej i za mniej. Ni cholery nie potrafię ich uruchomić...
Ja zamówiłem takie jak w adafruit chce spr czy te zadziałają
26,12 zł | 10 sztuk/partia nowy oryginał MB85RS64VPNF - G - JNERE1 RS64V patch SOP8 MB85RS64V
https://a.aliexpress.com/_mqogkrI

[kaczakat]

Z Chińczykami nigdy nie wiadomo, zawsze jest możliwe że to jakieś fake kości, niby cena nie była "okazyjna", ale komentarzy brak, może cena była też inna jak kupowałeś. Wysłałem wiadomość w sprawie wysyłki. Zawsze można sprawdzić, czy w ogóle prąd biorą zgodnie z deklaracją w datasheet tej pamięci, popatrzeć czy w ogóle coś gadają na SPI.

[brendy]

Też tak myślę, że trafił się jakiś feler. Kupowałem je w tamtym roku z myślą, że je użyje akurat są potrzebne ale przez parę dni w wolnych chwilach nie udało się uruchomić.
Podłączyłem miernik, żeby spr jaki jest pobór prądu kości podłączone tylko zasilanie bez SPI 5uA.

[kaczakat]

5uA to właściwie są w stanie wyłączenia, podczas pracy powinny brać 1.5mA, ale to takie piki tylko pewnie. Zlutowałem tą pamięć, znalazłem PDF, są różnice w komendach:

Kod:

WREN Set Write Enable Latch 0000 0110 B
WRDI Reset Write Enable Latch 0000 0100 B
RDSR Read Status Register 0000 0101 B
WRSR Write Status Register 0000 0001 B
READ Read Memory Code 0000 0011 B
WRITE Write Memory Code 0000 0010 B
RDID Read Device ID 1001 1111 B

Ostatniej nie ma w tej wersji pamięci, pierwsze 6 ma identyczne, dlatego biblioteka od Adafruit się tu glebuje, bo testuje poprawność podłączenia 7 komendą.
W pliku biblioteki Adafruit_FraM_SPI.cpp można to wyłączyć komentując tak w okolicy 110 linii:

Kod:

/* Make sure we're actually connected */
  uint8_t manufID;
  uint16_t prodID;
  /*getDeviceID(&manufID, &prodID);

  if (manufID != 0x04 && manufID != 0x7f)
  {
   // Serial.print("Unexpected Manufacturer ID: 0x"); Serial.println(manufID, HEX);
    return false;
  }
  if (prodID != 0x0302 && prodID != 0x7f7f)
  {
  //   Serial.print("Unexpected Product ID: 0x"); Serial.println(prodID, HEX);
    return false;
  }
*/
  /* Everything seems to be properly initialised and connected */
  _framInitialised = true;

  return true;

Pozostałe komendy wyglądają, że działają OK, zegar SPI na 8MHz Arduino działa na 4MHz, czyli jest aktywowana opcja SPI_CLOCK_DIV2 - podział/2.
Następnie wyglebuje się na sprawdzeniu jaki jest sposób adresowania pamięci, wg PDF mają być 2 bajty, sprawdza to wysyłając różne opcje, próbując zapisać i odczytać wybraną komórkę. No i jest problem właśnie z zapisem, raczej to się nie dzieje, więc jest komunikat o braku możliwości adresowania 2/3/4. 
Jest też ten drugi przykład, gdzie zapisuje coś++ do pierwszej komórki, co daje informację który to jest zapis, po resecie ta wartość powinna się zwiększyć, a potem robi odczyt całej pamięci. No i jest lipa, odczyt wygląda OK, wpadają różne wartości, nie są to same 0 lub FF, choć nie wiem dlaczego są różne na fabrycznym chipie, ale zapis nie działa. 
Znalazłem też inną bibliotekę, właśnie do tej pamięci, w spisie komend nie ma siódmej.
Ale też zapis nie działa. Może przetestuj ją u siebie:
https://github.com/pkourany/hackscribble-ferro-library
Może mam jakiś error na stykówce.
Jest też pokazany schemat połączenia, niby wszystko OK, ale zapis nie działa. Może jest z tym jakiś myk do zrobienia, że tym pinem trzeba jakoś zamachać przed zapisem (choć nie wiem po co mieli by to zmieniać), a nie tylko podłączyć do VCC, może pamięć jest lewa.
Ja na razie idę sprawdzić czy drzewa w lesie rosną. 

[kaczakat]

Ogarnąłem o co chodzi. Tak jak podejrzewałem pamięć była zabezpieczona przed zapisem. Biblioteka hackscribble działa OK, testuje pamięć w taki sposób, że odczytuje rejestr kontrolny, w nim są 3 nieużywane bity sterujące, zmienia ich stan na przeciwny, zapisuje, odczytuje i jak jest nowy stan odczytany  to zgłasza, że pamięć działa OK.

Ale są też dwa bity o ustawienia blokady zapisu, 4 opcje. 
   
Nie znalazłem funkcji by to zmienić w bibliotece i dopisałem.
Trzeba sobie dorzucić do plików cpp i h te dwie metody, do .h w public:
byte Hackscribble_Ferro::OdczytRejestru();
byte Hackscribble_Ferro:etWriteProtectBits(byte opcja);

Kod:

public:

    Hackscribble_Ferro(ferroPartNumber partNumber = MB85RS64, byte chipSelect = SS);
    ferroResult begin();
    ferroPartNumber getPartNumber();
    unsigned int getMaxBufferSize();
    unsigned int getBottomAddress();
    unsigned int getTopAddress();
    ferroResult checkForFRAM();
//////////////////////////////////////////////////////
    byte Hackscribble_Ferro::OdczytRejestru();
    byte Hackscribble_Ferro::setWriteProtectBits(byte opcja);
////////////////////////////////////////////////////////
    unsigned int getControlBlockSize();
    void writeControlBlock(byte *buffer);
    void readControlBlock(byte *buffer);
    ferroResult read(unsigned int startAddress, byte numberOfBytes, byte *buffer);
    ferroResult write(unsigned int startAddress, byte numberOfBytes, byte *buffer);
    unsigned int allocateMemory(unsigned int numberOfBytes, ferroResult& result);
    ferroResult format();

};

i do cpp, wstawiam z kawałkiem oryginalnej zawartości, by było widać gdzie (to między ///////////):

Kod:

    ferroPartNumber Hackscribble_Ferro::getPartNumber()
{
    return _partNumber;
}

unsigned int Hackscribble_Ferro::getMaxBufferSize()
{
    return _maxBufferSize;
}

unsigned int Hackscribble_Ferro::getBottomAddress()
{
    return _bottomAddress;
}

unsigned int Hackscribble_Ferro::getTopAddress()
{
    return _topAddress;
}
//////////////////////////////////////////////////////////////
byte Hackscribble_Ferro::OdczytRejestru()
{
byte registerValue = 0;

    // Read current value
    _select();
    SPI.transfer(_RDSR);
    registerValue = SPI.transfer(_dummy);
    _deselect();
return registerValue;
}

byte Hackscribble_Ferro::setWriteProtectBits(byte opcja)

    {
    const byte srMask = 0x0C; // Write protect bits are bits 2..3
    byte registerValue = 0;
    byte newValue = 0;    
        // Read current value
    _select();
    SPI.transfer(_RDSR);
    registerValue = SPI.transfer(_dummy);
    _deselect();    
    
    switch (opcja)
    {
    case 0:
    // set bits 2 and 3 to 0
    newValue = registerValue;    
    newValue&= ~(1<<2);
    newValue&= ~(1<<3);
    break;
    case 1:
    // set bits 2 to 1 and 3 to 0
    newValue = registerValue;    
    newValue|= (1<<2);
    newValue&= ~(1<<3);
    break;

    case 2:
    // set bits 2 to 0 and 3 to 1
    newValue = registerValue;    
    newValue|= (1<<3);
    newValue&= ~(1<<2);
    break;    
    case 3:
    // set bits 2 to 1 and 3 to 1
    newValue = registerValue;    
    newValue|= (1<<2);
    newValue|= (1<<3);
    break;        
    
    default:
    return registerValue;
    break;
    
    }



    
    // Write new value
    _select();
    SPI.transfer(_WREN);
    _deselect();
    _select();
    SPI.transfer(_WRSR);
    SPI.transfer(newValue);
    _deselect();    
    
            // Read current value
    _select();
    SPI.transfer(_RDSR);
    newValue = SPI.transfer(_dummy);
    _deselect();    
        return newValue;
    }
    
    
//////////////////////////////////////////////////////

ferroResult Hackscribble_Ferro::checkForFRAM()
{
    // Tests that the unused status register bits can be read, inverted, written back and read again
        
    const byte srMask = 0x70; // Unused bits are bits 6..4
    byte registerValue = 0;
    byte newValue = 0;
    boolean isPresent = true;
        
    // Read current value
    _select();
    SPI.transfer(_RDSR);
    registerValue = SPI.transfer(_dummy);
    _deselect();
        
    // Invert current value
    newValue = registerValue ^ srMask;
        
    // Write new value
    _select();
    SPI.transfer(_WREN);
    _deselect();
    _select();
    SPI.transfer(_WRSR);
    SPI.transfer(newValue);
    _deselect();
        
    // Read again
    _select();
    SPI.transfer(_RDSR);
    registerValue = SPI.transfer(_dummy);
    _deselect();
        
    if (((registerValue & srMask) == (newValue & srMask)))
    {
        return ferroOK;
    }
    else
    {
        return ferroBadResponse;    
    }
        
}

Potem skompilować i uruchomić raz szkic z ustawieniem na 0:

Kod:

#include <SPI.h>
#include <Hackscribble_Ferro.h>




void setup()
{
  // put your setup code here, to run once:
Serial.begin(115200);
  // Hackscribble_Ferro library uses standard Arduino SPI pin definitions:  MOSI, MISO, SCK.
  // Next statement creates an instance of Ferro using the standard Arduino SS pin and
  // default FRAM part number, MB85RS128A. Zmienilem na 64kbit w bibliotece
  Hackscribble_Ferro fram(MB85RS64);

  if (fram.begin() == ferroBadResponse)
  {
    Serial.println(F("FRAM response not OK"));
    while(1);
  }
  else
  {
    Serial.println(F("FRAM response OK"));
    printPartNumber(fram.getPartNumber());
    Serial.println(); 
    Serial.print("Odczyt rejestru kontrolnego: ");
    Serial.println(fram.OdczytRejestru(),2);
   
    Serial.println("Wyzerowanie blokady zapisu");
   
    Serial.println(fram.setWriteProtectBits(0),2);
  }
}
void loop()
{
  // put your main code here, to run repeatedly:

}



void printPartNumber(ferroPartNumber pn)
{
  switch(pn)
  {
    case MB85RS16:
    Serial.print("MB85RS16");
    break;
    case MB85RS64:
    Serial.print("MB85RS64");
    break;
    case MB85RS128A:
    Serial.print("MB85RS128A");
    break;
    case MB85RS128B:
    Serial.print("MB85RS128B");
    break;
    case MB85RS256A:
    Serial.print("MB85RS256A");
    break;
    case MB85RS256B:
    Serial.print("MB85RS256B");
    break;   
    default :
    Serial.print("unknown part number");
  }
}

Można podać też 1,2,3 i wtedy ustawi określoną część pamięci znowu w tryb do odczytu, a inne wartości tylko zwracają stan aktualny rejestru.
No i przykład z biblioteki test w końcu pokazał wartości zgodne z oczekiwaniami:

Kod:

HACKSCRIBBLE_FERRO TESTS
========================


Test: check for correct response from FRAM
Expected result: FRAM response OK; part number = MB85RS128A
Result ...
FRAM response OK
MB85RS64

Test: write zero-filled buffer to all available space in FRAM
Expected result: incrementing start address for each write; all result codes = 0
Result ...
40 0  80 0  C0 0  100 0  140 0  180 0  1C0 0  200 0  240 0  280 0  2C0 0  300 0  340 0  380 0  3C0 0  400 0  440 0  480 0  4C0 0  500 0  540 0  580 0  5C0 0  600 0  640 0  680 0  6C0 0  700 0  740 0  780 0  7C0 0  800 0  840 0  880 0  8C0 0  900 0  940 0  980 0  9C0 0  A00 0  A40 0  A80 0  AC0 0  B00 0  B40 0  B80 0  BC0 0  C00 0  C40 0  C80 0  CC0 0  D00 0  D40 0  D80 0  DC0 0  E00 0  E40 0  E80 0  EC0 0  F00 0  F40 0  F80 0  FC0 0  1000 0  1040 0  1080 0  10C0 0  1100 0  1140 0  1180 0  11C0 0  1200 0  1240 0  1280 0  12C0 0  1300 0  1340 0  1380 0  13C0 0  1400 0  1440 0  1480 0  14C0 0  1500 0  1540 0  1580 0  15C0 0  1600 0  1640 0  1680 0  16C0 0  1700 0  1740 0  1780 0  17C0 0  1800 0  1840 0  1880 0  18C0 0  1900 0  1940 0  1980 0  19C0 0  1A00 0  1A40 0  1A80 0  1AC0 0  1B00 0  1B40 0  1B80 0  1BC0 0  1C00 0  1C40 0  1C80 0  1CC0 0  1D00 0  1D40 0  1D80 0  1DC0 0  1E00 0  1E40 0  1E80 0  1EC0 0  1F00 0  1F40 0  1F80 0  1FC0 0 

Test: read subset of data back from FRAM
Expected result: result code = 0; each value = 0
Result ...
0
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 

Test: fill buffer with test data
Expected result: incrementing data starting at 42
Result ...
42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99  100  101  102  103  104  105 

Test: write buffer to FRAM
Expected result: result code = 0
Result ...
0

Test: read subset of data back from FRAM
Expected result: result code = 0; twenty incrementing values starting at 72
Result ...
0
72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90  91 

Przy uruchomieniu przykładów lub własnych programów trzeba sygnalizować, że używa się tej pamięci tworząc jej instancję:

Kod:

    // Hackscribble_Ferro library uses standard Arduino SPI pin definitions:  MOSI, MISO, SCK.
    // Next statement creates an instance of Ferro using the standard Arduino SS pin and
    // default FRAM part number, MB85RS128A.
    Hackscribble_Ferro myFerro(MB85RS64);

Ja w swoim szkicu akurat mam Hackscribble_Ferro fram(MB85RS64);

[brendy]

No Panie jesteś Wielki. Szacun! Rozgryzłeś temat palce lizać... Moje Gratulacje!
Zagadał czyli jest ok?

Kod:

HACKSCRIBBLE_FERRO TESTS
========================


Test: check for correct response from FRAM
Expected result: FRAM response OK; part number = MB85RS128A
Result ...
FRAM response OK
MB85RS64

Test: write zero-filled buffer to all available space in FRAM
Expected result: incrementing start address for each write; all result codes = 0
Result ...
40 0  80 0  C0 0  100 0  140 0  180 0  1C0 0  200 0  240 0  280 0  2C0 0  300 0  340 0  380 0  3C0 0  400 0  440 0  480 0  4C0 0  500 0  540 0  580 0  5C0 0  600 0  640 0  680 0  6C0 0  700 0  740 0  780 0  7C0 0  800 0  840 0  880 0  8C0 0  900 0  940 0  980 0  9C0 0  A00 0  A40 0  A80 0  AC0 0  B00 0  B40 0  B80 0  BC0 0  C00 0  C40 0  C80 0  CC0 0  D00 0  D40 0  D80 0  DC0 0  E00 0  E40 0  E80 0  EC0 0  F00 0  F40 0  F80 0  FC0 0  1000 0  1040 0  1080 0  10C0 0  1100 0  1140 0  1180 0  11C0 0  1200 0  1240 0  1280 0  12C0 0  1300 0  1340 0  1380 0  13C0 0  1400 0  1440 0  1480 0  14C0 0  1500 0  1540 0  1580 0  15C0 0  1600 0  1640 0  1680 0  16C0 0  1700 0  1740 0  1780 0  17C0 0  1800 0  1840 0  1880 0  18C0 0  1900 0  1940 0  1980 0  19C0 0  1A00 0  1A40 0  1A80 0  1AC0 0  1B00 0  1B40 0  1B80 0  1BC0 0  1C00 0  1C40 0  1C80 0  1CC0 0  1D00 0  1D40 0  1D80 0  1DC0 0  1E00 0  1E40 0  1E80 0  1EC0 0  1F00 0  1F40 0  1F80 0  1FC0 0 

Test: read subset of data back from FRAM
Expected result: result code = 0; each value = 0
Result ...
0
0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 

Test: fill buffer with test data
Expected result: incrementing data starting at 42
Result ...
42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99  100  101  102  103  104  105 

Test: write buffer to FRAM
Expected result: result code = 0
Result ...
0

Test: read subset of data back from FRAM
Expected result: result code = 0; twenty incrementing values starting at 72
Result ...
0
0  0  0  4  30  41  170  110  5  46  84  0  1  1  1  1  0  0  0  12 

Test: read test data from control block
Expected result: each value = 123
Result ...
0  0  0  0  0  0  0  110  5  46  84  0  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 

Test: read test data from control block
Expected result: each value = 43
Result ...
0  0  0  0  0  0  0  110  5  46  84  0  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 

Test: create a FerroArray of struct
Expected result: result code = 0; start address of array = 64
Result ...
0
64

Test: create a FerroArray of float
Expected result: result code = 0; start address of array = 224
Result ...
0
224

Test: create a FerroArray of int
Expected result: start address of array = 1024
Result ...
1024



FREE MEMORY: 1602

Test: write struct with test data to array
Expected result: 14123456, 1234, 4320; result code = 0
Result ...
14123456    1234    4320
0

Test: read test data from array into a new struct
Expected result: result code = 0; 14123456, 1234, 4320
Result ...
0
0    0    0

Test: write float with test data to array
Expected result: 3.14; result code = 0
Result ...
3.14
0

Test: read test data from array into a new struct
Expected result: result code = 0; 3.14
Result ...
0
0.00

Test: write int with test data to array
Expected result: -123; result code = 0
Result ...
-123
0

Test: read test data from array into a new int
Expected result: result code = 0; -123
Result ...
0
257

Test: format the FRAM and read subset of data
Expected result: result codes = 0 and 0; each value = 0
Result ...
0
0
0  0  0  4  30  41  170  110  5  46  84  0  1  1  1  1  0  0  0  12 

Test: read test data from control block
Expected result: each value = 43
Result ...
0  0  0  0  0  0  0  110  5  46  84  0  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 



FREE MEMORY: 1602



END OF TESTS
============

[kaczakat]

U Ciebie coś jest nie tak.
To coś:

Kod:

Test: write struct with test data to array
Expected result: 14123456, 1234, 4320; result code = 0
Result ...
14123456    1234    4320
0

Test: read test data from array into a new struct
Expected result: result code = 0; 14123456, 1234, 4320
Result ...
0
0    0    0

Powinno wyglądać tak:

Kod:

Test: write struct with test data to array
Expected result: 14123456, 1234, 4320; result code = 0
Result ...
14123456    1234    4320
0

Test: read test data from array into a new struct
Expected result: result code = 0; 14123456, 1234, 4320
Result ...
0
14123456    1234    4320

Czyli zapisuje dane w bloku write i potem odczytuje te same w read, a u Ciebie odczytał 0, czyli nic nie zapisał.

Jak wgrasz ten szkic do zerowania rejestru kontrolnego to powinieneś odczytać coś takiego na serial:

Kod:

FRAM response OK
MB85RS64
Odczyt rejestru kontrolnego: 1110000
Wyzerowanie blokady zapisu
1110000
FRAM response OK
MB85RS64
Odczyt rejestru kontrolnego: 0
Wyzerowanie blokady zapisu
0

Po każdym resecie te trzy 111 zamieniają się na zera i potem z powrotem z 000 (czyli 0, bo nie drukuje zer wiodących) na 111. W zablokowanej za pierwszym razem miałem jedynki na bitach 2 i 3, wyglądało to tak 1111100  lub 1100.

Poza tym akurat ta biblioteka nie obsługuje ESP. Ale po wyzerowaniu tych bitów i powrocie do biblioteki Adafruit, a w niej po zakomentowaniu bloku programu do odczytu ID jak we wcześniejszym poście w okolicach linii 110, można wgrać program przykładowy FRAMINFO (zmień prędkość serial na 115200, albo w monitorze na 9600) i powinno wypluć na serial: 

Kod:

Found SPI FRAM
SPI FRAM address size is 2 bytes.
SPI FRAM capacity appears to be..
8192 bytes
8 kilobytes
64 kilobits

Potem można już używać biblioteki Adafruit z ESP.

[brendy]

Bardzo mi zależy żeby to poszło na adafruit bo do ESP potrzebuje. A wyslabys mi już przerobiona Biblię pod Adafruit?
W połączeniach dajesz jakiś rezystor po jakiś pin fram? Czy tylko zasilanie i pod SPI proca?

[kaczakat]

W połączeniach masz OK, bo biblioteka odpowiada z pamięci "FRAM response OK", to znaczy, że do rejestru kontrolnego zapisał i odczytał te zmienione 111.
Ja połączyłem piny do VCC, można dać rezystor PULLUP, podłączenie HOLD do GND powoduje brak odpowiedzi z pamięci.
Podłączenie WP do GND powinno zablokować zapis do status register, ale tego nie testowałem. 
Tymczasem nie masz tego zablokowanego bo jest ten "response OK".
Wgrałeś ten szkic do zerowania pamięci? On jest w poście #15, skopiuj do nowego szkicu, skompiluj i wgraj.
Oczywiście po edycji biblioteki.
Zresztą masz obie przerobione w załączniku i szkic do zerowania.

[brendy]

kaczakat Dziękuje za biblioteki. To może chociaż na jakąś dobrą flachę? chciałbym się odwdzięczyć. 
Teraz jest git spr na pro mini 3.3V. Jeszcze wieczorem zrobie test na adafruit z ESP. Muszę iśc liście pograbić...

Kod:

YY⸮⸮FRAM response OK
MB85RS64
Odczyt rejestru kontrolnego: 1110000
Wyzerowanie blokady zapisu
1110000
FRAM response OK
MB85RS64
Odczyt rejestru kontrolnego: 0
Wyzerowanie blokady zapisu
0
FRAM response OK
MB85RS64
Odczyt rejestru kontrolnego: 1110000
Wyzerowanie blokady zapisu
1110000
FRAM response OK
MB85RS64
Odczyt rejestru kontrolnego: 0
Wyzerowanie blokady zapisu
0