void sampleMemory_loadSamples()
{
uint8_t numSamples = sd_getNumSamples();
if(numSamples==0) return;
//erase user memory flash
FLASH_If_Erase(SAMPLE_ROM_START_ADDRESS);
sampleMemory_setNumSamples(numSamples);
//reserve space for sample info header
SampleInfo info[50];
uint32_t addr = 0;
uint8_t i;
for(i=0;i<numSamples;i++)
{
sd_setActiveSample(i);
uint32_t len = sd_getActiveSampleLength();
char* name = sd_getActiveSampleName();
memcpy(info[i].name, name,3);
info[i].offset = SAMPLE_ROM_START_ADDRESS + 4 + addr*4; //+1 because of num_samples
info[i].size = len/2;
uint32_t j;
for(j=0;j<len;)
{
int16_t data[BLOCKSIZE];
// uint16_t bytesRead;
// bytesRead = sd_readSampleData(data, BLOCKSIZE);
sd_readSampleData(data, BLOCKSIZE);
volatile uint32_t add = 4+SAMPLE_ROM_START_ADDRESS + 4*addr; //*4 because we write uint32
FLASH_If_Write(&add, (uint32_t*)data, BLOCKSIZE/2);
j += BLOCKSIZE*2;
addr += BLOCKSIZE/2;
}
}
//write info header
volatile uint32_t add = SAMPLE_INFO_START_ADDRESS ;
FLASH_If_Write(&add, (uint32_t*)(info), numSamples*sizeof(SampleInfo)/4 + 1);
spi_deInit();
}
//---------------------------------------------------------------
void sampleMemory_setNumSamples(uint8_t num)
{
// sampleMemory_data[0] = num;
uint32_t data = num;
volatile uint32_t add = SAMPLE_ROM_START_ADDRESS; //*4 because we write uint32
FLASH_If_Write(&add, (uint32_t*)&data, 1);
}
/****************************************************************************************
** 函数名称: FlashParaUpdate
** 功能描述: 更新Flash 中保存的参数
** 参 数: 无
** 返 回 值: none
** 作 者: Sevent
** 日 期: 2013年08月27日
**---------------------------------------------------------------------------------------
** 修 改 人:
** 日 期:
**--------------------------------------------------------------------------------------
****************************************************************************************/
void FlashParaUpdate(EAbox_st *configData)
{
uint32_t paraStartAddress, paraEndAddress;
paraStartAddress = PARA_START_ADDRESS;
paraEndAddress = PARA_END_ADDRESS;
FLASH_If_Init();
FLASH_If_Erase(paraStartAddress, paraEndAddress); // 擦除16K 数据保存区;
FLASH_If_Write(¶StartAddress, (u32 *)configData, sizeof(eabox_config_t));
FLASH_Lock();
}
void updateConfiguration(mxchipWNet_HA_st *configData)
{
uint32_t paraStartAddress, paraEndAddress;
paraStartAddress = PARA_START_ADDRESS;
paraEndAddress = PARA_END_ADDRESS;
FLASH_If_Init();
FLASH_If_Erase(paraStartAddress, paraEndAddress);
FLASH_If_Write(¶StartAddress, (u32 *)&configData->conf, sizeof(mxchipWNet_HA_config_st));
FLASH_Lock();
}
void updateConfig(config_t *pConfig)
{
uint32_t paraStartAddress, paraEndAddress;
paraStartAddress = PARA_START_ADDRESS;
paraEndAddress = PARA_END_ADDRESS;
FLASH_If_Init();
FLASH_If_Erase(paraStartAddress, paraEndAddress); // 擦除16K 数据保存区;
FLASH_If_Write(¶StartAddress, (u32 *)pConfig, sizeof(config_t));
FLASH_Lock();
}
void restoreConfiguration(void)
{
EAbox_st EAboxInit;
uint32_t paraStartAddress, paraEndAddress;
paraStartAddress = PARA_START_ADDRESS;
paraEndAddress = PARA_END_ADDRESS;
memset(&EAboxInit, 0x0, sizeof(EAbox_st));
EAboxInit.conf.magicNumber = MAGIC_FLAG;
FLASH_If_Init();
FLASH_If_Erase(paraStartAddress, paraEndAddress); // 擦除16K 数据保存区;
FLASH_If_Write(¶StartAddress, (void *)&EAboxInit, sizeof(eabox_config_t));
FLASH_Lock();
}
uint8 program_move(uint16 crc)
{ uint16 app_crc;
uint16 cmp = 2;
int t = 0;
uint32_t addr_src = APP_ERCODE_ADDRESS;
uint32_t addr_dst = APPLICATION_ADDRESS;
FLASH_If_Init();
FLASH_If_Erase(APP_ERCODE_ADDRESS);
FLASH_If_Write((__IO uint32_t* )&addr_dst, (uint32_t*)addr_src ,(0x400/4*29));
FLASH_Lock();
app_crc = cal_crc16((uint8*)APPLICATION_ADDRESS, 0x400*29);
if(crc == app_crc) return 0;
return 1;
}
/**
* @brief Programs the internal Flash memory.
* @param None
* @retval None
*/
static void COMMAND_ProgramFlashMemory(void)
{
uint32_t programcounter = 0x00;
uint8_t readflag = TRUE;
uint16_t bytesread;
/* RAM Address Initialization */
RamAddress = (uint32_t) &RAM_Buf;
/* Erase address init */
LastPGAddress = APPLICATION_ADDRESS;
/* While file still contain data */
while ((readflag == TRUE))
{
/* Read maximum 512 Kbyte from the selected file */
f_read (&MyFileR, RAM_Buf, BUFFER_SIZE, (void *)&bytesread);
/* Temp variable */
TmpReadSize = bytesread;
/* The read data < "BUFFER_SIZE" Kbyte */
if(TmpReadSize < BUFFER_SIZE)
{
readflag = FALSE;
}
/* Program flash memory */
for(programcounter = TmpReadSize; programcounter != 0; programcounter -= 4)
{
TmpProgramCounter = programcounter;
/* Write word into flash memory */
if( FLASH_If_Write((LastPGAddress- TmpProgramCounter + TmpReadSize), \
*(uint32_t *)(RamAddress - programcounter + TmpReadSize )) != 0x00)
{
/* Flash programming error: Turn LED3 On and Toggle LED3 in infinite loop */
BSP_LED_On(LED3);
Fail_Handler();
}
}
/* Update last programmed address value */
LastPGAddress = LastPGAddress + TmpReadSize;
}
}
void restoreConfig(void)
{
config_t config;
net_para_st netPara;
uint32_t paraStartAddress, paraEndAddress;
paraStartAddress = PARA_START_ADDRESS;
paraEndAddress = PARA_END_ADDRESS;
getNetPara(&netPara,Station);
memset(&config, 0x0, sizeof(config_t));
config.magicNumber = MAGIC_FLAG;
sprintf((char*)config.wifi_ssid , "MXCHIP_%s", netPara.mac+6);
sprintf((char*)config.wifi_key , "");
FLASH_If_Init();
FLASH_If_Erase(paraStartAddress, paraEndAddress); // 擦除16K 数据保存区;
FLASH_If_Write(¶StartAddress, (void *)&config, sizeof(config_t));
FLASH_Lock();
}
void FlashConfig(void)
{
if(FLASH_If_Erase(CONFIG_BASE_ADDRESS,NUMBER_OF_CONFIG_PAGES) == FLASHIF_ERASEKO)
{
UserPrintf("Error:flash config error\n");
}
else
{
uint16_t config_size = sizeof(SystemConfig)/sizeof(uint32_t) + 1; // 防止不能被4整除
if(FLASH_If_Write(CONFIG_BASE_ADDRESS,(uint32_t *)&SystemConfig, config_size) == 0)
{
UserPrintf("Info:Flash success\n");
}
else
{
UserPrintf("Error:Flash error!Please retry\n");
}
}
}
void restoreConfiguration(void)
{
mxchipWNet_HA_st mxchipWNet_HA_Init;
uint32_t paraStartAddress, paraEndAddress;
paraStartAddress = PARA_START_ADDRESS;
paraEndAddress = PARA_END_ADDRESS;
memset(&mxchipWNet_HA_Init, 0x0, sizeof(mxchipWNet_HA_st));
mxchipWNet_HA_Init.conf.magicNumber = MAGIC_FLAG;
mxchipWNet_HA_Init.conf.versionNumber = CONFIGURATION_VERSION;
mxchipWNet_HA_Init.conf.dhcp_enable = 1;
strcpy((char*)mxchipWNet_HA_Init.conf.sta_ssid, DEFAULT_STA_SSID);
strcpy((char*)mxchipWNet_HA_Init.conf.sta_key, DEFAULT_STA_KEY);
strcpy((char*)mxchipWNet_HA_Init.conf.uap_ssid, DEFAULT_UAP_SSID);
strcpy((char*)mxchipWNet_HA_Init.conf.uap_key, DEFAULT_UAP_KEY);
strcpy((char*)mxchipWNet_HA_Init.conf.server_domain, DEFAULT_REMOTE_ADDR);
mxchipWNet_HA_Init.conf.server_port = DEFAULT_REMOTE_PORT;
FLASH_If_Init();
FLASH_If_Erase(paraStartAddress, paraEndAddress);
FLASH_If_Write(¶StartAddress, (void *)&mxchipWNet_HA_Init, sizeof(mxchipWNet_HA_config_st));
FLASH_Lock();
}
void updateProgram(void)
{
int clear = 0;
int cmdByte, i, temp;
FLASH_EraseResult result;
uint32_t addr, maxAddr = 0;
uint16_t endSector = 0xFFFF;
_ee_getReserved(_AI_EE_RES_ADDR_MAX_SECTOR, &endSector);
if (endSector > APPLICATION_END_SECTOR || !IS_FLASH_SECTOR(endSector))
endSector = APPLICATION_END_SECTOR;
lcd_clear();
lcd_printf("Aithon Board\nProgramming...");
// Unlock the Flash Program Erase controller
FLASH_If_Init();
while (TRUE)
{
led_toggle(0);
cmdByte = getByte();
debugPrintCmd(cmdByte);
switch (cmdByte)
{
case SYNC:
// sync
flushInterface();
sendResponse(SYNC, ACK);
break;
case ERASE_FLASH_START:
if (FLASH_If_Erase_Start() == FLASH_ERASE_IN_PROGRESS)
sendResponse(ERASE_FLASH_START, ACK);
else
sendResponse(ERASE_FLASH_START, NACK);
break;
case ERASE_FLASH_STATUS:
result = FLASH_If_Erase_Status(endSector);
if (result == FLASH_ERASE_COMPLETE)
sendResponse(ERASE_FLASH_STATUS, ACK);
else if (result == FLASH_ERASE_IN_PROGRESS)
sendResponse(ERASE_FLASH_STATUS, BUSY);
else
sendResponse(ERASE_FLASH_STATUS, NACK);
break;
case SET_ADDR:
// Read in the address, MSB first.
addr = 0;
for (i = 0; i < 4; i++)
{
if ((temp = getByte()) == Q_TIMEOUT)
break;
addr |= (((uint8_t) temp) & 0xFF) << (i * 8);
}
// Check for errors.
if (temp == Q_TIMEOUT)
sendResponse(SET_ADDR, NACK);
else
{
sendResponse(SET_ADDR, ACK);
// We'll get relative addresses, so add the start address.
addr += APPLICATION_START_ADDRESS;
}
break;
case CHECK_ADDR:
// Get the checksum
temp = getByte();
if (temp == Q_TIMEOUT)
sendResponse(CHECK_ADDR, NACK);
else
{
// Subtract the start address before calculating the checksum
addr -= APPLICATION_START_ADDRESS;
if (temp == calcChecksum((uint8_t *)&addr, 4))
sendResponse(CHECK_ADDR, ACK);
else
sendResponse(CHECK_ADDR, NACK);
addr += APPLICATION_START_ADDRESS;
}
break;
case FILL_BUFFER:
for (i = 0; i < PACKET_LEN; i++)
{
if ((temp = getByte()) == Q_TIMEOUT)
break;
_buffer[i] = (uint8_t) (temp & 0xFF);
}
if (temp == Q_TIMEOUT)
sendResponse(FILL_BUFFER, NACK);
else
sendResponse(FILL_BUFFER, ACK);
break;
case CHECK_BUFFER:
// Get the checksum
temp = getByte();
if (temp != Q_TIMEOUT && temp == calcChecksum(_buffer, PACKET_LEN))
sendResponse(CHECK_BUFFER, ACK);
else
sendResponse(CHECK_BUFFER, NACK);
break;
case COMMIT_BUFFER:
maxAddr = addr + PACKET_LEN - 1;
if (FLASH_If_Write((__IO uint32_t *)&addr, (uint32_t *)_buffer, PACKET_LEN/4))
sendResponse(COMMIT_BUFFER, NACK);
else
sendResponse(COMMIT_BUFFER, ACK);
break;
case START_PROGRAM:
sendResponse(START_PROGRAM, ACK);
flushInterface();
_ee_putReserved(_AI_EE_RES_ADDR_MAX_SECTOR, FLASH_Addr_To_Sector(maxAddr));
delayS(1);
startProgram();
// ...should never get here
return;
case Q_TIMEOUT:
default:
if (clear == 0) {
lcd_clear();
clear = 1;
}
lcd_printf ("0%x ", cmdByte);
break;
}
}
}
/**
* @brief Receive a file using the ymodem protocol with CRC16.
* @param p_size The size of the file.
* @retval COM_StatusTypeDef result of reception/programming
*/
COM_StatusTypeDef Ymodem_Receive ( uint32_t *p_size )
{
uint32_t i, packet_length, session_done = 0, file_done, errors = 0, session_begin = 0;
uint32_t flashdestination, ramsource, filesize;
uint8_t *file_ptr;
uint8_t file_size[FILE_SIZE_LENGTH], tmp, packets_received;
COM_StatusTypeDef result = COM_OK;
/* Initialize flashdestination variable */
flashdestination = APPLICATION_ADDRESS;
while ((session_done == 0) && (result == COM_OK))
{
packets_received = 0;
file_done = 0;
while ((file_done == 0) && (result == COM_OK))
{
switch (ReceivePacket(aPacketData, &packet_length, DOWNLOAD_TIMEOUT))
{
case HAL_OK:
errors = 0;
switch (packet_length)
{
case 2:
/* Abort by sender */
Serial_PutByte(ACK);
result = COM_ABORT;
break;
case 0:
/* End of transmission */
Serial_PutByte(ACK);
file_done = 1;
break;
default:
/* Normal packet */
if (aPacketData[PACKET_NUMBER_INDEX] != packets_received)
{
Serial_PutByte(NAK);
}
else
{
if (packets_received == 0)
{
/* File name packet */
if (aPacketData[PACKET_DATA_INDEX] != 0)
{
/* File name extraction */
i = 0;
file_ptr = aPacketData + PACKET_DATA_INDEX;
while ( (*file_ptr != 0) && (i < FILE_NAME_LENGTH))
{
aFileName[i++] = *file_ptr++;
}
/* File size extraction */
aFileName[i++] = '\0';
i = 0;
file_ptr ++;
while ( (*file_ptr != ' ') && (i < FILE_SIZE_LENGTH))
{
file_size[i++] = *file_ptr++;
}
file_size[i++] = '\0';
Str2Int(file_size, &filesize);
/* Test the size of the image to be sent */
/* Image size is greater than Flash size */
if (*p_size > (USER_FLASH_SIZE + 1))
{
/* End session */
tmp = CA;
HAL_UART_Transmit(&UartHandle, &tmp, 1, NAK_TIMEOUT);
HAL_UART_Transmit(&UartHandle, &tmp, 1, NAK_TIMEOUT);
result = COM_LIMIT;
}
/* erase user application area */
FLASH_If_Erase(APPLICATION_ADDRESS);
*p_size = filesize;
Serial_PutByte(ACK);
Serial_PutByte(CRC16);
}
/* File header packet is empty, end session */
else
{
Serial_PutByte(ACK);
file_done = 1;
session_done = 1;
break;
}
}
else /* Data packet */
{
ramsource = (uint32_t) & aPacketData[PACKET_DATA_INDEX];
/* Write received data in Flash */
if (FLASH_If_Write(flashdestination, (uint32_t*) ramsource, packet_length/4) == FLASHIF_OK)
{
flashdestination += packet_length;
Serial_PutByte(ACK);
}
else /* An error occurred while writing to Flash memory */
{
/* End session */
Serial_PutByte(CA);
Serial_PutByte(CA);
result = COM_DATA;
}
}
packets_received ++;
session_begin = 1;
}
break;
}
break;
case HAL_BUSY: /* Abort actually */
Serial_PutByte(CA);
Serial_PutByte(CA);
result = COM_ABORT;
break;
default:
if (session_begin > 0)
{
errors ++;
}
if (errors > MAX_ERRORS)
{
/* Abort communication */
Serial_PutByte(CA);
Serial_PutByte(CA);
}
else
{
Serial_PutByte(CRC16); /* Ask for a packet */
}
break;
}
}
}
return result;
}
static void get_update_post(int index, char *postdata, int len)
{
static const char endline[] = {'\r', '\n', '\r', '\n'};
static const char lengthstr[] = "Content-Length: ";
static const char boundarystr[] = "boundary=";
char *boundcp, *boundary, *p;
char *read_buffer = postdata, *end_pos = NULL, *lengthpos;
int read_buffer_size = len, time=5000;
int bytes_received, read_len, content_len = 0, total_read;
const char *resp;
u32 addr = UPDATE_START_ADDRESS;
/* Firmware update: OTA from webserver*/
setsockopt(index,0, SO_RCVTIMEO, &time, 4);
/* Get the content length & boundary & begin of content data */
do {
end_pos = (char*) memmem(read_buffer, read_buffer_size, endline, sizeof(endline));
if ( ( lengthpos = (char*) memmem( read_buffer, read_buffer_size, lengthstr, strlen( lengthstr )) ) != NULL )
{
content_len = atoi(lengthpos + sizeof( lengthstr)-1);
}
if (( boundary = (char*) memmem( read_buffer, read_buffer_size, boundarystr, strlen(boundarystr) )) != NULL )
{
boundary += strlen(boundarystr);
p = boundary;
while(*p != 0x0d)
p++;
*p++ = 0;
// now, we have found out the boundary, copy out.
boundcp = (char*)malloc(strlen(boundary)+1);
if (boundcp != NULL) {
strcpy(boundcp, boundary);
}
}
if (end_pos == NULL)
{
read_buffer = httpRequest;
bytes_received = recv(index, httpRequest, HTTP_DATA_MAX_LEN, 0 );
if ( bytes_received <= 0 )
{
break;
}
else
{
total_read += bytes_received;
read_buffer_size = bytes_received;
}
}
} while ( end_pos == NULL );
if (boundcp == NULL || content_len == 0) {
resp = systemResponseError;
goto EXIT;
}
end_pos += sizeof(endline);
read_buffer_size = read_buffer_size - (end_pos-read_buffer);
content_len -= read_buffer_size;
read_buffer = end_pos;
/* Get the begin of file data and write to flash */
do {
end_pos = (char*)memmem(read_buffer, read_buffer_size, endline, sizeof(endline));
if (end_pos == NULL)
{
read_buffer = httpRequest;
bytes_received = recv(index, httpRequest, HTTP_DATA_MAX_LEN, 0 );
if ( bytes_received <= 0 )
{
break;
}
else
{
content_len -= bytes_received;
read_buffer_size = bytes_received;
if (content_len <= 0)
break;
}
}
} while ( end_pos == NULL );
if (end_pos == NULL) {
resp = systemResponseError;
goto EXIT;
}
SetTimer(6000, delay_reload); // whether success or not, need reload system to use bootload erase NEW Image flash.
FLASH_If_Init();
end_pos += sizeof(endline);
read_buffer_size = read_buffer_size - (end_pos-read_buffer);
if (read_buffer_size > 0) {
FLASH_If_Write(&addr, (void *)end_pos, read_buffer_size);
}
content_len -= strlen(boundcp) - 4; // last string is '--'+boudnary+'--'
/* Recv file and write to flash, if it's last package, find the end of file to write */
while(content_len > 0) {
if (content_len > HTTP_DATA_MAX_LEN)
read_len = HTTP_DATA_MAX_LEN;
else
read_len = content_len;
bytes_received = recv(index, httpRequest, read_len, 0 );
if ( bytes_received <= 0 )
{
break;
}
FLASH_If_Write(&addr, (void *)httpRequest, bytes_received);
content_len -= bytes_received;
}
if (content_len == 0) {
memset(&configParas, 0, sizeof(boot_table_t));
configParas.bootTable.length = addr - UPDATE_START_ADDRESS;
configParas.bootTable.start_address = UPDATE_START_ADDRESS;
configParas.bootTable.type = 'A';
configParas.bootTable.upgrade_type = 'U';
updateConfig(&configParas);
resp = systemResponseSucc;
} else
resp = systemResponseError;
EXIT:
FLASH_Lock();
sprintf(httpRequest, HTTPSaveResponse,
strlen(resp), resp);
send_http_data(index, httpRequest, strlen(httpRequest));
}
/**
* @brief Receive a file using the ymodem protocol.
* @param buf: Address of the first byte.
* @retval The size of the file.
*/
int32_t Ymodem_Receive (uint8_t *buf)
{
uint8_t packet_data[PACKET_1K_SIZE + PACKET_OVERHEAD], file_size[FILE_SIZE_LENGTH], *file_ptr, *buf_ptr;
int32_t i, packet_length, session_done, file_done, packets_received, errors, session_begin, size = 0;
uint32_t flashdestination, ramsource;
/* Initialize flashdestination variable */
flashdestination = APPLICATION_ADDRESS;
for (session_done = 0, errors = 0, session_begin = 0; ;)
{
for (packets_received = 0, file_done = 0, buf_ptr = buf; ;)
{
switch (Receive_Packet(packet_data, &packet_length, NAK_TIMEOUT))
{
case 0:
errors = 0;
switch (packet_length)
{
/* Abort by sender */
case - 1:
Send_Byte(ACK);
return 0;
/* End of transmission */
case 0:
Send_Byte(ACK);
file_done = 1;
break;
/* Normal packet */
default:
if ((packet_data[PACKET_SEQNO_INDEX] & 0xff) != (packets_received & 0xff))
{
Send_Byte(NAK);
}
else
{
if (packets_received == 0)
{
/* Filename packet */
if (packet_data[PACKET_HEADER] != 0)
{
/* Filename packet has valid data */
for (i = 0, file_ptr = packet_data + PACKET_HEADER; (*file_ptr != 0) && (i < FILE_NAME_LENGTH);)
{
FileName[i++] = *file_ptr++;
}
FileName[i++] = '\0';
for (i = 0, file_ptr ++; (*file_ptr != ' ') && (i < FILE_SIZE_LENGTH);)
{
file_size[i++] = *file_ptr++;
}
file_size[i++] = '\0';
Str2Int(file_size, &size);
/* Test the size of the image to be sent */
/* Image size is greater than Flash size */
if (size > (USER_FLASH_SIZE + 1))
{
/* End session */
Send_Byte(CA);
Send_Byte(CA);
return -1;
}
/* erase user application area */
FLASH_If_Erase(APPLICATION_ADDRESS);
Send_Byte(ACK);
Send_Byte(CRC16);
}
/* Filename packet is empty, end session */
else
{
Send_Byte(ACK);
file_done = 1;
session_done = 1;
break;
}
}
/* Data packet */
else
{
memcpy(buf_ptr, packet_data + PACKET_HEADER, packet_length);
ramsource = (uint32_t)buf;
/* Write received data in Flash */
if (FLASH_If_Write(&flashdestination, (uint32_t*) ramsource, (uint16_t) packet_length/4) == 0)
{
Send_Byte(ACK);
}
else /* An error occurred while writing to Flash memory */
{
/* End session */
Send_Byte(CA);
Send_Byte(CA);
return -2;
}
}
packets_received ++;
session_begin = 1;
}
}
break;
case 1:
Send_Byte(CA);
Send_Byte(CA);
return -3;
default:
if (session_begin > 0)
{
errors ++;
}
if (errors > MAX_ERRORS)
{
Send_Byte(CA);
Send_Byte(CA);
return 0;
}
Send_Byte(CRC16);
break;
}
if (file_done != 0)
{
break;
}
}
if (session_done != 0)
{
break;
}
}
return (int32_t)size;
}
/*
*
* move the new_fimware to the firmware sector
*
*/
void firmware_write_firmware_temp_with_firmware() {
firmware_erase_firmware_temp();
FLASH_If_Write((uint32_t*)FIRMWARE_TEMP_FIRST_PAGE_ADDRESS, (uint32_t*)FIRMWARE_FIRST_PAGE_ADDRESS, FIRMWARE_SIZE);
}
/**
* @brief Processes data transfers after a TFTP write request
* @param _args: used as pointer on TFTP connection args
* @param upcb: pointer on udp_pcb structure
* @param pkt_buf: pointer on a pbuf stucture
* @param ip_addr: pointer on the receive IP_address structure
* @param port: receive port address
* @retval none
*/
static void IAP_wrq_recv_callback(void *_args, struct udp_pcb *upcb, struct pbuf *pkt_buf, struct ip_addr *addr, u16_t port)
{
tftp_connection_args *args = (tftp_connection_args *)_args;
uint32_t data_buffer[128];
char message[20];
u16 count=0;
if (pkt_buf->len != pkt_buf->tot_len)
{
return;
}
/* Does this packet have any valid data to write? */
if ((pkt_buf->len > TFTP_DATA_PKT_HDR_LEN) &&
(IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1)))
{
/* copy packet payload to data_buffer */
pbuf_copy_partial(pkt_buf, data_buffer, pkt_buf->len - TFTP_DATA_PKT_HDR_LEN,
TFTP_DATA_PKT_HDR_LEN);
total_count += pkt_buf->len - TFTP_DATA_PKT_HDR_LEN;
count = (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)/4;
if (((pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)%4)!=0)
count++;
/* Write received data in Flash */
FLASH_If_Write(&Flash_Write_Address, data_buffer ,count);
/* update our block number to match the block number just received */
args->block++;
/* update total bytes */
(args->tot_bytes) += (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN);
/* This is a valid pkt but it has no data. This would occur if the file being
written is an exact multiple of 512 bytes. In this case, the args->block
value must still be updated, but we can skip everything else. */
}
else if (IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1))
{
/* update our block number to match the block number just received */
args->block++;
}
/* Send the appropriate ACK pkt*/
IAP_tftp_send_ack_packet(upcb, addr, port, args->block);
/* If the last write returned less than the maximum TFTP data pkt length,
* then we've received the whole file and so we can quit (this is how TFTP
* signals the EndTransferof a transfer!)
*/
if (pkt_buf->len < TFTP_DATA_PKT_LEN_MAX)
{
IAP_tftp_cleanup_wr(upcb, args);
pbuf_free(pkt_buf);
#ifdef USE_LCD
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line5, (char*)"Tot bytes Received:");
sprintf(message, "%u bytes ",total_count);
LCD_DisplayStringLine(Line6, (uint8_t*)message);
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line9, (char*)"State: Prog Finished ");
#endif
BKP_WriteBackupRegister(BKP_DR11,0);
/* generate a watchdog reset */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
//SerialPutString("\r\nENABLE WTD! \n");
WWDG_Enable(0x40);
while(1);
}
else
{
pbuf_free(pkt_buf);
return;
}
}
/**
* @brief Processes data transfers after a TFTP write request
* @param _args: used as pointer on TFTP connection args
* @param upcb: pointer on udp_pcb structure
* @param pkt_buf: pointer on a pbuf stucture
* @param ip_addr: pointer on the receive IP_address structure
* @param port: receive port address
* @retval none
*/
static void IAP_wrq_recv_callback(void *_args, struct udp_pcb *upcb, struct pbuf *pkt_buf, struct ip_addr *addr, u16_t port)
{
tftp_connection_args *args = (tftp_connection_args *)_args;
uint32_t data_buffer[128];
u16 count=0;
static uint32_t process = 0;
static uint16_t process_x = UPDATE_WORD_START_X;
char buff[10];
static uint16_t process_buff = 0;
#ifdef USE_LCD
char message[40];
#endif
if (pkt_buf->len != pkt_buf->tot_len)
{
udp_lcd_y += UPDATE_WORD_SIZE + UPDATE_ROW_DISTANCE;
lcd_font24(udp_lcd_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,"> ÒÔÌ«ÍøÉý¼¶³ö´íÁË¡£´íÎó´úÂ룺2",UPDATE_FONT);
UDP_AddUpdateError();
// #ifdef USE_LCD
// LCD_SetTextColor(Red);
// LCD_DisplayStringLine(Line9, (uint8_t*)"Invalid data length");
// #endif
return;
}
/* Does this packet have any valid data to write? */
if ((pkt_buf->len > TFTP_DATA_PKT_HDR_LEN) &&
(IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1)))
{
/* copy packet payload to data_buffer */
pbuf_copy_partial(pkt_buf, data_buffer, pkt_buf->len - TFTP_DATA_PKT_HDR_LEN,
TFTP_DATA_PKT_HDR_LEN);
total_count += pkt_buf->len - TFTP_DATA_PKT_HDR_LEN;
count = (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)/4;
if (((pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)%4)!=0)
count++;
/* Write received data in Flash */
switch ( FLASH_If_Write(&Flash_Write_Address, data_buffer ,count) )
{
case 0:
process++;
if ((process % 30) == 0)
{
process_buff += 5;
lcd_font24(process_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,"-",UPDATE_FONT);
process_x += 12;
usprintf(buff,"%3d%%",process_buff);
lcd_font24(process_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,buff,UPDATE_FONT);
}
break;
case 1:
udp_lcd_y += UPDATE_WORD_SIZE + UPDATE_ROW_DISTANCE;
lcd_font24(udp_lcd_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,"> ÒÔÌ«ÍøÉý¼¶³ö´íÁË¡£´íÎó´úÂ룺3",UPDATE_FONT);
UDP_AddUpdateError();
case 2:
udp_lcd_y += UPDATE_WORD_SIZE + UPDATE_ROW_DISTANCE;
lcd_font24(udp_lcd_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,"> ÒÔÌ«ÍøÉý¼¶³ö´íÁË¡£´íÎó´úÂ룺4",UPDATE_FONT);
UDP_AddUpdateError();
}
/* update our block number to match the block number just received */
args->block++;
/* update total bytes */
(args->tot_bytes) += (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN);
/* This is a valid pkt but it has no data. This would occur if the file being
written is an exact multiple of 512 bytes. In this case, the args->block
value must still be updated, but we can skip everything else. */
}
else if (IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1))
{
/* update our block number to match the block number just received */
args->block++;
}
/* Send the appropriate ACK pkt*/
IAP_tftp_send_ack_packet(upcb, addr, port, args->block);
/* If the last write returned less than the maximum TFTP data pkt length,
* then we've received the whole file and so we can quit (this is how TFTP
* signals the EndTransferof a transfer!)
*/
if (pkt_buf->len < TFTP_DATA_PKT_LEN_MAX)
{
IAP_tftp_cleanup_wr(upcb, args);
pbuf_free(pkt_buf);
lcd_font24(process_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,"100%",UPDATE_FONT);
udp_lcd_y += UPDATE_WORD_SIZE + UPDATE_ROW_DISTANCE;
uPdateFinish = YES;
// #ifdef USE_LCD
// LCD_SetTextColor(White);
// LCD_DisplayStringLine(Line5, (uint8_t*)"Tot bytes Received:");
// sprintf(message, "%d bytes ",total_count);
// LCD_DisplayStringLine(Line6, (uint8_t*)message);
// LCD_DisplayStringLine(Line8, (uint8_t*)"State: Prog Finished ");
// #endif
}
else
{
// udp_lcd_y += UPDATE_WORD_SIZE + UPDATE_ROW_DISTANCE;
// lcd_font24(udp_lcd_x,udp_lcd_y,COLOR_POINT,COLOR_BACK,"Reset the board",UPDATE_FONT);
// #ifdef USE_LCD
// LCD_SetTextColor(Red);
// LCD_DisplayStringLine(Line9, (uint8_t*)" Reset the board ");
// #endif
pbuf_free(pkt_buf);
return;
}
}
/**
* @brief Processes data transfers after a TFTP write request
* @param _args: used as pointer on TFTP connection args
* @param upcb: pointer on udp_pcb structure
* @param pkt_buf: pointer on a pbuf stucture
* @param ip_addr: pointer on the receive IP_address structure
* @param port: receive port address
* @retval None
*/
static void IAP_wrq_recv_callback(void *_args, struct udp_pcb *upcb, struct pbuf *pkt_buf, struct ip_addr *addr, u16_t port)
{
tftp_connection_args *args = (tftp_connection_args *)_args;
uint32_t data_buffer[128];
uint16_t count=0;
#ifdef USE_LCD
char message[40];
#endif
if (pkt_buf->len != pkt_buf->tot_len)
{
#ifdef USE_LCD
LCD_ErrLog("Invalid data length\n");
#endif
return;
}
/* Does this packet have any valid data to write? */
if ((pkt_buf->len > TFTP_DATA_PKT_HDR_LEN) &&
(IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1)))
{
/* copy packet payload to data_buffer */
pbuf_copy_partial(pkt_buf, data_buffer, pkt_buf->len - TFTP_DATA_PKT_HDR_LEN,
TFTP_DATA_PKT_HDR_LEN);
total_count += pkt_buf->len - TFTP_DATA_PKT_HDR_LEN;
count = (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)/4;
if (((pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)%4)!=0)
count++;
/* Write received data in Flash */
FLASH_If_Write(&Flash_Write_Address, data_buffer ,count);
/* update our block number to match the block number just received */
args->block++;
/* update total bytes */
(args->tot_bytes) += (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN);
/* This is a valid pkt but it has no data. This would occur if the file being
written is an exact multiple of 512 bytes. In this case, the args->block
value must still be updated, but we can skip everything else. */
}
else if (IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1))
{
/* update our block number to match the block number just received */
args->block++;
}
/* Send the appropriate ACK pkt*/
IAP_tftp_send_ack_packet(upcb, addr, port, args->block);
/* If the last write returned less than the maximum TFTP data pkt length,
* then we've received the whole file and so we can quit (this is how TFTP
* signals the EndTransferof a transfer!)
*/
if (pkt_buf->len < TFTP_DATA_PKT_LEN_MAX)
{
IAP_tftp_cleanup_wr(upcb, args);
pbuf_free(pkt_buf);
#ifdef USE_LCD
sprintf(message, "%d bytes ",(int)total_count);
LCD_UsrLog("Tot bytes Received:, %s\n", message);
LCD_UsrLog(" State: Prog Finished \n");
LCD_UsrLog("Reset the board \n");
#endif
}
else
{
pbuf_free(pkt_buf);
return;
}
}
/*
*
* move the new_fimware to the firmware sector
*
*/
void firmware_write_firmware_with_new_firmware() {
firmware_erase_firmware();
FLASH_If_Write((uint32_t*)FIRMWARE_FIRST_PAGE_ADDRESS, (uint32_t*)NEW_FIRMWARE_FIRST_PAGE_ADDRESS, FIRMWARE_SIZE);
}
