Запись данных в флэш W25Q, интерфейс SPI. STM32F103

    // Filling data in array
    for(int i = 0; i <= 10; i++)
    {
        W25qxx_WriteByte(i, i);                 // Write one byte
    }
 
    // Reading data from Flash
    HAL_Delay(1);
    uint8_t read_buff[10] = {0};
    for(int i = 0; i <= 10; i++)
    {
        W25qxx_ReadByte(&read_buff[i], i);           // Read one byte
    }

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Write all sector. One sector = 16 pages. One sector = 256*16 4096 bytes
    // W25qxx_EraseChip();
    // Erase sector 0
    W25qxx_EraseSector(0);
    // Init buffer for write
    char buff_for_write_on_flash[255] = {0};
    memset (buff_for_write_on_flash, 1, sizeof(buff_for_write_on_flash));
 
    ////////////  Write all pages in sector data in flash.
    // One sector has 16 pages
    for(uint8_t i = 0; i<=15; i++)
    {
        // 1. Write number
//      memset (buff_for_write_on_flash, i, sizeof(buff_for_write_on_flash));
//      W25qxx_WritePage(buff_for_write_on_flash, i, 0, 0);
        // 2. Write string
        sprintf(buff_for_write_on_flash, "%s", "TEST");
        W25qxx_WritePage(buff_for_write_on_flash, i, 0, 0);
 
    }
    //////////// 1. Read all pages using read page function
    char buff_for_read_from_flash[256] = {0};
    for(int i = 0; i<=15; i++)
    {
        memset (buff_for_read_from_flash, 0, sizeof(buff_for_read_from_flash));
        W25qxx_ReadPage(buff_for_read_from_flash, i, 0, 0);
    }
 
    //////////// 2.Read all pages using read all SECTOR function
    uint8_t buffer_for_read_sector[4096] = {0};
    W25qxx_ReadSector(buffer_for_read_sector, 0, 0, 0);
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

uint8_t W25qxx_Init(void);
 
void W25qxx_EraseChip(void);
void W25qxx_EraseSector(uint32_t SectorAddr);
void W25qxx_EraseBlock(uint32_t BlockAddr);
 
uint32_t W25qxx_PageToSector(uint32_t PageAddress);
uint32_t W25qxx_PageToBlock(uint32_t PageAddress);
uint32_t W25qxx_SectorToBlock(uint32_t SectorAddress);
uint32_t W25qxx_SectorToPage(uint32_t SectorAddress);
uint32_t W25qxx_BlockToPage(uint32_t BlockAddress);
 
uint8_t W25qxx_IsEmptyPage(uint32_t Page_Address, uint32_t OffsetInByte);
uint8_t W25qxx_IsEmptySector(uint32_t Sector_Address, uint32_t OffsetInByte);
uint8_t W25qxx_IsEmptyBlock(uint32_t Block_Address, uint32_t OffsetInByte);
 
void W25qxx_WriteByte(uint8_t byte, uint32_t addr);
void W25qxx_WritePage(uint8_t *pBuffer, uint32_t Page_Address, uint32_t OffsetInByte, uint32_t NumByteToWrite_up_to_PageSize);
void W25qxx_WriteSector(uint8_t *pBuffer, uint32_t Sector_Address, uint32_t OffsetInByte, uint32_t NumByteToWrite_up_to_SectorSize);
void W25qxx_WriteBlock(uint8_t* pBuffer, uint32_t Block_Address, uint32_t OffsetInByte, uint32_t NumByteToWrite_up_to_BlockSize);
 
void W25qxx_ReadByte(uint8_t *pBuffer, uint32_t Bytes_Address);
void W25qxx_ReadBytes(uint8_t *pBuffer, uint32_t ReadAddr, uint32_t NumByteToRead);
void W25qxx_ReadPage(uint8_t *pBuffer, uint32_t Page_Address, uint32_t OffsetInByte, uint32_t NumByteToRead_up_to_PageSize);
void W25qxx_ReadSector(uint8_t *pBuffer, uint32_t Sector_Address, uint32_t OffsetInByte, uint32_t NumByteToRead_up_to_SectorSize);
void W25qxx_ReadBlock(uint8_t *pBuffer, uint32_t Block_Address, uint32_t OffsetInByte,uint32_t NumByteToRead_up_to_BlockSize);

void test_write_read_bytes()
{
    W25qxx_EraseChip();
    // Filling data in array
    char tx_data[10] = "TEST ";
    int number = 0;
    int k = 0;
    int r = 0;
    for(int k = 1; k <= 10; k++)
    {
        // add number at the end fo string
        snprintf(tx_data, sizeof(tx_data), "TEST %d", k );
        for(int i =0 ; i<=sizeof(tx_data); i++)
        {
            W25qxx_WriteByte(tx_data[i], r++);
        }
    }
 
    // Reading data from Flash
    HAL_Delay(1);
    uint8_t read_buff[1000] = {0};
    for(int i = 0; i <= 200; i++)
    {
        W25qxx_ReadByte(&read_buff[i], i);           // Read one byte
    }

void test_write_read_bytes()
{
    // Create structure
    struct sensors_data{
        int number_of_measure;
        char sensor_name_1[11];
        char sensor_1_data[4];
    };
    struct sensors_data sensors_data_t;             // Creating sensors_data_t structure variable
    struct sensors_data_t *sensors_data_t_p;        // Create pointer on struct
    sensors_data_t_p = &sensors_data_t;
 
    W25qxx_EraseChip();                 // Erase all flash chip
 
    int k = 0;
    int r = 0;
 
    for(int k = 1; k <= 10; k++)
    {
        strcpy( sensors_data_t.sensor_name_1, "Sensor_1:");
        for(int i =0 ; i<=sizeof(sensors_data_t); i++)
        {
            sensors_data_t.number_of_measure = 1;
            strcpy( sensors_data_t.sensor_1_data, "99");
            // Writing in flash sensors_data_t structure byte by bytes
            W25qxx_WriteByte(sensors_data_t_p, r++);
        }
    }
 
    // Reading data from Flash
    HAL_Delay(1);
    uint8_t read_buff[1000] = {0};
    for(int i = 0; i <= 200; i++)
    {
        W25qxx_ReadByte(&read_buff[i], i);           // Read one byte
    }

void send_buffer(char *buffer, unsigned long flash_offset, unsigned int size) {
...
}

send_buffer((char*)&sensors_data_t, 0x102030, 1234);

//###################################################################################################################
void W25qxx_WriteByte(uint8_t byte, uint32_t addr)
{
    while(w25qxx.Lock == 1)
        W25qxx_Delay(1);
 
    w25qxx.Lock = 1;
 
    W25qxx_WaitForWriteEnd();
    W25qxx_WriteEnable();
 
    W25QFLASH_CS_SELECT;
 
    W25qxx_Spi(W25_PAGE_PROGRAMM);
 
    if(w25qxx.ID >= W25Q256)
        W25qxx_Spi((addr & 0xFF000000) >> 24);
 
    W25qxx_Spi((addr & 0xFF0000) >> 16);
    W25qxx_Spi((addr & 0xFF00) >> 8);
    W25qxx_Spi(addr & 0xFF);
 
    W25qxx_Spi(byte);
 
    W25QFLASH_CS_UNSELECT;
 
    W25qxx_WaitForWriteEnd();
 
    w25qxx.Lock = 0;
}
 
//###################################################################################################################

// ----------------------------------------------------------------------------
void save_data_in_flash(void)
{
    struct sensors_data sensors_data_t;                             // Creating sensors_data_t structure variable
    //struct sensors_data *sensors_data_t_p = &sensors_data_t;      // Create pointer on structure
 
    sensors_data_t.number_of_measure = 1;                           // Test filling data
    strcpy( sensors_data_t.sensor_name_1, "SI7021:");               // Test filling data
    strcpy( sensors_data_t.sensor_1_data, "T 21, H 70%");           // Test filling data
 
    //W25qxx_EraseChip();                   // Erase all flash chip
 
    unsigned int size = sizeof(sensors_data_t);
    write_struct_in_flash(sensors_data_t, size);
}
 
void write_struct_in_flash(struct sensors_data t, unsigned int size)
{
    static unsigned long flash_offset = 0;              // Flash address 
    if(flash_offset >= 65535)                           // Use only block 0
    {
        flash_offset = 0;
        W25qxx_EraseBlock(0);
    }
    
    for(int i = 0; i<= size; i++)
    {
        // Send data in flash, byte by byte
        flash_offset ++;
        //W25qxx_WriteByte(uint8_t byte, uint32_t flash_offset)
    }
}
// ----------------------------------------------------------------------------

void test_flash_W25Q(void)
{
    uint8_t init=0;
    init = W25qxx_Init();
 
    uint32_t id=0;
    id = W25qxx_ReadID();
 
W25qxx_EraseSector(0);                  // First to all erase sector 0
 
 
 
    uint8_t tempetature = 21;
    uint8_t humidity = 80;
 
    save_data(tempetature, humidity);
 
    tempetature = 30;
    humidity = 90;
 
    save_data(tempetature, humidity);
 
    tempetature = 100;
    humidity = 60;
 
    save_data(tempetature, humidity);
 
 
    // Read sector from flash in the end
    char buff_for_read_from_flash[10000] = {0};         // Buffer for read data from flash
    memset(buff_for_read_from_flash, 0 , sizeof(buff_for_read_from_flash));
    W25qxx_ReadSector(buff_for_read_from_flash, 0, 0, 0);
}
// ----------------------------------------------------------------------------
void save_data(uint8_t tempetature, uint8_t humidity)
{
    static unsigned int number_of_measure = 1;
    static unsigned int flash_offset = 0;               // flash memory offset (One byre writer: flash_offset++)
 
    flash_offset = save_data_in_flash(tempetature, humidity, number_of_measure, flash_offset);
 
    // For save only in one sector
    if(flash_offset >= 4096)                    // 4096: size of one sector
    {
        flash_offset = 0;
        W25qxx_EraseSector(0);                  // First to all erase sector 0
    }
    number_of_measure ++;                       // How many message was save
 
}
// ----------------------------------------------------------------------------
unsigned int save_data_in_flash(uint8_t tempetature, uint8_t humidity, unsigned int number_of_measure, unsigned int flash_offset)
{
    char test_array [32] = {0};
    uint8_t q = 0;                                      // Counter of saved messages
    uint8_t pages = 0;                                  // Counter of pages
    uint8_t size_array = sizeof(test_array)-1;
 
    sprintf(test_array,"%s %d %s%d%s %s%d%s", "sensor_1", number_of_measure, "T:",tempetature, "C", "H:",humidity, "%");    // Write data on array
 
    for(int i = 0; i <=  size_array; i++)                       // Write all bytes from array
    {
        W25qxx_WriteByte(test_array[i], flash_offset++);        // Write all bytes from array
    }
 
    return flash_offset;
}

sprintf(test_array,"%s %d %s%d%s %s%d%s", "sensor_1", number_of_measure, "T:",tempetature, "C", "H:",humidity, "%");    // Write data on array