Arduino.ru

Определите указатель на массив байт.  А потом присвойте ему адрес float

нахрена такие сложности?

float pi = 3.1415926;

EEPROM.put(Адрес, pi);

float pi2;

EEPROM.get(Адрес, pi2);

Serial.print(pi2);

ну или через массив

template<typename T>
size_t SaveToRom(const size_t AAddress, T &AValue) {
	uint8_t *valueptr = (uint8_t *)(&AValue);
	for (uint8_t i = 0; i < sizeof(T); i++) EEPROM.put(AAddress, *valueptr++);  // старшим байтом вперёд
	return sizeof(T);
}

чтение оналогична. 

Это внешний EEPROM. И  в библиотеке Eeprom24C01_02 нету методов put и get 

Тогда зачем эта помойнаябиблиотеке нужна

Да, я невнимательная пьянь. :( 

Добавить методы и сделать также.

Ну, это тоже лишние сложности. Всё делается также, как и раньше

float massiv [] = { 2.87, 3.62, 4.12 };

EEPROM.put(Адрес, massiv);

float massiv [] = { 2.87, 3.62, 4.12 };

EEPROM.put(Адрес, massiv);

А put рази не запишет в ROM, в этом случае, не сам massiv, а адрес его начала в ОЗУ?

ему же float * передается, без длины.  Или я тупой навовсе?  

float massiv [] = { 2.87, 3.62, 4.12 };

EEPROM.put(Адрес, massiv);

3.62 - из другого массива.

Еще небольшой комментарий. Логичнее начинать использование EEPRAM так

byte M1[2]; // некий массив 1
byte* M1_adr = 0; // адресс в eepram  массива 1 где значения можно скачать
int M2[2]; // некий массив 2
int* M2_adr =(int*)&M1_adr[2]; // адресс в eepram  массива 2 где значения можно скачать
/*ну и так даллее*/
void setup() {
}

void loop() {

}

Но кривые библиотеки на это не рассчитаны .

Ему передаётся float massiv [], у которого вполне правильный sizeof. Точняк, спроси у Рабиновича :-)

Давай таки проверим. Вот оригинальная put из библиотеки EEPROM

    template< typename T > const T &put( int idx, const T &t ){
        EEPtr e = idx;
        const uint8_t *ptr = (const uint8_t*) &t;
        for( int count = sizeof(T) ; count ; --count, ++e )  (*e).update( *ptr++ );
        return t;
    }

давай напишем точно такую же, но не будем ничего никуда пхать, а просто параметры напечатаем:

#include <Printing.h>

 template< typename T > const T &kaka( int idx, const T &t ){
	const uint8_t *ptr = (const uint8_t*) &t;
	printf("idx=%d; ptr=%p; sizeof=%u\r\n", idx, ptr, sizeof(T));
	return t;
 }

float massiv [] = { 2.87, 3.62, 4.12 };

void setup(void) {
	Serial.begin(57600);
	printf("massiv=%p\r\n", massiv);
	kaka(0, massiv);
}

void loop(void){}

//////////////////
//
// 	Результат
// massiv=0x100
// idx=0; ptr=0x100; sizeof=12
//

Как видишь, и адрес начала, и sizeof - всё на месте. Так с чего ему не работать?

// 	Результат
// massiv=0x100
// idx=0; ptr=0x100; sizeof=12
//

Нихрена не понимаю.  :(   Нада, какабычно, напицца. 

Из темплейта компилятором будет создана функция для обработки float[3] (а не float*) , таким образом - внутри неё уже будет известен размер структуры данных.

понятно. А для float[5]  создасца совсем другой шаблон?  

Из этого же шаблона создастся вторая функция, но для float[5]. И третья для float[9]... Поэтому, честно говоря, бездумное применение функции put() мне представляется разбазариванием ресурсов МК.

А что более простого примера для еепром, который бы не тащил за собой и меню, и кнопку, и lcd нету?

А что выдернуть Вы не сможете. Там же все прозрачно.

#include <EEPROM.h>
const byte* adr = 0;
void setup() {
  Serial.begin(9600);
  EERef aaa((int)adr);
  aaa = 5;
  Serial.println(aaa);// выведено 5
  aaa += 5;
  Serial.println(aaa);// выведено 10

}

void loop() {


}

У шаблона похожее будет

Выдернул, посмотрел. К сожалению, даже на даже на беглый взгляд, количество ошибок зашкаливает. Я даже не говорю про идейные странности - только про простые программные ляпы. Но, как Вы неоднократно писали мне и другим в той теме, баг-репорты Вас не интересуют, и учить Вас не надо. Это в силе? Или Вы передумали, и Вам интересен баг-репорт?

Зачем. Что бы править надо понимать зачем и почему. Как вы можете править мои баги, если я смутно понимаю как и почему.

Но похоже и автор EEPROM тоже в этом плавал. Иначе того шаблона не существовало. Он лишний.

Ну, как хотите. Если Вам нравится публиковать коды с большим количеством ошибок, и не нравится узнавать об этих ошибках, не могу Вам запретить этого :)

Мне не хочется исправлять не только свои ошибки, но и чужие. Так что обойдусь.

Ну, и ладненько.

byte M1[2]; // некий массив 1
byte* M1_adr = 0; // адресс в eepram  массива 1 где значения можно скачать
int M2[2]; // некий массив 2
int* M2_adr =(int*)&M1_adr[2]; // адресс в eepram  массива 2 где значения можно скачать
/*ну и так даллее*/
void setup() {
}

void loop() {

}

Пух, ты чё курил?

Спасибо вам всем большое, но я еле еле разобрался с это библиотекой так как самая простая для меня, то что вы написали думаю конечно правильно, но я не фига не вдупляю))) и коньяк и водка мне не помогут).

В моем примере запись и чтение работают хорошо косяк идет при получении числа из массива. Хотя может и при разбивке уже фигня идет. 

Если не сложно тыкните носом в коде где косяк.

#include <Wire.h>

#include <Eeprom24C01_02.h>

#define EEPROM_ADDRESS  0x50 

static Eeprom24C01_02 eeprom(EEPROM_ADDRESS);
byte            REG_Massive[4];
long            tmp =2147483647;
byte            REG_MassiveR[4];
long t;
int a0=1;
int a1=2;
int a2=3;
int a3=4;
void setup()
{
    // Initialize serial communication.
    Serial.begin(9600);
        
    // Initialize EEPROM library.
    eeprom.initialize();

}

void loop()
{
 
   REG_Massive[0] = tmp>>24;
   REG_Massive[1] = tmp>>16;
   REG_Massive[2] = tmp>>8;    // разбиваю число на байты и записываю в массив
   REG_Massive[3] = tmp;
   Serial.println("Write byte to EEPROM memory...");
   Serial.println(tmp);
    Serial.print("REG_Massive[0]=======");
    Serial.println(REG_Massive[0],BIN);
    Serial.print("REG_Massive[1]=======");
    Serial.println(REG_Massive[1],BIN);
    Serial.print("REG_Massive[2]=======");
    Serial.println(REG_Massive[2],BIN);
    Serial.print("REG_Massive[3]=======");
    Serial.println(REG_Massive[3],BIN);
    
    // Write a byte at address 0 in EEPROM memory.
    
    eeprom.writeByte(a0, REG_Massive[0]); //запись 1-го байта 
    delay(50);
    eeprom.writeByte(a1, REG_Massive[1]); //запись 2-го байта 
    delay(50);
    eeprom.writeByte(a2, REG_Massive[2]); //запись 3-го байта 
    delay(50);
    eeprom.writeByte(a3, REG_Massive[3]); //запись 4-го байта
    // Write cycle time (tWR). See EEPROM memory datasheet for more details.
    delay(10);
    
    // Read a byte at address 0 in EEPROM memory.
    Serial.println("Read byte from EEPROM memory...");
     REG_MassiveR[0]= eeprom.readByte(a0); // считываю байты и записываю в массив
     REG_MassiveR[1]= eeprom.readByte(a1);
     REG_MassiveR[2]= eeprom.readByte(a2); // считываю байты и записываю в массив
     REG_MassiveR[3]= eeprom.readByte(a3);
    t   = REG_MassiveR[0]<<24;
    t  += REG_MassiveR[1]<<16;
    t  += REG_MassiveR[2]<<8;
    t  += REG_MassiveR[3]; // преобразую байты из массва в число.
    // Print read byte.
    
    Serial.print("REG_MassiveR[0]=======");
    Serial.println(REG_MassiveR[0],BIN);
    Serial.print("REG_MassiveR[1]=======");
    Serial.println(REG_MassiveR[1],BIN);
    Serial.print("REG_MassiveR[2]=======");
    Serial.println(REG_MassiveR[2],BIN);
    Serial.print("REG_MassiveR[3]=======");
    Serial.println(REG_MassiveR[3],BIN);
    Serial.println(t);
   
    delay(4000);
}

монитор выдает

long  toEeprom = 2147483647;
long  fromEeprom = 0;
byte  address = 1;
...
eeprom.writeBytes(address, sizeof(toEeprom), (byte*) &toEeprom);
Serial.println(toEeprom);
...
eeprom.writeBytes(address, sizeof(fromEeprom), (byte*) &fromEeprom);
Serial.println(fromEeprom);
...

Век живи - век учись, дураком помрешь. А я, дурак, вписывал (температура*10-константа) в байт.

Но все равно - Учится, учится и еще раз учится!

к сожалению не понимаю как, но  работает ток  8 строчка readBytes  )) Спасибо большое.

Я так понял, ответа на #28 не будет? Ну, да, и хрен с ним. Только, я тебя прошу, будь другом, не превращайся в Великого. Вот этого не надо:

Кривизна wiring, это его тема, а не твоя.

Да, копипастнул я лихо.

Работает так:

1) Функции writeBytes()/readBytes() требуют адрес байтового массива и его размер;
2) Байтовый массив есть последовательность ячеек, а имя его - алиас адреса нулевой (начальной ячейки), т.е. указатель на него;
3) Тип данных long (а так же float) есть байтовый массив, при вычислениях интерпретируемый особый образом;
4) sizeof() возвращает размер заданной переменной в байтах;

Итого: берём адрес (через операцию &) переменной типа long (фактически - байтового массива), затем обманываем функцию  (через byte*), заставляя рассматривать данный адрес как указатель на байтовый массив. Таким образом, функция получает адрес начала байтового массива и его размер, а с ними она уже умеет работать. Внутри себя функция бежит по этому массиву и пишет (или читает) его последовательно.

asam дал наводку на это в #1.

В первых версиях библиотеки EEPROM.h методов put()/get() не было использовал такие функции.

Для float все точно так же, только тип данных другой

long EEPROM_long_read(int addr) { //передаем в функцию адрес ячейки из которой читать
byte raw[4]; for(byte i = 0; i < 4; i++) raw[i] = EEPROM.read(addr+i); long &num = (long&)raw; 
return num; } //возвращает считанное значение

//====================

//функция записи в EEPROM переменной типа long
  void EEPROM_long_write(int addr, long num){//передаем в функцию адрес куда писать и данные что писать
 byte raw[4]; (long&)raw = num; for(byte i = 0; i < 4; i++) EEPROM.write(addr+i, raw[i]); }//ничего не возвращает

Kakmyc,

если уж делать без шаблонов, то лучше всё-таки везде писать не 4, а sizeof(long).

Тогда уж sizeof(num).

Может сразу типа этого:

inline uint16_t EEPROM_write(uint16_t _address, uint32_t _number) {
  return EEPROM_write(_address, (uint8_t*) &_number, sizeof(_number));
}

inline uint16_t EEPROM_write(uint16_t _address, float _number) {
  return EEPROM_write(_address, (uint8_t*) &_number, sizeof(_number));
}

inline uint16_t EEPROM_write(uint16_t _address, uint64_t _number) {
  return EEPROM_write(_address, (uint8_t*) &_number, sizeof(_number));
}

uint16_t EEPROM_write(uint16_t _address, uint8_t* _ptrData, uint16_t _sizeData) {
  for (uint16_t i = 0x00; i < _sizeData; i++) {
    EEPROM.update(_address, *_ptrData);
    _address++;
    _ptrData++;
  }
  return _sizeData;
}

...

  uint16_t eepromAddress = 0x00;
  float nFloat = 1.236;
  uint64_t n64bit = 135467ULL;
  eepromAddress += EEPROM_write(eepromAddress, nFloat);
  eepromAddress += EEPROM_write(eepromAddress, n64bit);

Тогда уж сразу шаблон

Можно и шаблон, но с этим, как я вижу, пока проблемы когнитивного характера наблюдаются.