EEPROM I2C - text, caractere sau symbol-uri pt LCD Grafic

[Vizitator]

Salut!

Am de facut un proiect cu Arduino Nano, si memoria nu imi este suficienta. Mai am nevoie de 2-3Kb.

Am incercat sa scriu si sa citesc texte, numere de pe un EEPROM 24C16.

 

Cum s-ar putea folosi o memorie EEPROM pe I2C - 24C256 - , pentru a fi scrisa, si apoi citita, continand mai multe symboluri  pe un display grafic, de exemplu OLED?

Ca exemplu - static const unsigned char PROGMEM logo16_glcd_bmp[] = :

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

#define OLED_RESET 4
Adafruit_SH1106 display(OLED_RESET);

#define NUMFLAKES 5 // 10 = nr de obiecte
#define XPOS 0
#define YPOS 1
#define DELTAY 2


#define LOGO16_GLCD_HEIGHT 16 
#define LOGO16_GLCD_WIDTH  16 
static const unsigned char PROGMEM logo16_glcd_bmp[] =
{ B00000000, B11000000,
  B00000001, B11000000,
  B00000001, B11000000,
  B00000011, B11100000,
  B11110011, B11100000,
  B11111110, B11111000,
  B01111110, B11111111,
  B00110011, B10011111,
  B00011111, B11111100,
  B00001101, B01110000,
  B00011011, B10100000,
  B00111111, B11100000,
  B00111111, B11110000,
  B01111100, B11110000,
  B01110000, B01110000,
  B00000000, B00110000 };
  
  ...

 

[modoran]

PROGMEM nu are ce cauta aici daca nu ai spatiu in flash.  Sa utilizezi memorie externa trebuie sa o citesti pe I2C la runtime, un exemplu aiciȘ

http://www.hobbytronics.co.uk/arduino-external-eeprom

 

Eu as utiliza alt procesor daca aplicatia cere mai multe resurse, cum ar fi STM32F103C8 ( costa tot cam atat ca un arduino la chinezi ), dar faci cum vrei.

Editat Iulie 15, 2018 de modoran

[Vizitator]

Am incercat cu doua module de nano pe I2C sau pe Serial. Unul ca port intrari/iesiri, si celalat pentru controlul display-ului. primul trimite un cod de la 0 la 10 (de exemplu), si prin case-uri afisez starea intrarilor iesirilor - https://www.youtube.com/watch?v=nD-7BWScAyw - cu cel de-al doilea nano, 3 intrari si 3 iesiri. Am mai cosmetizat un pic codul de am mai redus ceva din el, dar tot nu am coborat prea mult din spatiu.

Am primit de curand un STM32F103C8, dar nu am reusit decat sa ma joc cu porturile ca intrari/iesiri. Dar sa functioneza cu un OLED 1.3"_SH1106 , nu am reusit deloc. 

Am comandat si un mega2560 micro, dar pana vineeee, si daca mai vine, ca a trecut ceva timp :( . Si de fapt imi mai tebuie doar cativa kb, 2-4 maxim.

 

Am testat de pe aceasta pagina http://www.hobbytronics.co.uk/arduino-external-eeprom exemplele, si le-am simulat in Proteus. dar tot nu prind ideea cum as putea sa incarc un symbol.

[nico_2010]

Schimba libraria Adafruit GFX si cea pentru OLED cu altele, sau rescrie cele doua librarii, astfel incat sa obtii cei 2-3kB necesari. Si cu STM32 vei pati acelasi lucru

[deejay2k1]

Ai mai intrebat si in alt thread despre I2C eeprom, metodele necesare sunt postate acolo.

Acum , daca vrei sa incarci simboluri (care de fapt sunt 'imagini' pe oled-ul tau) arbitrare, ia in calcul o tabela de alocare, intrucat dimensiunile array-urilor care contin elementele tale nu sunt fixe.

 

Sau, le poti face fixe, egale cu dimensiunile ecranului , si face OR intrele ele, un fel de layere.

[mihaicozac]

Elementele din arie fiind bytes se pretează bine la citire/scriere în EEPROM însă pt. afişare cred că ar trebui făcută conversie într-o arie de biţi separaţi apoi aceştia afişaţi ca pixeli individuali fiecare cu propriile coordonate sau incrementându-le automat folosind o buclă dublă "for", una pt. orizontală cealaltă pt. verticală.

[Vizitator]

Se pare ca este un pic cam complicat pt unul care nu este programator. Am sapat pe google si in alte limbi, dar nu am gasit nicaieri un exemplu cat de mic. probabil nu prea se foloseste pt asa ceva.

 

Va multumesc tuturor pt sfaturi!

 

Apropo, nico_2010 mi-a sugerat sa schimb librariile Adafruit . Ce librarie imi recomandati pt un OLED 1.3 - SH1106? 

Editat Iulie 16, 2018 de Vizitator

[nico_2010]

Foloseste u8g library.

[informer]

3 hours ago, va_cristi said:

Apropo, nico_2010 mi-a sugerat sa schimb librariile Adafruit . Ce librarie imi recomandati pt un OLED 1.3 - SH1106? 

 

Ti-as sugera sa te inspiri si de aici: https://github.com/ThingPulse/esp8266-oled-ssd1306

Personal n-am folosit-o pe Arduino/ESP dar am modificat-o pt. PIC8 si functioneaza foarte bine atat pt. display-urile cu 128 coloane cat si pt. cele cu 132 (SSD1306 / SH1106).

Deasemenea poti afla unde sa-ti generezi font-uri daca nu-ti plac alea 3 care-s deja acolo.

[Vizitator]

nico_2010, am incercat mai de mult aceste librarii u8glib si u8g2. Mi se par cam "grele" pt mine, fata de Adafruit. Cea de pe http://www.rinkydinkelectronics.com/library.php?id=79 ,  este mult mai simpla de utilizat, dar, aceasta nu merge pe SH1106, merge doar pe OLED I2C-SSD306 . Ca sa modific libraria   .

Oricum, din ce am vazut si pe net, nu prea se foloseste EEPROM-ul la ce vreau eu. Proiectul meu, ori il scurtez, ori folosesc doua module de arduino nano, sau doua de pro mini cu comunicare intre ele I2C, sau seriala.

Multumesc tutror celor care ati postat.

Rog moderatorul sa ia atitudine asupra acestui topic daca nu este de interes.

 

Editat Iulie 17, 2018 de Vizitator

[PKP98]

Salut!

Si eu lucrez la ceva asemanator,doar ca folosesc un ATmega16 .

Acum 22 ore, va_cristi a spus:

Oricum, din ce am vazut si pe net, nu prea se foloseste EEPROM-ul la ce vreau eu.

Initial eu am vrut sa afisez pe un OLED 128X64 (I2C) niste imagini (pentru un meniu),iar prima problema peste care am dat a fost memoria SRAM care pentru un ATmega16 este de 1Kbyte ,adica fix o imagine 128x64=1024byte,iar la prima compilare in ATMEL STUDIO 7 memoria SRAM era peste 100%.Urmatoare idee a fost sa folosec o memorie EEPROM 24C32 pentru a stoca pe ea 4 imagini,iar a doua problema peste care am dat a fost "Cum incarc imaginile in memoria EEPROM???".Am scris repede un cod pentru un ATMEGA328  cu 2Kbyte SRAM si am scris cate 512byte dintr-o imagine,adica jumatate din ea(nici asta nu avea destula memorie SRAM pentru a lucra cu o imagine),astfel pentru 4 imagini am facut 8 scrieri (a fost o solutie de moment pe care o recomand doar daca nu ai alta solutie :))...mai buna).Dupa asta am rescris un cod pentru ATmega16 care de data aceasta foloseste doar 0.1% din memoria SRAM ,adica un byte.

Deci eu folosesc cu succes memoria EEPROM si imi place chiar foarte mult .....folosesc doar doi pini de la ATmega16 cei responsabili cu comunicarea I2C,ador chestia asta de fapt!

Uite un filmulet cu jucaria mea:https://imgur.com/eCP8MgM

 

[Vizitator]

Felicitari PKP98. Din postul tau si filmulet am inteles ca se poate folosi un EEPROM pt imagini. Multumesc pt incurajare  .

[PKP98]

Sigur ca se poate,ideea este sa reusesti sa comunici cu ele (memoria eeprom si OLED-ul) si sa le folosesti optim ,iar cu un Arduino este foarte simplu pentru ca ai o gramada de biblioteci deja create..eu am facut cu un ATmega16 pentru ca am vrut sa-mi fac eu librariile si sa  invat si acest protocol de comunicare I2C care este pur si simplu SUPERB.Sincer,eu nu folosesc Arduino pentru ca desii poti sa faci proiecte complexe ca si incepator....nu ma satisfac absolut deloc... ba chiar mai rau ma enerveaza pentru ca nu stiu cum functioneaza :)))

Prefer sa ma chinui cu foaia de catalog de la microprocesor si tutoriale "blana"...daca intelegi baza o sa vezi ca Arduino e banal de simplu.

 

In alta ordine de idei,priveste memoria unui EEPROM  ca pe un sir de caractere,de exemplu un 24c02 care are 256byte poate fi asociat cu :  unsigned char 24c02[256].Citeste bine foaia de catalog  de la EEPROM-ul pe care il alegi.

Daca ai alte intrebari...nu ezita,cred ca te pot ajuta si cu codul pentru Arduino.

[Vizitator]

Salutare tuturor!

Pentru ca nu am putut sa ma abtin, fiind incurajat de PKP98 vizualizand filmuletul postat, si de ceilalti colegi, am reusit sa incarc un 24AA256 cu fisiere HEX.

Libraria folosita se gaseste aici.

 

Codul pentru incarcare HEX_demo:

#include <Wire.h>
#include <AT24CX.h>

// EEPROM object
AT24CX mem;

// setup
void setup() {
  // serial init
  Serial.begin(115200);
  Serial.println("AT24CX read/write demo");
  Serial.println("----------------------");
}

// main loop
void loop() {

  // write array of bytes
  byte xy[] = {
    0X00, 0X70, 0X0F, 0XE0, 0X03, 0XE0, 0X01, 0XC0, 0X07, 0X3F, 0X80, 0X07, 0XFE, 0X38, 0X00, 0X00,

  };

  byte yy[] = {
    0X01, 0X80, 0X01, 0X80, 0X01, 0X80, 0X01, 0X80, 0X01, 0X80, 0X01, 0X80, 0X01, 0X82,
  };

  mem.write(0, (byte*)xy, sizeof(xy));

  mem.write(20, (byte*)yy, sizeof(yy));
}

 

si codul pentru citirea EEPROM-ului_demo:

// include libraries
#include <Wire.h>
#include <AT24CX.h>

// EEPROM object
AT24CX mem;

// setup
void setup() {
  // serial init
  Serial.begin(115200);
  Serial.println("AT24CX read/write demo");
  Serial.println("----------------------");
}

// main loop
void loop() {
 // read EEPROM
  byte xy[16];
  byte yy[14];

  // read bytes with multiple steps
  Serial.println("Read 16 single bytes starting at address 0 => 0 > 15");
  for (int i = 0; i < sizeof(xy); i++) {
    byte sb = mem.read(0 + i);
    Serial.print("[");
    Serial.print(0+i);
    Serial.print("] = ");
    Serial.println(sb, HEX);
  }
Serial.println(" ");
  Serial.println("Read 14 single bytes starting at address 20 => 20 > 33");
  for (int i = 0; i < sizeof(yy); i++) {
    byte sc = mem.read(20 + i);
    Serial.print("[");
    Serial.print(20+i);
    Serial.print("] = ");
    Serial.println(sc, HEX);
  }
  // Serial.println();

  // stop
  while (1 == 1) {}
}

Rezultatul obtinut in simulator:

 

, si rezultatul real folosind un Arduino Nano si un EEPROM 24AA256:

 

Acuma mai ramane sa pot folosi EEPROM-ul pt a afisa pe un display OLED symbol-uri sau imagini monochrome.

Daca aveti un sfat, o idee, nu ma lasati sa ma chinuiesc prea mult , ca ce a fost mai greu sper ca am reusit  cu ajutorul librariei AT24Cx.

Intre timp o sa ma straduiesc si eu sa vad cum pot sa afisez symbol-uri,... folosind EEPROM-ul.

Multa sanatate tuturor  !

Editat Iulie 21, 2018 de Vizitator