int OTAClass::set_system_data(uint32_t address, uint32_t value) {
flash_t flash;
uint32_t i, data;
flash_write_word(&flash, FLASH_SYSTEM_DATA_ADDR + address, value);
flash_read_word(&flash, FLASH_SYSTEM_DATA_ADDR + address, &data);
if (value != data) {
//erase backup sector
flash_erase_sector(&flash, FLASH_RESERVED_DATA_BASE);
//backup system data to backup sector
for(i = 0; i < 0x1000; i+= 4){
flash_read_word(&flash, FLASH_SYSTEM_DATA_ADDR + i, &data);
flash_write_word(&flash, FLASH_RESERVED_DATA_BASE + i,data);
}
//erase system data
flash_erase_sector(&flash, FLASH_SYSTEM_DATA_ADDR);
//write data back to system data
for(i = 0; i < 0x1000; i+= 4){
flash_read_word(&flash, FLASH_RESERVED_DATA_BASE + i, &data);
if(i == address) data = value;
flash_write_word(&flash, FLASH_SYSTEM_DATA_ADDR + i,data);
}
//erase backup sector
flash_erase_sector(&flash, FLASH_RESERVED_DATA_BASE);
}
}
void sys_adc_calibration(u8 write, u16 *offset, u16 *gain)
{
flash_t flash;
u8* pbuf;
if(write){
// backup
pbuf = (unsigned char*)RtlMalloc(FLASH_SECTOR_SIZE);
if(!pbuf) return;
flash_stream_read(&flash, FLASH_SYSTEM_DATA_ADDR, FLASH_SECTOR_SIZE, pbuf);
memcpy((char*)pbuf+FLASH_ADC_PARA_OFFSET, offset, 2);
memcpy((char*)pbuf+FLASH_ADC_PARA_OFFSET+2, gain, 2);
flash_erase_sector(&flash, FLASH_RESERVED_DATA_BASE);
flash_stream_write(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
// Write
flash_stream_read(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
flash_erase_sector(&flash, FLASH_SYSTEM_DATA_ADDR);
flash_stream_write(&flash, FLASH_SYSTEM_DATA_ADDR, FLASH_SECTOR_SIZE, pbuf);
RtlMfree(pbuf, FLASH_SECTOR_SIZE);
printf("\n\rStore ADC calibration success.");
}
flash_stream_read(&flash, FLASH_ADC_PARA_BASE, 2, (u8*)offset);
flash_stream_read(&flash, FLASH_ADC_PARA_BASE+2, 2, (u8*)gain);
printf("\n\rADC offset = 0x%04X, gain = 0x%04X.\n\r", *offset, *gain);
}
int write_ota_addr_to_system_data(flash_t *flash, uint32_t ota_addr)
{
uint32_t data, i = 0;
//Get upgraded image 2 addr from offset
flash_read_word(flash, OFFSET_DATA, &data);
printf("\n\r[%s] data 0x%x ota_addr 0x%x", __FUNCTION__, data, ota_addr);
if(data == ~0x0){
flash_write_word(flash, OFFSET_DATA, ota_addr);
}else{
//erase backup sector
flash_erase_sector(flash, BACKUP_SECTOR);
//backup system data to backup sector
for(i = 0; i < 0x1000; i+= 4){
flash_read_word(flash, OFFSET_DATA + i, &data);
if(i == 0)
data = ota_addr;
flash_write_word(flash, BACKUP_SECTOR + i,data);
}
//erase system data
flash_erase_sector(flash, OFFSET_DATA);
//write data back to system data
for(i = 0; i < 0x1000; i+= 4){
flash_read_word(flash, BACKUP_SECTOR + i, &data);
flash_write_word(flash, OFFSET_DATA + i,data);
}
//erase backup sector
flash_erase_sector(flash, BACKUP_SECTOR);
}
return 0;
}
void main(void)
{
uint32 data32;
uint16 data16;
uint8 data8;
flash_init(); //初始化flash
flash_erase_sector(SECTOR_NUM); //擦除扇区
//写入flash数据前，需要先擦除对应的扇区(不然数据会乱)
if( 0==flash_write(SECTOR_NUM,0,0x12345678) ) //写入数据到扇区，偏移地址为0，必须一次写入4字节
//if是用来检测是否写入成功，写入成功了就读取
{
data32 = flash_read(SECTOR_NUM,0,uint32); //读取4字节
printf("一次读取32位的数据为：0x%08x\n",data32);
data16 = flash_read(SECTOR_NUM,0,uint16); //读取2字节
printf("一次读取16位的数据为：0x%04x\n",data16);
data8 = flash_read(SECTOR_NUM,0,uint8); //读取1字节
printf("一次读取8位的数据为：0x%02x\n",data8);
}
while(1);
}
void memory_protect(void) {
#if MEMORY_PROTECT
// Reference STM32F205 Flash programming manual revision 5
// http://www.st.com/resource/en/programming_manual/cd00233952.pdf Section 2.6
// Option bytes
// set RDP level 2 WRP for sectors 0 and
// 1 flash option control register matches
if (((FLASH_OPTION_BYTES_1 & 0xFFEC) == 0xCCEC) &&
((FLASH_OPTION_BYTES_2 & 0xFFF) == 0xFFC) &&
(FLASH_OPTCR == 0x0FFCCCED)) {
return; // already set up correctly - bail out
}
for (int i = FLASH_STORAGE_SECTOR_FIRST; i <= FLASH_STORAGE_SECTOR_LAST;
i++) {
flash_erase_sector(i, FLASH_CR_PROGRAM_X32);
}
flash_unlock_option_bytes();
// Section 2.8.6 Flash option control register (FLASH_OPTCR)
// Bits 31:28 Reserved, must be kept cleared.
// Bits 27:16 nWRP: Not write protect: write protect bootloader code in
// flash main memory sectors 0 and 1 (Section 2.3; table 2) Bits 15:8 RDP:
// Read protect: level 2 chip read protection active Bits 7:5 USER: User
// option bytes: no reset on standby, no reset on stop, software watchdog
// Bit 4 Reserved, must be kept cleared.
// Bits 3:2 BOR_LEV: BOR reset Level: BOR off
// Bit 1 OPTSTRT: Option start: ignored by flash_program_option_bytes
// Bit 0 OPTLOCK: Option lock: ignored by flash_program_option_bytes
flash_program_option_bytes(0x0FFCCCEC);
flash_lock_option_bytes();
#endif
}
void storage_commit(void)
{
int i;
uint32_t *w;
// backup meta
memcpy(meta_backup, (void *)FLASH_META_START, FLASH_META_LEN);
flash_clear_status_flags();
flash_unlock();
// erase storage
for (i = FLASH_META_SECTOR_FIRST; i <= FLASH_META_SECTOR_LAST; i++) {
flash_erase_sector(i, FLASH_CR_PROGRAM_X32);
}
// modify storage
memcpy(meta_backup + FLASH_META_DESC_LEN, "stor", 4);
memcpy(meta_backup + FLASH_META_DESC_LEN + 4, storage_uuid, sizeof(storage_uuid));
memcpy(meta_backup + FLASH_META_DESC_LEN + 4 + sizeof(storage_uuid), &storage, sizeof(Storage));
// copy it back
for (i = 0; i < FLASH_META_LEN / 4; i++) {
w = (uint32_t *)(meta_backup + i * 4);
flash_program_word(FLASH_META_START + i * 4, *w);
}
flash_lock();
// flash operation failed
if (FLASH_SR & (FLASH_SR_PGAERR | FLASH_SR_PGPERR | FLASH_SR_PGSERR | FLASH_SR_WRPERR)) {
layoutDialog(DIALOG_ICON_ERROR, NULL, NULL, NULL, "Storage failure", "detected.", NULL, "Please unplug", "the device.", NULL);
for (;;) { }
}
}
void
flash_func_erase_sector(unsigned sector)
{
if (sector >= BOARD_FLASH_SECTORS)
return;
/* get the base address of the sector */
uint32_t address = 0;
for (unsigned i = 0; i < sector; i++)
address += flash_func_sector_size(i);
/* blank-check the sector */
unsigned size = flash_func_sector_size(sector);
bool blank = true;
for (unsigned i = 0; i < size; i += sizeof(uint32_t)) {
if (flash_func_read_word(address + i) != 0xffffffff) {
blank = false;
break;
}
}
/* erase the sector if it failed the blank check */
if (!blank)
flash_erase_sector(flash_sectors[sector].erase_code, FLASH_PROGRAM_X32);
}
void config_updateToFlash()
{
uint16_t *dst = &_flashConfigROMBegin;
uint16_t *src = &_flashConfigRAMBegin;
bool canUpdateFlash = false;
for (; src < &_flashConfigRAMEnd; ++src, ++dst)
{
if (*dst != *src)
{
canUpdateFlash = true;
break;
}
}
if (false != canUpdateFlash)
{
dst = &_flashConfigROMBegin;
src = &_flashConfigRAMBegin;
(void) flash_unlock();
flash_erase_sector(FLASH_CONFIG_SECTOR, FLASH_PROGRAMM_ACCESS_SIZE);
for (; src < &_flashConfigRAMEnd; ++src, ++dst)
{
flash_program_half_word((uint32_t)dst, *src, FLASH_PROGRAMM_ACCESS_SIZE);
}
(void) flash_lock();
}
}
int FlashIAP::erase(uint32_t addr, uint32_t size)
{
uint32_t current_sector_size;
uint32_t flash_size = flash_get_size(&_flash);
uint32_t flash_start_addr = flash_get_start_address(&_flash);
uint32_t flash_end_addr = flash_start_addr + flash_size;
uint32_t erase_end_addr = addr + size;
if (erase_end_addr > flash_end_addr) {
return -1;
} else if (erase_end_addr < flash_end_addr){
uint32_t following_sector_size = flash_get_sector_size(&_flash, erase_end_addr);
if (!is_aligned(erase_end_addr, following_sector_size)) {
return -1;
}
}
int32_t ret = 0;
_mutex->lock();
while (size) {
ret = flash_erase_sector(&_flash, addr);
if (ret != 0) {
ret = -1;
break;
}
current_sector_size = flash_get_sector_size(&_flash, addr);
size -= current_sector_size;
addr += current_sector_size;
}
_mutex->unlock();
return ret;
}
void aseba_flash_erase_page(int aseba_page)
{
flash_unlock();
int sector = aseba_page_sector(aseba_page);
if (sector != -1) { // first page in sector
flash_erase_sector(sector, FLASH_CR_PROGRAM_X16);
}
}
static void svhandler_flash_erase_sector(uint16_t sector) {
/* we only allow erasing storage sectors 2 and 3. */
if (sector < FLASH_STORAGE_SECTOR_FIRST ||
sector > FLASH_STORAGE_SECTOR_LAST) {
return;
}
flash_erase_sector(sector, FLASH_CR_PROGRAM_X32);
}
void sys_recover_ota_signature(void)
{
flash_t flash;
u32 ota_offset=0xFFFFFFFF, part1_offset, part2_offset;
u8 signature[OTA_Signature_len+1];
u8* pbuf;
flash_stream_read(&flash, 0x18, 4, (u8*)&part1_offset);
part1_offset = (part1_offset&0xFFFF) * 1024;
flash_stream_read(&flash, part1_offset+OTA_Signature_offset, OTA_Signature_len, signature);
if(!memcmp((char const*)signature, OTA_Clear, OTA_Signature_len)){
ota_offset = part1_offset;
}
flash_stream_read(&flash, FLASH_SYSTEM_DATA_ADDR, 4, (u8*)&part2_offset);
flash_stream_read(&flash, part2_offset+OTA_Signature_offset, OTA_Signature_len, signature);
if(!memcmp((char const*)signature, OTA_Clear, OTA_Signature_len)){
ota_offset = part2_offset;
}
printf("\n\rOTA offset = 0x%08X", ota_offset);
if(ota_offset < OTA_valid_offset){
flash_stream_read(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
signature[OTA_Signature_len] = '\0';
printf("\n\rSignature = %s", signature);
if(!memcmp((char const*)signature, OTA_Clear, OTA_Signature_len)){
// backup
pbuf = (unsigned char*)RtlMalloc(FLASH_SECTOR_SIZE);
if(!pbuf) return;
flash_stream_read(&flash, ota_offset, FLASH_SECTOR_SIZE, pbuf);
memcpy((char*)pbuf+OTA_Signature_offset, OTA_Signature, OTA_Signature_len);
flash_erase_sector(&flash, FLASH_RESERVED_DATA_BASE);
flash_stream_write(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
// Write
flash_stream_read(&flash, FLASH_RESERVED_DATA_BASE, FLASH_SECTOR_SIZE, pbuf);
flash_erase_sector(&flash, ota_offset);
flash_stream_write(&flash, ota_offset, FLASH_SECTOR_SIZE, pbuf);
flash_stream_read(&flash, ota_offset+OTA_Signature_offset, OTA_Signature_len, signature);
signature[OTA_Signature_len] = '\0';
printf("\n\rSignature = %s", signature);
RtlMfree(pbuf, FLASH_SECTOR_SIZE);
printf("\n\rRecover OTA signature success.");
}
}
}
// Mandatory function to save controller pairing to persistent storage
// called when HAP controller pairing update
void HAPPlatformSavePairings(HAPPersistentPairing_t *pairing, int num)
{
uint8_t *flash_buffer = (uint8_t *) malloc(FLASH_DATA_LEN);
flash_stream_read(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
memcpy(flash_buffer + HAP_FLASH_PAIRING_OFFSET, pairing, sizeof(HAPPersistentPairing_t) * num);
flash_stream_write(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
free(flash_buffer);
}
// Mandatory function to save accessory key pair to persistent storage
// called when HAP accessory key pair generation
void HAPPlatformSaveKeypair(HAPPersistentKeypair_t *keypair)
{
uint8_t *flash_buffer = (uint8_t *) malloc(FLASH_DATA_LEN);
flash_stream_read(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
memcpy(flash_buffer + HAP_FLASH_KEYPAIR_OFFSET, keypair, sizeof(HAPPersistentKeypair_t));
flash_stream_write(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
free(flash_buffer);
}
int uartadapter_flasherase(int flashadd, int erase_bytelen)
{
int ret = 0;
flash_t flash;
flash_erase_sector(&flash, flashadd);
return ret;
}
void check_bootloader(void)
{
#if MEMORY_PROTECT
uint8_t hash[32];
int r = memory_bootloader_hash(hash);
if (!known_bootloader(r, hash)) {
layoutDialog(&bmp_icon_error, NULL, NULL, NULL, _("Unknown bootloader"), _("detected."), NULL, _("Unplug your TREZOR"), _("contact our support."), NULL);
shutdown();
}
if (is_mode_unprivileged()) {
return;
}
if (r == 32 && 0 == memcmp(hash, bl_hash, 32)) {
// all OK -> done
return;
}
// ENABLE THIS AT YOUR OWN RISK
// ATTEMPTING TO OVERWRITE BOOTLOADER WITH UNSIGNED FIRMWARE MAY BRICK
// YOUR DEVICE.
layoutDialog(&bmp_icon_warning, NULL, NULL, NULL, _("Updating bootloader"), NULL, NULL, _("DO NOT UNPLUG"), _("YOUR TREZOR!"), NULL);
// unlock sectors
memory_write_unlock();
for (int tries = 0; tries < 10; tries++) {
// replace bootloader
flash_unlock();
for (int i = FLASH_BOOT_SECTOR_FIRST; i <= FLASH_BOOT_SECTOR_LAST; i++) {
flash_erase_sector(i, FLASH_CR_PROGRAM_X32);
}
for (int i = 0; i < FLASH_BOOT_LEN / 4; i++) {
const uint32_t *w = (const uint32_t *)(bl_data + i * 4);
flash_program_word(FLASH_BOOT_START + i * 4, *w);
}
flash_lock();
// check whether the write was OK
r = memory_bootloader_hash(hash);
if (r == 32 && 0 == memcmp(hash, bl_hash, 32)) {
// OK -> show info and halt
layoutDialog(&bmp_icon_info, NULL, NULL, NULL, _("Update finished"), _("successfully."), NULL, _("Please reconnect"), _("the device."), NULL);
shutdown();
return;
}
}
// show info and halt
layoutDialog(&bmp_icon_error, NULL, NULL, NULL, _("Bootloader update"), _("broken."), NULL, _("Unplug your TREZOR"), _("contact our support."), NULL);
shutdown();
#endif
}
flash_result_t flash_erase_block_by_addr(const uint32_t *p)
{
uint32_t addr = (uint32_t)p;
if (addr < 0x08020000 ||
addr > 0x080fffff ||
(addr & 0x1ffff) != 0)
return FLASH_FAIL; // bad address
int offset = addr - 0x08020000;
int block = 5 + offset / 0x20000;
return flash_erase_sector(block);
}
/*!
* @brief 启动前进行检测（检测按键是否按下，按下则进入死循环，防止进入 main 函数,松开按键后再按下则进行解锁）
* @since v5.0
* @note 此函数可避免 下载口在 main 前 复用了导致无法下载等问题
*/
void start_check()
{
#if 0
uint8 flag = 0;
key_init(KEY_A);
if(key_check(KEY_A) == KEY_DOWN )
{
//按键按下
led_init(LED0);
while(1)
{
if(key_check(KEY_A) == KEY_UP)
{
flag = 1;
}
led_turn(LED0);
printf("\n进入死循环等待！");
DELAY_MS(500); //此处的延时，可起到 按键 消抖的功能
//如果 送开按键后，再按下 按键，则 进行解锁 操作
if((flag == 1) && (key_check(KEY_A) == KEY_DOWN ))
{
while(key_check(KEY_A) == KEY_DOWN) //等待按键 弹起
{
led_turn(LED0);
DELAY_MS(100); //此处的延时，可起到 按键 消抖的功能
}
while(key_check(KEY_A) == KEY_UP) //等待按键 弹起后 再 进行解锁
{
led_turn(LED0);
DELAY_MS(50); //此处的延时，可起到 按键 消抖的功能
}
printf("\n进行解锁操作，请重新刷入固件");
//解锁单片机
flash_init();
DELAY_MS(100);
flash_erase_sector(0); //擦除扇区 0 (解锁)
NVIC_SystemReset(); //复位单片机
}
}
}
#endif
}
/** Erase a sector of the STM flash
* \param sector Number of the sector to erase.
* \return Error code
*/
u8 stm_flash_erase_sector(u8 sector)
{
/* Check that sector argument is valid. */
if (sector >= STM_FLASH_N_SECTORS)
return FLASH_INVALID_SECTOR;
/* Erase sector.
* See "PM0081 : STM32F40xxx and STM32F41xxx Flash programming manual"
*/
flash_unlock();
flash_erase_sector(sector, FLASH_CR_PROGRAM_X32);
flash_lock();
return FLASH_OK;
}
void cmd_factory_reset(int argc, char **argv)
{
// Read setupcode
char setup_code[11];
FlashSetupcodeRead(setup_code);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
// Restore setupcode
if(strlen(setup_code) == 10)
FlashSetupcodeWrite(setup_code);
// Turn off Wi-Fi and reboot system
wifi_off();
sys_reset();
}
void FlashSetupcodeWrite(char *code)
{
if(strlen(code) == 10) {
PersistentSetupcode_t setupcode;
memset(&setupcode, 0, sizeof(PersistentSetupcode_t));
setupcode.len = 10;
strcpy(setupcode.code, code);
uint8_t *flash_buffer = (uint8_t *) malloc(FLASH_DATA_LEN);
flash_stream_read(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
flash_erase_sector(&flash, FLASH_DATA_ADDR);
memcpy(flash_buffer + FLASH_SETUPCODE_OFFSET, &setupcode, sizeof(PersistentSetupcode_t));
flash_stream_write(&flash, FLASH_DATA_ADDR, FLASH_DATA_LEN, flash_buffer);
free(flash_buffer);
}
}
void platform_save_config() {
volatile unsigned *src, *dest;
int n_sectors, conf_bytes;
flash_unlock();
/* configrom is sectors 1 through 3, each 16k,
* compute how many we need to erase */
conf_bytes = ((char*)&_econfigdata - (char*)&_sconfigdata);
n_sectors = (conf_bytes + 16385) / 16386;
flash_erase_sector(n_sectors, 2);
for (dest = &_configdata_loadaddr, src = &_sconfigdata;
src < &_econfigdata;
src++, dest++) {
flash_program_word((uint32_t)dest, *src);
}
flash_lock();
}
int
flash_program_sector(const uint8_t *buf, uintptr_t addr, size_t len)
{
int ret = 0;
ret = ret || (len != FLASH_SECTOR_SIZE);
ret = ret || ((addr & (FLASH_SECTOR_SIZE - 1)) != 0);
ret = ret || flash_erase_sector(addr);
for (int i = FLASH_SECTOR_SIZE / FLASH_SECTION_SIZE; i > 0; --i) {
memcpy(flash_get_staging_area(addr, FLASH_SECTION_SIZE),
buf,
FLASH_SECTION_SIZE);
ret = ret || flash_program_section(addr, FLASH_SECTION_SIZE);
buf += FLASH_SECTION_SIZE;
addr += FLASH_SECTION_SIZE;
}
return (ret);
}
void main(void)
{
flash_t flash;
uint32_t val32_to_write = 0x13572468;
uint32_t val32_to_read;
uint32_t address = FLASH_APP_BASE;
int result = 0;
flash_read_word(&flash, address, &val32_to_read);
flash_erase_sector(&flash, address);
flash_write_word(&flash, address, val32_to_write);
flash_read_word(&flash, address, &val32_to_read);
DBG_8195A("Read Data 0x%x\n", val32_to_read);
// verify result
result = (val32_to_write == val32_to_read) ? 1 : 0;
printf("\r\nResult is %s\r\n", (result) ? "success" : "fail");
for(;;);
}
int main (void){
cpu_wakeup_init();
clock_init();
gpio_init();
gpio_write(GPIO_PD7, 0);
gpio_set_output_en(GPIO_PD7, 1);
i2c_init();
wd_stop();
sleep_us(50*1000);
mouse_sensor_no_fifo_init();
sleep_us(1000*1000); // for L3G, must delay enough time
s16 avg_data[6];
calib(64, avg_data);
flash_erase_sector(AIRMOUSE_CALIBRATION_ADDR);
flash_write_page(AIRMOUSE_CALIBRATION_ADDR, 12, avg_data);
while (1);
return 0;
}
void dfu_check_and_do_sector_erase(uint32_t addr)
{
if(addr == sector_addr[sector_num]) {
flash_erase_sector((sector_num & 0x1f)<<3, FLASH_PROGRAM_X32);
}
}
int OTAClass::beginLocal(uint16_t port, bool reboot_when_success) {
int ret = -1;
// variables for image processing
flash_t flash;
uint32_t img2_addr, img2_len, img3_addr, img3_len;
uint32_t img_upper_bound;
uint32_t checksum = 0;
uint32_t signature1, signature2;
// variables for network processing
int server_socket = -1;
int client_socket = -1;
struct sockaddr_in localHost;
struct sockaddr_in client_addr;
int socket_error, socket_timeout;
socklen_t optlen;
// variables for OTA
unsigned char *buf = NULL;
int read_bytes = 0, processed_len;
uint32_t file_info[3];
uint32_t ota_len;
uint32_t ota_blk_size = 0;
int i, n;
do {
sync_ota_addr();
get_image_info(&img2_addr, &img2_len, &img3_addr, &img3_len);
img_upper_bound = img2_addr + 0x10 + img2_len; // image2 base + header + len
if (img3_len > 0) {
img_upper_bound += 0x10 + img3_len; // image 3 header + len
}
if ((ota_addr & 0xfff != 0) || (ota_addr == ~0x0) || (ota_addr < img_upper_bound)) {
OTA_PRINTF("Invalid OTA address: %08X\r\n", ota_addr);
break;
}
buf = (unsigned char *) malloc (BUFSIZE);
if (buf == NULL) {
OTA_PRINTF("Fail to allocate memory\r\n");
break;
}
server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (server_socket < 0) {
OTA_PRINTF("Fail to create socket\r\n");
break;
}
memset(&localHost, 0, sizeof(localHost));
localHost.sin_family = AF_INET;
localHost.sin_port = htons(port);
localHost.sin_addr.s_addr = INADDR_ANY;
if (lwip_bind(server_socket, (struct sockaddr *)&localHost, sizeof(localHost)) < 0) {
OTA_PRINTF("Bind fail\r\n");
break;
}
if (lwip_listen(server_socket , 1) < 0) {
OTA_PRINTF("Listen fail\r\n");
break;
}
OTA_PRINTF("Wait for client\r\n");
n = (int) sizeof( client_addr );
memset(&client_addr, 0, sizeof(client_addr));
client_socket = lwip_accept(server_socket, (struct sockaddr *) &client_addr, (socklen_t *)&n);
OTA_PRINTF("Client connected. IP:%s port:%d\r\n\r\n", inet_ntoa(client_addr.sin_addr.s_addr), ntohs(client_addr.sin_port));
socket_timeout = DEFAULT_IMAGE_DOWNLOAD_TIMEOUT;
lwip_setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &socket_timeout, sizeof(socket_timeout));
OTA_PRINTF("Read OTA info...\r\n");
read_bytes = read(client_socket, file_info, sizeof(file_info));
if (read_bytes < 0) {
OTA_PRINTF("Fail to read OTA info\r\n");
break;
}
if (file_info[2] == 0) {
OTA_PRINTF("OTA image len is 0\r\n");
break;
}
ota_len = file_info[2];
ota_blk_size = ((ota_len - 1) / 4096) + 1;
for (i = 0; i < ota_blk_size; i++) {
flash_erase_sector(&flash, ota_addr + i * 4096);
}
OTA_PRINTF("Start download\r\n");
// Now download OTA image
processed_len = 0;
while( processed_len < ota_len ) {
memset(buf, 0, BUFSIZE);
read_bytes = read(client_socket, buf, BUFSIZE);
if (read_bytes < 0) {
optlen = sizeof(socket_error);
getsockopt(client_socket, SOL_SOCKET, SO_ERROR, &socket_error, &optlen);
if (socket_error == EAGAIN) {
// socket timeout
}
break;
}
if (flash_stream_write(&flash, ota_addr + processed_len, read_bytes, buf) < 0) {
OTA_PRINTF("Write sector fail\r\n");
break;
}
processed_len += read_bytes;
}
if (processed_len != ota_len) {
OTA_PRINTF("Download fail\r\n");
break;
}
// Read OTA image from flash and calculate checksum
checksum = processed_len = 0;
while ( processed_len < ota_len ) {
n = (processed_len + BUFSIZE < ota_len) ? BUFSIZE : (ota_len - processed_len);
flash_stream_read(&flash, ota_addr + processed_len, n, buf);
for (i=0; i<n; i++) checksum += (buf[i] & 0xFF);
processed_len += n;
}
if (checksum != file_info[0]) {
OTA_PRINTF("Bad checksum:%d expected:%d\r\n", checksum, file_info[0]);
break;
}
// Put signature for OTA image
flash_write_word(&flash, ota_addr + 8, 0x35393138);
flash_write_word(&flash, ota_addr + 12, 0x31313738);
flash_read_word(&flash, ota_addr + 8, &signature1);
flash_read_word(&flash, ota_addr + 12, &signature2);
if (signature1 != 0x35393138 || signature2 != 0x31313738) {
OTA_PRINTF("Put signature fail\r\n");
break;
}
// Mark image 2 as old image
flash_write_word(&flash, img2_addr + 8, 0x35393130);
ret = 0;
OTA_PRINTF("OTA success\r\n");
} while (0);
if (buf != NULL) {
free(buf);
}
if (server_socket >= 0) {
close(server_socket);
}
if (client_socket >= 0) {
close(client_socket);
}
if (ret < 0) {
OTA_PRINTF("OTA fail\r\n");
} else {
if (reboot_when_success) {
sys_reset();
}
}
return ret;
}
void main(void)
{
flash_t flash;
uint32_t address = FLASH_APP_BASE;
#if 1
uint32_t val32_to_write = 0x13572468;
uint32_t val32_to_read;
int loop = 0;
int result = 0;
for(loop = 0; loop < 10; loop++)
{
flash_read_word(&flash, address, &val32_to_read);
DBG_8195A("Read Data 0x%x\n", val32_to_read);
flash_erase_sector(&flash, address);
flash_write_word(&flash, address, val32_to_write);
flash_read_word(&flash, address, &val32_to_read);
DBG_8195A("Read Data 0x%x\n", val32_to_read);
// verify result
result = (val32_to_write == val32_to_read) ? 1 : 0;
//printf("\r\nResult is %s\r\n", (result) ? "success" : "fail");
DBG_8195A("\r\nResult is %s\r\n", (result) ? "success" : "fail");
result = 0;
}
#else
int VERIFY_SIZE = 256;
int SECTOR_SIZE = 16;
uint8_t writedata[VERIFY_SIZE];
uint8_t readdata[VERIFY_SIZE];
uint8_t verifydata = 0;
int loop = 0;
int index = 0;
int sectorindex = 0;
int result = 0;
int resultsector = 0;
int testloop = 0;
for(testloop = 0; testloop < 1; testloop++){
address = FLASH_APP_BASE;
for(sectorindex = 0; sectorindex < 4080; sectorindex++){
result = 0;
//address += SECTOR_SIZE;
flash_erase_sector(&flash, address);
//DBG_8195A("Address = %x \n", address);
for(loop = 0; loop < SECTOR_SIZE; loop++){
for(index = 0; index < VERIFY_SIZE; index++)
{
writedata[index] = verifydata + index;
}
flash_stream_write(&flash, address, VERIFY_SIZE, &writedata);
flash_stream_read(&flash, address, VERIFY_SIZE, &readdata);
for(index = 0; index < VERIFY_SIZE; index++)
{
//DBG_8195A("Address = %x, Writedata = %x, Readdata = %x \n",address,writedata[index],readdata[index]);
if(readdata[index] != writedata[index]){
DBG_8195A("Error: Loop = %d, Address = %x, Writedata = %x, Readdata = %x \n",testloop,address,writedata[index],readdata[index]);
}
else{
result++;
//DBG_8195A(ANSI_COLOR_BLUE"Correct: Loop = %d, Address = %x, Writedata = %x, Readdata = %x \n"ANSI_COLOR_RESET,testloop,address,writedata[index],readdata[index]);
}
}
address += VERIFY_SIZE;
}
if(result == VERIFY_SIZE * SECTOR_SIZE){
//DBG_8195A("Sector %d Success \n", sectorindex);
resultsector++;
}
}
if(resultsector == 4079){
DBG_8195A("Test Loop %d Success \n", testloop);
}
resultsector = 0;
verifydata++;
}
//DBG_8195A("%d Sector Success \n", resultsector);
DBG_8195A("Test Done");
#endif
for(;;);
}
void svc_flash_erase_sector(uint16_t sector) {
assert (!flash_locked);
assert (sector >= FLASH_META_SECTOR_FIRST &&
sector <= FLASH_META_SECTOR_LAST);
flash_erase_sector(sector, 3);
}
void main()
{
DisableInterrupts;
volatile u8 i;
u32 bianliang;
flash_init();
gpio_init (PORTA, 24, GPI_UP_PF,1);///////拨码
gpio_init (PORTA, 25, GPI_UP_PF,1);
gpio_init (PORTA, 6, GPI_UP_PF,1);
gpio_init (PORTA, 10, GPI_UP_PF,1);///////按键
gpio_init (PORTA, 12, GPI_UP_PF,1);
gpio_init (PORTA, 8, GPI_UP_PF,1);
if(gpio_get(PORTA,24)==1&&gpio_get(PORTA,25)==1&&gpio_get(PORTA,6)==0)
{
LCD_Init();
//flash_erase_sector(255);
// flash_write(255,0x004,0x03e8);/////////////////////////////需要给定初值时
while(1&&tx==0)
{
if(gpio_get(PORTA,10)==0)
{
delayms(100);
if(gpio_get(PORTA,10)==0)/////////确定按下加计数
{
bianliang=flash_read(255,0x004,u32);
delayms(50);
bianliang+=5;
flash_erase_sector(255);
delayms(50);
flash_write(255,0x004, (u32)bianliang);
delayms(50);
LCD_CLS();
LCD_PrintValueI(8, 4, bianliang);
}
}
if(gpio_get(PORTA,12)==0)
{
delayms(100);
if(gpio_get(PORTA,12)==0)
{
bianliang=flash_read(255,0x004,u32);
delayms(50);
bianliang-=5;
flash_erase_sector(255);
delayms(50);
flash_write(255,0x004,(u32)bianliang);
delayms(50);
LCD_CLS();//清屏
LCD_PrintValueI(8, 4,bianliang);
}
}
if(gpio_get(PORTA,8)==0)
{
delayms(100);
if(gpio_get(PORTA,8)==0)
{
tx=1;
}
else
tx=0;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////单道设置档
if(gpio_get(PORTA,24)==0&&gpio_get(PORTA,25)==1&&gpio_get(PORTA,6)==0)//////////////右转正值
{
LCD_Init();
while(1)
{
if(gpio_get(PORTA,10)==0)
{
delayms(100);
if(gpio_get(PORTA,10)==0)/////////单道右转
{
delayms(50);
flash_erase_sector(254);
delayms(50);
flash_write(254,0x004, (u32)6);
delayms(50);
LCD_Char( 10,3,'R');
LCD_Char(26 ,3,'+') ;
LCD_Char(32 ,3,'6') ;
}
}
if(gpio_get(PORTA,12)==0)
{
delayms(100);
if(gpio_get(PORTA,12)==0)/////////单道左转
{
delayms(50);
flash_erase_sector(254);
delayms(50);
flash_write(254,0x004, (u32)(-6));
delayms(50);
LCD_CLS();
LCD_Char( 10,3,'L');
LCD_Char(26 ,3,'-') ;
LCD_Char(32 ,3,'6') ;
}
}
if(gpio_get(PORTA,8)==0)
{
delayms(100);
if(gpio_get(PORTA,8)==0)/////////单道直道
{
delayms(50);
flash_erase_sector(254);
delayms(50);
flash_write(254,0x004, (u32)0);
delayms(50);
LCD_CLS();
LCD_Char(32 ,3,'0');
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////速度档位
if(gpio_get(PORTA,24)==1&&gpio_get(PORTA,25)==1&&gpio_get(PORTA,6)==1)/////////////////////
{
yz=10,yz1=6,yz2=3;///定义搜线阈值
buxianL=25,buxianR=27;//左右补线值
dandao=(int)flash_read(254,0x004,u32);
zhijiao=8;//直角延时场数
quanheiMAX=60;//全黑最大值
quanbaiMIN=80;//全白最小值
dandaoBDD=9.455;////////////////////////////////////////////////////////////
dandaoHDD=9.455;////////////////////////////////////////////////////////////
zhijiaoBDpwmmax=500.0;
zhijiaoBS_Kp=10.0;
zhijiaoBD_Kp=378.25;
zhijiaoHDpwmmax=300.0;
zhijiaoHS_Kp=42.0;//50轻微振荡
zhijiaoHD_Kp=305.25;//299.25
zkp=2200;//清华PD：2053 卡尔曼PD：2200
zkd=47;//44/////////////50
S_Kpstart=10.0;// 1.3
S_Kistart=33.91;//11.8
S_Kpend=42.0;///////////////29.0
S_Kiend=32.01;//11.8
Sqiwang =1400;// 1.3
Sjishu =7;//11.8
D_Kp =305.25; //299.25
D_Kd =300.0;//
D_Kdd=9.455;//12.05
zhangaiDmax=300.0;
direction_pwmmax=300.0;
}
if(gpio_get(PORTA,24)==0&&gpio_get(PORTA,25)==1&&gpio_get(PORTA,6)==1)/////////////////////
{
yz=10,yz1=6,yz2=3;///定义搜线阈值
buxianL=25,buxianR=27;//左右补线值
dandao=(int)flash_read(254,0x004,u32);
zhijiao=10;//直角延时场数
quanheiMAX=60;//全黑最大值
quanbaiMIN=80;//全白最小值
dandaoBDD=9.455;////////////////////////////////////////////////////////////
dandaoHDD=9.455;////////////////////////////////////////////////////////////
zhijiaoBDpwmmax=500.0;
zhijiaoBS_Kp=10.0;
zhijiaoBD_Kp=378.25;
zhijiaoHDpwmmax=300.0;
zhijiaoHS_Kp=42.0;//50轻微振荡
zhijiaoHD_Kp=305.25;//299.25
zkp=2200;//清华PD：2053 卡尔曼PD：2200
zkd=47;//44/////////////50
S_Kpstart=10.0;// 1.3
S_Kistart=33.91;//11.8
S_Kpend=42.0;///////////////29.0
S_Kiend=32.01;//11.8
Sqiwang =1400;// 1.3
Sjishu =7;//11.8
D_Kp =305.25; //299.25
D_Kd =300.0;//
D_Kdd=9.455;//12.05
zhangaiDmax=300.0;
direction_pwmmax=300.0;
}
if(gpio_get(PORTA,24)==1&&gpio_get(PORTA,25)==0&&gpio_get(PORTA,6)==1)/////////////////////
{
yz=10,yz1=6,yz2=3;///定义搜线阈值
buxianL=25,buxianR=27;//左右补线值
dandao=(int)flash_read(254,0x004,u32);
zhijiao=12;//直角延时场数
quanheiMAX=60;//全黑最大值
quanbaiMIN=80;//全白最小值
dandaoBDD=9.455;////////////////////////////////////////////////////////////
dandaoHDD=9.455;////////////////////////////////////////////////////////////
zhijiaoBDpwmmax=500.0;
zhijiaoBS_Kp=10.0;
zhijiaoBD_Kp=378.25;
zhijiaoHDpwmmax=300.0;
zhijiaoHS_Kp=42.0;//50轻微振荡
zhijiaoHD_Kp=305.25;//299.25
zkp=2200;//清华PD：2053 卡尔曼PD：2200
zkd=47;//44/////////////50
S_Kpstart=10.0;// 1.3
S_Kistart=33.91;//11.8
S_Kpend=42.0;///////////////29.0
S_Kiend=32.01;//11.8
Sqiwang =1400;// 1.3
Sjishu =7;//11.8
D_Kp =305.25; //299.25
D_Kd =300.0;//
D_Kdd=9.455;//12.05
zhangaiDmax=300.0;
direction_pwmmax=300.0;
}
if(gpio_get(PORTA,24)==0&&gpio_get(PORTA,25)==0&&gpio_get(PORTA,6)==1)//////////////////////最低速 1400
{
yz=10,yz1=6,yz2=3;///定义搜线阈值
buxianL=25,buxianR=27;//左右补线值
dandao=(int)flash_read(254,0x004,u32);
zhijiao=14;//直角延时场数
quanheiMAX=60;//全黑最大值
quanbaiMIN=80;//全白最小值
dandaoBDD=9.455;////////////////////////////////////////////////////////////
dandaoHDD=9.455;////////////////////////////////////////////////////////////
zhijiaoBDpwmmax=500.0;
zhijiaoBS_Kp=10.0;
zhijiaoBD_Kp=378.25;
zhijiaoHDpwmmax=300.0;
zhijiaoHS_Kp=42.0;//50轻微振荡
zhijiaoHD_Kp=305.25;//299.25
zkp=2200;//清华PD：2053 卡尔曼PD：2200
zkd=47;//44/////////////50
S_Kpstart=10.0;// 1.3
S_Kistart=33.91;//11.8
S_Kpend=42.0;///////////////29.0
S_Kiend=32.01;//11.8
Sqiwang =1400;// 1.3
Sjishu =7;//11.8
D_Kp =305.25; //299.25
D_Kd =300.0;//
D_Kdd=9.455;//12.05
zhangaiDmax=300.0;
direction_pwmmax=300.0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////特殊速度档
if(gpio_get(PORTA,24)==0&&gpio_get(PORTA,25)==0&&gpio_get(PORTA,6)==0)
{
yz=10,yz1=6,yz2=3;///定义搜线阈值
buxianL=25,buxianR=27;//左右补线值
dandao=(int)flash_read(254,0x004,u32);
zhijiao=14;//直角延时场数
quanheiMAX=60;//全黑最大值
quanbaiMIN=80;//全白最小值
dandaoBDD=9.455;////////////////////////////////////////////////////////////
dandaoHDD=9.455;////////////////////////////////////////////////////////////
zhijiaoBDpwmmax=500.0;
zhijiaoBS_Kp=10.0;
zhijiaoBD_Kp=378.25;
zhijiaoHDpwmmax=300.0;
zhijiaoHS_Kp=42.0;//50轻微振荡
zhijiaoHD_Kp=305.25;//299.25
zkp=2400;//清华PD：2053 卡尔曼PD：2200
zkd=47;//44/////////////50
S_Kpstart=10.0;// 1.3
S_Kistart=31.91;//11.8
S_Kpend=42.0;///////////////29.0
S_Kiend=30.01;//11.8
Sqiwang =1400;// 1.3
Sjishu =7;//11.8
D_Kp =305.25; //299.25
D_Kd =300.0;//
D_Kdd=9.455;//12.05
zhangaiDmax=300.0;
direction_pwmmax=300.0;
}
if(gpio_get(PORTA,24)==1&&gpio_get(PORTA,25)==0&&gpio_get(PORTA,6)==0)//////////////////////////有值太大
{
yz=10,yz1=6,yz2=3;///定义搜线阈值
buxianL=25,buxianR=27;//左右补线值
dandao=(int)flash_read(254,0x004,u32);
zhijiao=16;//直角延时场数
quanheiMAX=60;//全黑最大值
quanbaiMIN=80;//全白最小值
dandaoBDD=9.455;////////////////////////////////////////////////////////////
dandaoHDD=9.455;////////////////////////////////////////////////////////////
zhijiaoBDpwmmax=500.0;
zhijiaoBS_Kp=10.0;
zhijiaoBD_Kp=378.25;
zhijiaoHDpwmmax=300.0;
zhijiaoHS_Kp=42.0;//50轻微振荡
zhijiaoHD_Kp=305.25;//299.25
zkp=2400;//清华PD：2053 卡尔曼PD：2200
zkd=47;//44/////////////50
S_Kpstart=10.0;// 1.3
S_Kistart=31.91;//11.8
S_Kpend=42.0;///////////////29.0
S_Kiend=30.01;//11.8
Sqiwang =1400;// 1.3
Sjishu =7;//11.8
D_Kp =305.25; //299.25
D_Kd =300.0;//
D_Kdd=9.455;//12.05
zhangaiDmax=300.0;
direction_pwmmax=300.0;
}
/**/
//串口初始化
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
if(tx==1)
uart_init(UART5,115200);
else
uart_init(UART5,9600);
asm("nop");
asm("nop");
//CCD及其各引脚初始化
CCD1_init() ;
CCD2_init() ;
asm("nop");
asm("nop");
//PWM输出初始化
FTM_PWM_init(FTM0, CH0, 10000, 0); //R后退
FTM_PWM_init(FTM0, CH1, 10000, 0); //R前进
FTM_PWM_init(FTM0, CH2, 10000, 0); //L后退
FTM_PWM_init(FTM0, CH3, 10000, 0); //L前进
//拨码初始化
// gpio_init (PORTA, 7, GPI_UP_PF,1);
asm("nop");
asm("nop");
gpio_init (PORTE, 1, GPI,0);
gpio_init (PORTD, 15, GPI,0);
gpio_init (PORTD, 14, GPI,0);
gpio_init (PORTD, 12,GPI,0);
asm("nop");
asm("nop");
asm("nop");
asm("nop");
//正交解码初始化
FTM1_QUAD_Iint();
FTM2_QUAD_Iint();
asm("nop");
asm("nop");
asm("nop");
asm("nop");
//各种中断初始化
pit_init_ms(PIT0, 1);
asm("nop");
asm("nop");
asm("nop");
asm("nop");
// 陀螺仪及加速度计初始化
adc_init(ADC0, AD12); ////// PTB2 ENC
adc_init(ADC0, AD12); ///PTB3 Z
adc_init(ADC0, AD17); ///PTE24 DIR_ENC
/////////////////////////////////////////////////陀螺仪开机自检
delayms(1000);
gpio_init (PORTA, 17, GPO, 0);
MMA7361level=flash_read(255,0x004,u32);
rectifyT = ad_ave(ADC0,SE12,ADC_12bit,10);
gyro_DIR=ad_ave(ADC0,SE17,ADC_12bit,10);
// gyro_DIR=gyro_DIR/20;
/////////////////////////////////////////////////
// gpio_init (PORTC, 0, GPI,0);不知道要用否
delayms(1500);
EnableInterrupts;
while(1)
{
if((gpio_get(PORTD,12)==0)&&(gpio_get(PORTD,14)==0))//||(gpio_get(PORTE,1)==1)
{b=1;d=0;}
if(fs>=1)
{
DisableInterrupts;
fs=0;js=0;
ImageCapture1(Pixel1);
ImageCapture2(Pixel2);
EnableInterrupts;
Analyze_CCD_Data();
}
if(tx==1)
{
sendDataToCCDViewer(0,Pixel1);//////////////////////////////////////
sendDataToCCDViewer(1,Pixel2);
sendDataToScope();
}
else
{
OutData[0]=Min_Data1;//L_Max_Data_Place3
OutData[1]=Max_Data1;//R_Max_Data_Place1
OutData[2]=L_Max_Data_Place1; //L_Max_Data_Place1
OutData[3]=R_Max_Data_Place1;//
OutPut_Data();
}//
//sb[0]=FTM1_CNT;
//sb[1]=MMA7361;
// tongxun();
}
}
