mirror of
https://github.com/eddyem/IR-controller.git
synced 2025-12-06 10:45:15 +03:00
118 lines
3.4 KiB
C
118 lines
3.4 KiB
C
/*
|
|
* flash.c - functions to work with STM32 flash memory
|
|
*
|
|
* Copyright 2015 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "flash.h"
|
|
#include <libopencm3/stm32/flash.h>
|
|
#include <string.h>
|
|
|
|
// this is variable structure saved in RAM for ability of data changing
|
|
stored_data Stored_Data;
|
|
|
|
// this is constant structure saved in flash. It have to be copied to Stored_Data after run
|
|
const flash_data Flash_Data __attribute__ ((aligned(FLASH_BLOCK_SIZE))) = {
|
|
.all_stored = {
|
|
//.magick = FLASH_MAGICK,
|
|
._ADC_multipliers = {100000,100000,100000,100000,100000,100000,100000,100000, // TRD
|
|
26, // shutter
|
|
2 // power
|
|
},
|
|
._ADC_divisors = {1,1,1,1,1,1,1,1, // TRD
|
|
25, // shutter
|
|
7 // power
|
|
}
|
|
}
|
|
};
|
|
|
|
uint8_t flash_write_data(uint32_t *dataptr, uint16_t datalen){
|
|
uint32_t start_address = (uint32_t)&(Flash_Data.all_stored);
|
|
uint16_t i, rem;
|
|
uint8_t ret = 0;
|
|
flash_unlock();
|
|
DBG("erase\n");
|
|
//Erasing page
|
|
flash_erase_page(start_address);
|
|
rem = datalen % 4; // remainder
|
|
datalen /= 4; // round to 4
|
|
// copy data by blocks of four
|
|
for(i = 0; i < datalen; i++, dataptr++, start_address += 4){
|
|
// write data word
|
|
flash_program_word(start_address, *dataptr);
|
|
//verify
|
|
if(*((uint32_t*)start_address) != *dataptr){
|
|
ret = FLASH_WRONG_DATA_WRITTEN;
|
|
goto endoffunction;
|
|
}
|
|
}
|
|
// remainder
|
|
if(rem){
|
|
uint16_t halfwords[2] = {0,0}, n = 1;
|
|
if(rem == 1) halfwords[0] = *((uint8_t*)dataptr);
|
|
else halfwords[0] = *((uint16_t*)dataptr);
|
|
if(rem == 3){ halfwords[1] = *((uint8_t*)dataptr+3); n = 2;}
|
|
for(i = 0; i < n; i++, start_address += 2){
|
|
flash_program_half_word(start_address, halfwords[i]);
|
|
//verify
|
|
if(*((uint16_t*)start_address) != halfwords[i]){
|
|
ret = FLASH_WRONG_DATA_WRITTEN;
|
|
goto endoffunction;
|
|
}
|
|
}
|
|
}
|
|
DBG("ok written\n");
|
|
endoffunction:
|
|
flash_lock();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* save all data from RAM to flash
|
|
*/
|
|
uint8_t save_flashdata(){
|
|
// uint32_t sz = (uint32_t)&Stored_Data.last_addr - (uint32_t)&Stored_Data;
|
|
//return flash_write_data((uint32_t*)&Stored_Data, sz);
|
|
return flash_write_data((uint32_t*)&Stored_Data, sizeof(stored_data));
|
|
}
|
|
|
|
void read_stored_data(){
|
|
// uint32_t sz = (uint32_t)&Stored_Data.last_addr - (uint32_t)&Stored_Data;
|
|
memcpy((void*)&Stored_Data, (void*)&(Flash_Data.all_stored), sizeof(stored_data));
|
|
}
|
|
|
|
/**
|
|
* printout all data stored in flash
|
|
*/
|
|
void dump_flash_data(sendfun s){
|
|
int i;
|
|
// P("magick: ", s);
|
|
// print_int(Stored_Data.magick, s);
|
|
P("\nADC multipliers: ", s);
|
|
for(i = 0; i < ADC_CHANNELS_NUMBER; i++){
|
|
if(i) P(", ", s);
|
|
print_int(Flash_Data.all_stored._ADC_multipliers[i], s);
|
|
}
|
|
P("\nADC divisors: ", s);
|
|
for(i = 0; i < ADC_CHANNELS_NUMBER; i++){
|
|
if(i) P(", ", s);
|
|
print_int(Flash_Data.all_stored._ADC_divisors[i], s);
|
|
}
|
|
s('\n');
|
|
}
|