Дописал get и put, починил

libraries/EEPROM/src/EEPROM.cpp

@@ -88,13 +88,16 @@ void EEPROMClass:: update( int idx, uint8_t val )
     uint32_t byte_idx  = ((uint32_t)idx) % EEPROM_WORD_SIZE;
     // Извлечение нужного байта
     uint32_t byte      = ((uint32_t)val) << ((EEPROM_WORD_SIZE - byte_idx - 1) * 8);
+    // uint8_t  oldVal    = (uint8_t)(( write_data_buf[word_idx] & (((uint32_t)0xFF) << ((EEPROM_WORD_SIZE - byte_idx - 1) * 8)) ) >> ((EEPROM_WORD_SIZE - byte_idx - 1) * 8)); 
+    uint8_t  oldVal    = (uint8_t)(*((uint8_t*)write_data_buf + word_idx + (EEPROM_WORD_SIZE - byte_idx - 1))); 
     // Проверка того, что записанный байт отличается от нового
-    if((uint8_t)(( write_data_buf[word_idx] & (((uint32_t)0xFF) << ((EEPROM_WORD_SIZE - byte_idx - 1) * 8)) ) >> ((EEPROM_WORD_SIZE - byte_idx - 1) * 8)) != val)
+    if( oldVal != val )
     {  
         // Очистка нужной страницы
         HAL_EEPROM_Erase(&heeprom, (uint16_t)addr, EEPROM_PAGE_WORDS, HAL_EEPROM_WRITE_SINGLE, EEPROM_OP_TIMEOUT);
         // Вычленение и замена нужного байта из страницы
         write_data_buf[word_idx] = (write_data_buf[word_idx] & (~((uint32_t)(0xFF) << ((EEPROM_WORD_SIZE - byte_idx - 1) * 8)))) | byte;
+
         HAL_EEPROM_Write(&heeprom, (uint16_t)addr, write_data_buf, EEPROM_PAGE_WORDS, HAL_EEPROM_WRITE_SINGLE, EEPROM_OP_TIMEOUT);
     }
 }

libraries/EEPROM/src/EEPROM.h

@@ -171,10 +171,7 @@ struct EEPROMClass{
         HAL_read((uint16_t)addr, write_data_buf);
         // Если данные не влезут на первую страницу, то записываем только то, что влезло
         if (EEPROM_PAGE_SIZE - byte_addr < dataSize)
-        {
             writeSize = EEPROM_PAGE_SIZE - byte_addr;
-            // lastWord  = EEPROM_PAGE_WORDS - 1;
-        }
         uint32_t lastWord = (writeSize + byte_idx - 1) / EEPROM_WORD_SIZE + word_idx;
         dataSize -= writeSize;
         // Запись данных постранично, сначала записываем первую страницу - отдельно
@@ -186,24 +183,17 @@ struct EEPROMClass{
             write_data_buf[i] = 0;
             write_data_buf[i] = ((word & 0xFF)<<24) | ((word & (0xFF<<8))<<8) | ((word & (0xFF<<16))>>8) | ((word & (0xFF<<24))>>24);
         }
-        // for (uint8_t i = 0; i < writeSize; i++, dataPointer_8++)
-        //     *(writePointer_8 + byte_addr + i) = *(dataPointer_8);
         HAL_erase((uint16_t)addr);
         HAL_write((uint16_t)addr, write_data_buf);
         // Если данные остались после записи первой страницы, то пишем их постранично, пока не закончатся
         while (dataSize > 0)
         {
-            dataShift += writeSize;
+            addr += EEPROM_PAGE_SIZE;
-            // addr = EEPROM_START_ADDR + ((dataShift) / EEPROM_PAGE_SIZE) * EEPROM_PAGE_SIZE;
-            addr +=  EEPROM_PAGE_SIZE; //Почему-то не работает с uint32_t данными
-            // addr = EEPROM_START_ADDR;
             HAL_read((uint16_t)addr, write_data_buf);
+            dataShift += writeSize;
             writeSize = dataSize;
             if (EEPROM_PAGE_SIZE < dataSize)
-            {
                 writeSize = EEPROM_PAGE_SIZE;
-                // dataShift += writeSize;
-            }
             lastWord = (writeSize - 1) / EEPROM_WORD_SIZE;
             memcpy((void *)(write_data_buf), (void*)((uint8_t *)dataPointer + dataShift), writeSize);
             // Разворачиваем слова
@@ -213,35 +203,16 @@ struct EEPROMClass{
                 write_data_buf[i] = 0;
                 write_data_buf[i] = ((word & 0xFF)<<24) | ((word & (0xFF<<8))<<8) | ((word & (0xFF<<16))>>8) | ((word & (0xFF<<24))>>24);
             }
-            // for (uint8_t i = 0; i < writeSize; i++, dataPointer_8++)
-            //     *(write_data_buf + byte_addr + i) = *dataPointer_8;
             HAL_erase((uint16_t)addr);
             HAL_write((uint16_t)addr, write_data_buf);
             dataSize -= writeSize;
         }
-
-        // Количество байт данных для записи.
-        // int count = sizeof(T);
-
-        // Цикл для записи данных побайтно в EEPROM.
-        // for(uint16_t i = 0; i < sizeof(T); i++) {
-        //     // Запись текущего байта данных в EEPROM.
-        //     EEPROM.update(ee_idx + i, *ptr++ );
-        // }
-
-        // Запись данных в eeprom
-        // Возврат ссылки на записанный объект.
         return dataPointer;
     }
 
     template< typename T >
-    T& get(int idx, T& dataPointer) {
+    T& get(int idx, T& dataPointer)
-    // EEPtr e = idx;               // Указатель на адрес в EEPROM
+    {
-    // uint8_t *ptr = (uint8_t*) &t; // Преобразуем ссылку на объект данных в указатель на байт
-    // for (int count = sizeof(T); count; --count, ++e) {
-    //     *ptr++ = *e;              // Читаем данные из EEPROM и записываем в объект
-    // }
-
         // Проверка адекватности адреса idx
         if (((uint32_t)idx >= (uint32_t)EEPROM_LENGHT) || (idx < 0))
             return dataPointer; // #TODO Добавить сообщение об ошибке 
@@ -265,12 +236,9 @@ struct EEPROMClass{
         uint32_t byte_idx  = ((uint32_t)idx) % EEPROM_WORD_SIZE;
         // Чтение первой страницы
         HAL_read((uint16_t)addr, read_data_buf);
-        uint32_t lastWord = (dataSize + byte_idx - 1) / EEPROM_WORD_SIZE + word_idx;
         if (EEPROM_PAGE_SIZE - byte_addr < dataSize)
-        {
             readSize = EEPROM_PAGE_SIZE - byte_addr;
-            lastWord  = EEPROM_PAGE_WORDS - 1;
+        uint32_t lastWord = (readSize + byte_idx - 1) / EEPROM_WORD_SIZE + word_idx;
-        }
         dataSize -= readSize;
         // Разворачиваем слова
         for(uint8_t i = word_idx; i <= lastWord; i++)
@@ -290,40 +258,20 @@ struct EEPROMClass{
             dataShift += readSize;
             readSize = dataSize;
             if (EEPROM_PAGE_SIZE < dataSize)
-            {
                 readSize = EEPROM_PAGE_SIZE;
-                // dataShift += readSize;
-            }
             lastWord = (dataSize - 1) / EEPROM_WORD_SIZE;
-            dataSize -= readSize;
             // Разворачиваем слова
-            for(uint8_t i = word_idx; i <= lastWord; i++)
+            for(uint8_t i = 0; i <= lastWord; i++)
             {
                 uint32_t word = read_data_buf[i];
                 read_data_buf[i] = 0;
                 read_data_buf[i] = ((word & 0xFF)<<24) | ((word & (0xFF<<8))<<8) | ((word & (0xFF<<16))>>8) | ((word & (0xFF<<24))>>24);
             }
-            memcpy((void *)(dataPointer + dataShift), (void*)((uint8_t *)read_data_buf), readSize);
+            memcpy((void *)((uint8_t *)dataPointer + dataShift), (void*)(read_data_buf), readSize);
-            // for (uint8_t i = 0; i < readSize; i++, dataPointer_8++)
+            dataSize -= readSize;
-            //     *(read_data_buf + byte_addr + i) = *dataPointer_8;
         }
         return dataPointer;                     // Возвращаем ссылку на переданный объект с прочитанными данными
     }
-
-    //Functionality to 'get' and 'put' objects to and from EEPROM.
-    // template< typename T > T &get( int idx, T &t ){
-    //     EEPtr e = idx;
-    //     uint8_t *ptr = (uint8_t*) &t;
-    //     for( int count = sizeof(T) ; count ; --count, ++e )  *ptr++ = *e;
-    //     return t;
-    // }
-    
-    // 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;
-    // }
 };
 
 static EEPROMClass EEPROM;