rabit/CW_A5H_9225_8108
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

DVT

Browse Source
This commit is contained in:
陈春
2025-09-29 16:47:12 +08:00
parent 2d906350bf
commit 0a4832db5e
237 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

675
A5H_9225_8108_SPIV3.0/APP/ota/OtaApi.c
View File

@@ -1,675 +0,0 @@
#include "OtaApi.h"
#include "stdio.h"
#include "string.h"
#include "VsyncApi.h"
#include "xtal.h"
#include "FbApi.h"
#include "bl_ic_config.h"
// M C U V e u A B C D E F G H I J
#if (MODEL_TYPE== A5H_85_28_16_448_HY8108)
const uint8_t BconVersion[16]= {0x4d,0x43,0x55,0x56,0x65,0x72,
0x04,//MCU<43><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0x01 GD;0x02 NATION;0x03 NUVOTON 0x04 HYASIC
0x05,//<2F><><EFBFBD><EFBFBD>IC<49><43>0x01 IWAIT;0x02 MBI;0x03 NOVA;0x04 ICND 0X05 HYASIC
0x04,//<2F><><EFBFBD><EFBFBD><EFBFBD>ߴ磺0x01 55;0x02 65;0x03 75;0x04 86;0x05 90;0x06 98;0x07 100
0x05,//<2F><><EFBFBD><EFBFBD>ϵ<EFBFBD>У<EFBFBD>0x01 S;0x02 W;0x03 Q;0x04 G;0x05 A
0x5F,//<2F><><EFBFBD><EFBFBD>
0x01,//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO<52><4F>0x01 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x02 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x03 <20><><EFBFBD><EFBFBD>PRO;0x04 <20><><EFBFBD><EFBFBD>PRO
28,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
16,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
32,//<2F><>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
0x00 //MCU<43>汾
};
#elif (MODEL_TYPE== A5HP_65_40_22_880_HY8108)
const uint8_t BconVersion[16]= {0x4d,0x43,0x55,0x56,0x65,0x72,
0x04,//MCU<43><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0x01 GD;0x02 NATION;0x03 NUVOTON 0x04 HYASIC
0x05,//<2F><><EFBFBD><EFBFBD>IC<49><43>0x01 IWAIT;0x02 MBI;0x03 NOVA;0x04 ICND 0X05 HYASIC
0x02,//<2F><><EFBFBD><EFBFBD><EFBFBD>ߴ磺0x01 55;0x02 65;0x03 75;0x04 86;0x05 90;0x06 98;0x07 100
0x05,//<2F><><EFBFBD><EFBFBD>ϵ<EFBFBD>У<EFBFBD>0x01 S;0x02 W;0x03 Q;0x04 G;0x05 A
0x5F,//<2F><><EFBFBD><EFBFBD>
0x03,//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO<52><4F>0x01 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x02 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x03 <20><><EFBFBD><EFBFBD>PRO;0x04 <20><><EFBFBD><EFBFBD>PRO
40,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
22,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
9,//<2F><>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
0x00 //MCU<43>汾
};
#elif (MODEL_TYPE==A5HP_75_44_24_1056_HY8108)
const uint8_t BconVersion[16]= {0x4d,0x43,0x55,0x56,0x65,0x72,
0x04,//MCU<43><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0x01 GD;0x02 NATION;0x03 NUVOTON 0x04 HYASIC
0x05,//<2F><><EFBFBD><EFBFBD>IC<49><43>0x01 IWAIT;0x02 MBI;0x03 NOVA;0x04 ICND 0X05 HYASIC
0x03,//<2F><><EFBFBD><EFBFBD><EFBFBD>ߴ磺0x01 55;0x02 65;0x03 75;0x04 86;0x05 90;0x06 98;0x07 100
0x05,//<2F><><EFBFBD><EFBFBD>ϵ<EFBFBD>У<EFBFBD>0x01 S;0x02 W;0x03 Q;0x04 G;0x05 A
0x5F,//<2F><><EFBFBD><EFBFBD>
0x03,//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO<52><4F>0x01 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x02 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x03 <20><><EFBFBD><EFBFBD>PRO;0x04 <20><><EFBFBD><EFBFBD>PRO
44,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
24,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
9,//<2F><>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
0x00 //MCU<43>汾
};
#elif (MODEL_TYPE==A5HP_85_48_28_1344_HY8108)
const uint8_t BconVersion[16]= {0x4d,0x43,0x55,0x56,0x65,0x72,
0x04,//MCU<43><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0x01 GD;0x02 NATION;0x03 NUVOTON 0x04 HYASIC
0x05,//<2F><><EFBFBD><EFBFBD>IC<49><43>0x01 IWAIT;0x02 MBI;0x03 NOVA;0x04 ICND 0X05 HYASIC
0x04,//<2F><><EFBFBD><EFBFBD><EFBFBD>ߴ磺0x01 55;0x02 65;0x03 75;0x04 86;0x05 90;0x06 98;0x07 100
0x05,//<2F><><EFBFBD><EFBFBD>ϵ<EFBFBD>У<EFBFBD>0x01 S;0x02 W;0x03 Q;0x04 G;0x05 A
0x5F,//<2F><><EFBFBD><EFBFBD>
0x03,//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO<52><4F>0x01 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x02 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PRO;0x03 <20><><EFBFBD><EFBFBD>PRO;0x04 <20><><EFBFBD><EFBFBD>PRO
48,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
28,//ÿ<>з<EFBFBD><D0B7><EFBFBD><EFBFBD><EFBFBD>
11,//<2F><>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
0x00 //MCU<43>汾
};
#endif
const unsigned int crc_table[256]= {
0x0,0x4c11db7,0x9823b6e,0xd4326d9,0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,0x18aeb13,0x54bf6a4,0x808d07d,0xcc9cdca,
0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
0x315d626,0x7d4cb91,0xa97ed48,0xe56f0ff,0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,0x29f3d35,0x65e2082,0xb1d065b,0xfdc1bec,
0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4,
};
unsigned int crc32(unsigned int original_value, uint8_t * input, int len)
{
int i;
unsigned long res = original_value;
for ( i= 0; i < len; i++)
{
res = crc_table[(res >> 24) ^ (input[i]&0xff)] ^ (res << 8);
}
return res;
}
volatile uint8_t check_led_flag=0;
volatile BACKLIGHT_LOGO_STATUS LINIT_LOGO_flag=STATUS_INIT;
volatile uint8_t logo_flag = IIC_LINT_LOGO_DIS;
volatile uint8_t middle_duty[2] = {0xf,0xff};
void I2c_Init(void)
{
GPIO_InitType GPIO_InitStruct;
I2C_InitType I2C_InitStruct;
RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
RCC_APB1_Peripheral_Clock_Enable(RCC_APB1_PERIPH_I2C2);
GPIO_Structure_Initialize(&GPIO_InitStruct);
GPIO_InitStruct.Pin=IIC_SDA_PIN|IIC_CLK_PIN;
GPIO_InitStruct.GPIO_Mode=GPIO_MODE_AF_OD;
GPIO_InitStruct.GPIO_Slew_Rate=GPIO_SLEW_RATE_FAST;
GPIO_InitStruct.GPIO_Alternate = GPIO_AF7_I2C2;
GPIO_InitStruct.GPIO_Pull=GPIO_PULL_UP;
GPIO_Peripheral_Initialize(IIC_PORT,&GPIO_InitStruct);
I2C_Reset(OTA_IIC);
I2C_Initializes_Structure(&I2C_InitStruct);
I2C_InitStruct.BusMode = I2C_BUSMODE_I2C;
I2C_InitStruct.DutyCycle = I2C_FMDUTYCYCLE_16_9;
I2C_InitStruct.OwnAddr1 = I2C_SLAVE_BOARD0;
I2C_InitStruct.AckEnable = I2C_ACKEN;
I2C_InitStruct.AddrMode = I2C_ADDR_MODE_7BIT;
I2C_InitStruct.ClkSpeed = I2C_SPEED;
I2C_Own_Addr2_Set(OTA_IIC, I2C_SLAVE_BOARD1);
I2C_Dual_Addr_Enable(OTA_IIC);
I2C_Initializes(OTA_IIC, &I2C_InitStruct);
I2C_Interrupts_Enable(OTA_IIC, I2C_INT_EVENT | I2C_INT_BUF | I2C_INT_ERR);
I2C_ON(OTA_IIC);
}
void OtaApi_I2cReset(void) {
RCC_APB1_Peripheral_Reset(RCC_APB1_PERIPH_I2C2);
RCC_APB1_Peripheral_Clock_Disable(RCC_APB1_PERIPH_I2C2);
RCC_APB1_Peripheral_Reset(RCC_APB1_PERIPH_I2C2);
I2c_Init();
NVIC_EnableIRQ(I2C2_EV_IRQn);
NVIC_EnableIRQ(I2C2_ER_IRQn);
}
uint8_t get_month(void)
{
uint8_t month_val;
switch(__DATE__[2])
{
case 'n':
if(__DATE__[1] == 'a')
month_val = 1;
else
month_val = 6;
break;
case 'b':
month_val = 2;
break;
case 'r':
if(__DATE__[1] == 'a')
month_val = 3;
else
month_val = 4;
break;
case 'y':
month_val = 5;
break;
case 'l':
month_val = 7;
break;
case 'g':
month_val = 8;
break;
case 'p':
month_val = 9;
break;
case 't':
month_val = 10;
break;
case 'v':
month_val = 11;
break;
case 'c':
month_val = 12;
break;
default:
month_val = 0;
break;
}
return month_val;
}
#define MDK_YEAR ((((__DATE__[7] - '0')*10 + __DATE__[8] - '0')*10 \
+(__DATE__[9] - '0'))*10+(__DATE__[10] - '0'))
#define MDK_MONTH get_month()
#define MDK_DAY ((__DATE__[4]==' ' ? 0 : __DATE__[4]-'0')*10 \
+(__DATE__[5] - '0'))
#define MDK_HOUR ((__TIME__[0]-'0')*10 + __TIME__[1]-'0')
#define MDK_MIN ((__TIME__[3]-'0')*10 + __TIME__[4]-'0')
#define MDK_SEC ((__TIME__[6]-'0')*10 + __TIME__[7]-'0')
void Show_Fw_Version(void) {
// uint8_t i=0;
// printf("firmware version:");
// for(i=0;i<sizeof(BconVersion);i++){
// printf("%c",BconVersion[i]);
// }
printf("\n");
#if (MODEL_TYPE== A5H_85_28_16_448_HY8108)
printf("HYASIC-HYASIC-85A5H-%02d*%02d-%02dmA-%02x\n",BconVersion[12],BconVersion[13],BconVersion[14],BconVersion[15]);
// printf("BCON-NUM-:N030102-001246-106\n");
#elif (MODEL_TYPE== A5HP_65_40_22_880_HY8108)
printf("HYASIC-HYASIC-65A5HP-%02d*%02d-%02dmA-%02x\n",BconVersion[12],BconVersion[13],BconVersion[14],BconVersion[15]);
// printf("BCON-NUM-:N030102-001246-105\n");
#elif (MODEL_TYPE==A5HP_75_44_24_1056_HY8108)
printf("HYASIC-HYASIC-75A5HP-%02d*%02d-%02dmA-%02x\n",BconVersion[12],BconVersion[13],BconVersion[14],BconVersion[15]);
// printf("BCON-NUM-:N030102-001246-104\n");
#elif (MODEL_TYPE==A5HP_85_48_28_1344_HY8108)
printf("HYASIC-HYASIC-85A5HP-%02d*%02d-%02dmA-%02x\n",BconVersion[12],BconVersion[13],BconVersion[14],BconVersion[15]);
// printf("BCON-NUM-:N030102-001246-103\n");
#endif
printf("MDK-TIME:%04d-%02d-%02d %02d:%02d:%02d\n",MDK_YEAR,MDK_MONTH,MDK_DAY,MDK_HOUR,MDK_MIN,MDK_SEC);
}
uint16_t ota_recv_flag=0;
uint16_t recv_cnt=0;
uint16_t send_cnt=0;
uint8_t iic_recv_buf[256]= {0};
uint8_t iic_send_buf[256]= {0};
void I2C2_ER_IRQHandler(void) {
uint32_t last_event;
last_event = I2C_Last_Event_Get(OTA_IIC);
if(last_event == I2C_EVT_SLAVE_ACK_MISS)
{
I2C_Flag_Status_Clear(OTA_IIC, I2C_FLAG_ACKFAIL);
}
else if( (last_event&0x0100) == 0x0100) { //bus busy
OTA_IIC->STS1 &=~(1<<8);
}
else if( (last_event&0x0200) == 0x0200) { //Arbitration lost
OTA_IIC->STS1 &=~(1<<9);
}
else if( (last_event&0x0800) == 0x0800) { //Overrun/Underrun
OTA_IIC->STS1 &=~(1<<11);
}
else if( (last_event&0x1000) == 0x1000) { //PEC Error
OTA_IIC->STS1 &=~(1<<12);
}
else if( (last_event&0x4000) == 0x4000) { //Timeout
OTA_IIC->STS1 &=~(1<<14);
}
else if( (last_event&0x8000) == 0x8000) { //SMBus
OTA_IIC->STS1 &=~(1<<15);
}
}
void I2C2_EV_IRQHandler(void) {
uint32_t ev_status = 0;
ev_status =I2C_Last_Event_Get(OTA_IIC);
if ((ev_status & I2C_ROLE_MASTER) != I2C_ROLE_MASTER) {
switch (ev_status) {
case I2C_EVT_SLAVE_RECV_ADDR_MATCHED:
// case I2C_EVT_SLAVE_RECV_ADDR2_MATCHED:
case 0x00820002://0x00820002
recv_cnt = 0;
break;
case I2C_EVT_SLAVE_SEND_ADDR_MATCHED:
case I2C_EVT_SLAVE_SEND_ADDR2_MATCHED:
send_cnt=0;
if((iic_recv_buf[0]==0x20)&&(iic_recv_buf[1]==0x01)&&(iic_recv_buf[2]==0x01)&&(iic_recv_buf[3]==0x20)) {
OTA_IIC->DAT = logo_flag;
} else if((iic_recv_buf[0]==0x20)&&(iic_recv_buf[1]==0x01)&&(iic_recv_buf[2]==0x02)&&(iic_recv_buf[3]==0x20)) {
OTA_IIC->DAT = middle_duty[send_cnt++];
} else {
memcpy(iic_send_buf,&BconVersion[6],10);
send_cnt %=16;
OTA_IIC->DAT = iic_send_buf[send_cnt++];
}
break;
case I2C_EVT_SLAVE_DATA_SENDING:
case I2C_EVT_SLAVE_DATA_SENDED:
if((iic_recv_buf[0]==0x20)&&(iic_recv_buf[1]==0x01)&&(iic_recv_buf[2]==0x01)&&(iic_recv_buf[3]==0x20)) {
OTA_IIC->DAT = logo_flag;
} else if((iic_recv_buf[0]==0x20)&&(iic_recv_buf[1]==0x01)&&(iic_recv_buf[2]==0x02)&&(iic_recv_buf[3]==0x20)) {
OTA_IIC->DAT = middle_duty[send_cnt++];
} else {
memcpy(iic_send_buf,&BconVersion[6],10);
send_cnt %=16;
OTA_IIC->DAT = iic_send_buf[send_cnt++];
}
break;
case I2C_EVT_SLAVE_DATA_RECVD:
case I2C_EVT_SLAVE_DATA_ADDR2_RECVD:
recv_cnt %=256;
iic_recv_buf[recv_cnt++] = OTA_IIC->DAT;
break;
case I2C_EVT_SLAVE_STOP_RECVD:
I2C_ON(OTA_IIC);
ota_recv_flag=1;
break;
case 0:
case 0x60004:
I2C_ON(OTA_IIC);
break;
default:
//printf("sts:0x%x!\n",ev_status);
OtaApi_I2cReset();
break;
}
}
}
typedef union {
uint8_t u8buf[128];
uint32_t u32buf[32];
} FW_buf_T;
__align(4) FW_buf_T fw_buf= {0};
static Cmd_pack cmd_pack= {0};
static Respon_pack respon_pack= {0};
static uint8_t ota_status=0;
void Set_Ota_Status(uint8_t value) {
ota_status=value;
}
uint8_t Get_Ota_Status(void) {
return ota_status;
}
uint8_t Crc_Respon(void) {
uint8_t i;
uint8_t crc=0;
for(i=0; i<respon_pack.pack_len-1; i++)
crc^=respon_pack.data[i];
return crc;
}
void Copy_Respon_To_Sendbuf(void) {
send_cnt=0;
memcpy(iic_send_buf,respon_pack.data,respon_pack.pack_len);
}
void Reset_Send_Buf(void) {
memset(iic_send_buf,0,sizeof(iic_send_buf));
}
Respond Analysis_Cmd(uint8_t *data,uint16_t len) {
uint16_t i;
uint8_t flag=0;
uint8_t crc=0;
uint8_t crc_res=0;
uint8_t *p=data;
if(len<1)
return OTA_EXCEPTION;
if(data[0]==0x30&&data[3]==0x00) {
check_led_flag=0;
}
else if((data[0]==0x30&&data[3]==0x01)||(data[0]==0x30&&data[3]==0x02)) {
check_led_flag=1;
}
if((data[0]==0x10)&&(data[1]==0x01)&&(data[2]==0x11)&&(data[3]==0x10)) {
LINIT_LOGO_flag=STATUS_DISABLE_LOGOBL;//<2F><>
logo_flag = IIC_LINT_LOGO_DIS;
middle_duty[0] = 0xf;
middle_duty[1] = 0xff;
}
if((data[0]==0x10)&&(data[1]==0x01)&&(data[2]==0x22)&&(data[3]==0x10)) {
LINIT_LOGO_flag=STATUS_ENABLE_LOGOBL;//<2F><>
logo_flag = IIC_LINT_LOGO_EN;
middle_duty[0] = 0x7;
middle_duty[1] = 0xff;
}
flag=*data;
crc=data[len-1];
// printf("iic recv pack len=[%d]\n",len);
switch(flag) {
case START_UPDATE:
FbApi_StopDetect();
VsyncApi_StopCap();
Set_Ota_Status(1);
if(crc!=flag) {
if(Get_Ota_Status())
Set_Ota_Status(0);
return OTA_CRC_ERROR;
}
break;
case READ_VERSION:
case TRANSFER_END:
if(crc!=flag) {
if(Get_Ota_Status())
Set_Ota_Status(0);
return OTA_CRC_ERROR;
}
break;
case PACK_CHECK:
case FW_PACK:
for(i=0; i<len-1; i++) {
crc_res^=*data;
data++;
}
if(crc!=crc_res) {
// printf("iic pack[%x] crc err\n",flag);
if(Get_Ota_Status())
Set_Ota_Status(0);
return OTA_CRC_ERROR;
}
break;
case ERASE_FLASH:
break;
case FACTORY_TEST_RUNNING_HORSE:
if(crc!=flag) {
if(Get_Ota_Status())
Set_Ota_Status(0);
return OTA_CRC_ERROR;
}
break;
default:
// printf("flag[%x] err\n",flag);
return OTA_FLAG_ERROR;
}
memcpy(&cmd_pack,p,len-1);
return OTA_SUCCESS;
}
uint8_t Deal_Cmd(Respond result) {
uint16_t i=0;
uint16_t pack_len=0;
uint8_t cnt=0;
static uint16_t fw_buf_size=0;
static uint32_t fw_offset=0;
static uint8_t step=0;
static uint32_t fw_len=0;
static uint32_t fw_crc=0;
static uint32_t fw_len_calc=0;
static uint32_t fw_crc_calc=0;
if(result) {
respon_pack.flag=cmd_pack.flag;
respon_pack.len_num.len=1;
respon_pack.data[0]=OTA_FAIL;
respon_pack.pack_len=3;
// respon_pack.crc=crc_respon();
return 0;
}
else {
respon_pack.flag=cmd_pack.flag;
respon_pack.len_num.len=1;
respon_pack.data[0]=OTA_SUCCESS;
respon_pack.pack_len=3;
//printf("flag2[%x] err\n",result);
}
switch(cmd_pack.flag) {
case START_UPDATE:
// printf("OTA START\n");
Set_Ota_Status(1);
step=START_UPDATE;
fw_len=0;
fw_crc=0;
fw_len_calc=0;
fw_crc_calc=0;
FLASH_Unlock();
FLASH_One_Page_Erase(OTA_PATCH_ADD);
memset(fw_buf.u8buf,0,sizeof(fw_buf.u8buf));
fw_buf_size=0;
fw_offset=0;
VsyncApi_StopCap();
FbApi_StopDetect(); //??FB
break;
// respon_pack.data[0]=READ_VERSION;
// respon_pack.data[1]=sizeof(BconVersion);
// memcpy(&respon_pack.data[2],BconVersion,sizeof(BconVersion));
// respon_pack.pack_len=3+sizeof(BconVersion);
// respon_pack.data[respon_pack.pack_len-1]=crc_respon();
case FW_PACK:
if(Get_Ota_Status()) {
pack_len=128;
memset(fw_buf.u8buf,0xff,sizeof(fw_buf.u8buf));
memcpy(fw_buf.u8buf,cmd_pack.data,pack_len);
I2C_Interrupts_Disable(OTA_IIC, I2C_INT_EVENT | I2C_INT_ERR);
for(i=0; i<32; i++) {
FLASH_Word_Program(OTA_PATCH_ADD+fw_offset+i*4,fw_buf.u32buf[i]);
}
I2C_Interrupts_Enable(OTA_IIC, I2C_INT_EVENT | I2C_INT_ERR);
fw_buf_size+=pack_len;
fw_len_calc+=pack_len;
fw_offset+=pack_len;
// printf("ota pack %d\n",fw_offset);
if(fw_buf_size==2048) {
FLASH_One_Page_Erase(OTA_PATCH_ADD+fw_offset);
fw_buf_size=0;
}
}
break;
case PACK_CHECK: //????????
//printf("OTA_COMPLETE K_01!\n");
if(step==START_UPDATE) {
step=PACK_CHECK;
//printf("OTA_COMPLETE K_02!\n");
fw_len=cmd_pack.data[0]<<24| cmd_pack.data[1]<<16| cmd_pack.data[2]<<8| cmd_pack.data[3];
fw_crc=cmd_pack.data[4]<<24| cmd_pack.data[5]<<16| cmd_pack.data[6]<<8| cmd_pack.data[7];
if(fw_len_calc!=fw_len) { //???????????
// printf("ota len err:%d[real len:%d]\n",fw_len_calc,fw_len);
respon_pack.data[4]=OTA_CRC_ERROR;
respon_pack.data[respon_pack.pack_len-1]=Crc_Respon();
}
else {
fw_crc_calc=crc32(0xffffffff,(uint8_t *)OTA_PATCH_ADD,fw_len_calc);
if(fw_crc_calc!=fw_crc) { //CRC err
// printf("ota crc err:0x%x[real crc:0x%x]\n",fw_crc_calc,fw_crc);
respon_pack.data[4]=OTA_CRC_ERROR;
respon_pack.data[respon_pack.pack_len-1]=Crc_Respon();
}
else
{
//printf("ota complete len=%d[%d] crc=%x[%x]\n",fw_len_calc,fw_len,fw_crc_calc,fw_crc);
do {
if(cnt==3) {
FLASH_One_Page_Erase(OTA_FLAG_ADD);
// printf("ota write flag or len err\n");
return 0;
}
cnt++;
FLASH_One_Page_Erase(OTA_FLAG_ADD);
FLASH_Word_Program(OTA_FLAG_ADD,OTA_FLAG); //ota???????
FLASH_Word_Program(OTA_FLAG_ADD+4,fw_len_calc); //ota pack len
}
while( ((*(uint32_t *)(OTA_FLAG_ADD))!=OTA_FLAG) || ((*(uint32_t *)(OTA_FLAG_ADD+4))!=fw_len_calc) );
fw_len_calc=0;
fw_buf_size=0;
memset(fw_buf.u8buf,0,sizeof(fw_buf.u8buf));
Set_Ota_Status(0);
// FMC_Close();
// FMC_DISABLE_AP_UPDATE();
// SYS_LockReg();
VsyncApi_StartCap();
FbApi_StartDetect();
// SYS_UnlockReg();
//printf("restart ic\n");
delay_ms(20);
NVIC_SystemReset();
// }
}
}
}
else { //??????
step=0;
//printf("OTA_COMPLETE K_03!\n");
respon_pack.data[2]=OTA_EXCEPTION;
respon_pack.pack_len=4;
respon_pack.data[respon_pack.pack_len-1]=Crc_Respon();
// TIMER_Start(TIMER2); //???g?|??3?go???g2??
//TIMER_Start(TIMER0); //???g?|??3?go???g2??
VsyncApi_StartCap();
}
break;
case TRANSFER_END:
// //NVIC_SystemReset();
// if(Get_Ota_Status()){
// printf("OTA end\n");
// FLASH_One_Page_Erase(OTA_FLAG_ADD);
// FLASH_Word_Program(OTA_FLAG_ADD,OTA_FLAG); //ota????
// FLASH_Word_Program(OTA_FLAG_ADD+4,fw_offset); //ota????
//
//
// fw_offset=0;
// fw_buf_size=0;
// memset(fw_buf.u8buf,0,sizeof(fw_buf.u8buf));
// //set_ota_status(0);
//
// printf("restart ic\n");
// delay_ms(50);
// NVIC_SystemReset();//?<3F><>??
//
//
// }
break;
// case READ_VERSION:
// printf("read version\n");
// respon_pack.len_num.len=10;
// memcpy(respon_pack.data,&BconVersion[6],10);
// respon_pack.pack_len=10;
// break;
case FACTORY_TEST_RUNNING_HORSE:
// #if HC_FUNCTION_ADD_BIST_KEY_3
// check_led_flag = 1;
// #endif
// FbApi_StartDetect();
// VsyncApi_StartCap();
// Set_Ota_Status(0);
break;
}
// Copy_Respon_To_Sendbuf();
return 0;
}
uint8_t Get_Ota_Flag(void)
{
return cmd_pack.flag;
}
void Ota_Process(void) {
Respond res;
do {
if(ota_recv_flag) {
//Reset_Send_Buf();
cmd_pack.flag=0;
res=Analysis_Cmd(iic_recv_buf,recv_cnt);
Deal_Cmd(res);
ota_recv_flag=0;
}
}
while(Get_Ota_Status());
}

485
A5H_9225_8108_SPIV3.0/APP/ota/OtaApi.c.orig
View File

@@ -1,485 +0,0 @@
#include "OtaApi.h"
#include "stdio.h"
#include "string.h"
#include "VsyncApi.h"
#include "xtal.h"
uint16_t ota_recv_flag=0;
extern uint8_t com_recv_buf[256];
extern uint8_t com_send_buf[64];
uint16_t recv_length=4;
uint16_t send_length=8;
uint16_t real_recv_cnt=0;
static uint8_t ota_status=0;
__align(4) FW_buf_T fw_buf= {0};
const uint8_t BconVersion[5]= {0xAA,0x33,0xad,0xbc,0xdf};
unsigned int crc_table[1]= {0};
void crc32_init(unsigned int poly)
{
int i;
int j;
unsigned int c;
for(i=0; i<256; i++)
{
c = i;
for (j=0; j<32; j++)
{
if(c&0x80000000)
{
c=poly^(c<<1);
}
else
{
c<<=1;
}
}
crc_table[i] = c;
}
}
unsigned int crc32(unsigned int original_value, uint8_t * input, int len)
{
int i;
unsigned long res = original_value;
for ( i= 0; i < len; i++)
{
res = crc_table[(res >> 24) ^ (input[i]&0xff)] ^ (res << 8);
}
return res;
}
void I2C_Dma_Init(void){
DMA_InitType DMA_InitSt;
RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_DMA);
DMA_Reset(SOC_OTA_RXDMA_CH);
DMA_InitSt.PeriphAddr = (uint32_t)&OTA_IIC->DAT;
DMA_InitSt.MemAddr = (uint32_t)com_recv_buf;
DMA_InitSt.Direction = DMA_DIR_PERIPH_SRC;
DMA_InitSt.BufSize = 4;
DMA_InitSt.PeriphInc = DMA_PERIPH_INC_MODE_DISABLE;
DMA_InitSt.MemoryInc = DMA_MEM_INC_MODE_ENABLE;
DMA_InitSt.PeriphDataSize = DMA_PERIPH_DATA_WIDTH_BYTE;
DMA_InitSt.MemDataSize = DMA_MEM_DATA_WIDTH_BYTE;
DMA_InitSt.CircularMode = DMA_CIRCULAR_MODE_DISABLE;
DMA_InitSt.Priority = DMA_CH_PRIORITY_HIGHEST;
DMA_InitSt.Mem2Mem = DMA_MEM2MEM_DISABLE;
DMA_Initializes(SOC_OTA_RXDMA_CH, &DMA_InitSt);
DMA->INTCLR=0;
SOC_OTA_RXDMA_CH->CHCFG |=2;
SOC_OTA_RXDMA_CH->CHSEL |=16;
SOC_OTA_RXDMA_CH->CHCFG |=1;
//OTA dma send
DMA_Reset(SOC_OTA_TXDMA_CH);
DMA_InitSt.PeriphAddr = (uint32_t)&OTA_IIC->DAT;
DMA_InitSt.MemAddr = (uint32_t)com_send_buf;
DMA_InitSt.BufSize = send_length;
DMA_InitSt.Direction = DMA_DIR_PERIPH_DST;
DMA_InitSt.PeriphInc = DMA_PERIPH_INC_MODE_DISABLE;
DMA_InitSt.MemoryInc = DMA_MEM_INC_MODE_ENABLE;
DMA_InitSt.PeriphDataSize = DMA_PERIPH_DATA_WIDTH_BYTE;
DMA_InitSt.MemDataSize = DMA_MEM_DATA_WIDTH_BYTE;
DMA_InitSt.CircularMode = DMA_CIRCULAR_MODE_DISABLE;
DMA_InitSt.Priority = DMA_CH_PRIORITY_HIGHEST;
DMA_InitSt.Mem2Mem = DMA_MEM2MEM_DISABLE;
DMA_Initializes(SOC_OTA_TXDMA_CH, &DMA_InitSt);
DMA->INTCLR=0;
// SOC_OTA_TXDMA_CH->CHCFG |=2;
SOC_OTA_TXDMA_CH->CHSEL |=15;
SOC_OTA_TXDMA_CH->CHCFG |=1;
}
void I2c_Init(void)
{
GPIO_InitType GPIO_InitSt;
I2C_InitType I2C_InitSt;
RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
RCC_APB1_Peripheral_Clock_Enable(RCC_APB1_PERIPH_I2C2);
GPIO_Structure_Initialize(&GPIO_InitSt);
GPIO_InitSt.Pin=IIC_SDA_PIN|IIC_CLK_PIN;
GPIO_InitSt.GPIO_Mode=GPIO_MODE_AF_OD;
GPIO_InitSt.GPIO_Pull=GPIO_PULL_UP;
GPIO_InitSt.GPIO_Slew_Rate=GPIO_SLEW_RATE_FAST;
GPIO_InitSt.GPIO_Alternate = GPIO_AF2_I2C1;
GPIO_Peripheral_Initialize(IIC_PORT,&GPIO_InitSt);
I2C_Reset(OTA_IIC);
I2C_Initializes_Structure(&I2C_InitSt);
I2C_InitSt.BusMode = I2C_BUSMODE_I2C;
I2C_InitSt.DutyCycle = I2C_FMDUTYCYCLE_16_9;
I2C_InitSt.OwnAddr1 = I2C_SLAVE_BOARD0;
I2C_InitSt.AckEnable = I2C_ACKEN;
I2C_InitSt.AddrMode = I2C_ADDR_MODE_7BIT;
I2C_InitSt.ClkSpeed = I2C_SPEED;
I2C_Initializes(OTA_IIC, &I2C_InitSt);
I2C_Interrupts_Enable(OTA_IIC, I2C_INT_EVENT | I2C_INT_ERR);
/* Enable Analog Filter */
I2C_SCL_Analog_Filter_Enable(OTA_IIC);
/* Set Filter width */
I2C_SCL_Analog_Filter_Width_Set(OTA_IIC,I2C_ANALOG_FILTER_WIDTH_15NS);
I2C_Dma_Init();
I2C_DMA_Transfer_Enable(OTA_IIC);
I2C_ON(OTA_IIC);
}
void OtaApi_Show_Fw_Version(void) {
uint8_t i=0;
printf("firmware version:");
for(i=0; i<sizeof(BconVersion); i++) {
printf("%#x",BconVersion[i]);
}
printf("\n");
}
void Ota_Dma_Recv(uint16_t len){
SOC_OTA_RXDMA_CH->CHCFG &=~1;
SOC_OTA_RXDMA_CH->MADDR=(uint32_t)com_recv_buf;
SOC_OTA_RXDMA_CH->TXNUM=len;
SOC_OTA_RXDMA_CH->CHCFG |=1;
}
void Ota_Dma_Tran(uint16_t len){
SOC_OTA_TXDMA_CH->CHCFG &=~1;
SOC_OTA_TXDMA_CH->MADDR=(uint32_t)com_send_buf;
SOC_OTA_TXDMA_CH->TXNUM=len;
SOC_OTA_TXDMA_CH->CHCFG |=1;
}
void I2C2_ER_IRQHandler(void) {
uint32_t last_event;
last_event = I2C_Last_Event_Get(OTA_IIC);
if(last_event == I2C_EVT_SLAVE_ACK_MISS)
{
I2C_Flag_Status_Clear(OTA_IIC, I2C_FLAG_ACKFAIL);
}
else{
OTA_IIC->STS1 = 0;
OTA_IIC->STS2 = 0;
}
}
void I2C2_EV_IRQHandler(void) {
uint32_t ev_status = 0;
ev_status =I2C_Last_Event_Get(OTA_IIC);
if ((ev_status & I2C_ROLE_MASTER) != I2C_ROLE_MASTER)
{
switch (ev_status)
{
case I2C_EVT_SLAVE_RECV_ADDR_MATCHED:
Ota_Dma_Recv(recv_length);
real_recv_cnt = 0;
break;
case I2C_EVT_SLAVE_SEND_ADDR_MATCHED:
Ota_Dma_Tran(send_length);
break;
case I2C_EVT_SLAVE_STOP_RECVD:
I2C_ON(OTA_IIC);
ota_recv_flag=1;
break;
default:
I2C_OFF(OTA_IIC);
I2C_ON(OTA_IIC);
break;
}
}
}
//ota recv
void DMA_Channel3_IRQHandler(void)
{
if(DMA->INTSTS &0x0200)
{
DMA->INTCLR |=0x0f00;
real_recv_cnt=recv_length;
}
}
////ota recv
//void DMA_Channel4_IRQHandler(void)
//{
// if(DMA->INTSTS &0x2000)
// {
// DMA->INTCLR |=0xf000;
// }
//}
//static Cmd_pack cmd_pack= {0};
//static Respon_pack respon_pack= {0};
void Set_Ota_Status(uint8_t value) {
ota_status=value;
}
uint8_t Get_Ota_Status(void) {
return ota_status;
}
uint8_t Crc_Respon(void) {
uint8_t i;
uint8_t crc=0;
for(i=0; i<send_length-1; i++)
crc^=com_send_buf[i];
return crc;
}
void Reset_Send_Buf(void) {
memset(com_send_buf,0,sizeof(com_send_buf));
}
Respond OtaApi_AnalysisCmd(uint8_t *data,uint16_t len) {
uint16_t i;
uint8_t flag=0;
uint8_t crc=0;
uint8_t crc_res=0;
flag=*data;
crc=data[len-1];
switch(flag) {
case OTA_START:
case OTA_PACK:
case OTA_FW_MESSAGE:
case OTA_COMPLETE:
case READ_VERSION:
case RESET_MCU:
for(i=0; i<len-1; i++) {
crc_res^=*data;
data++;
}
if(crc!=crc_res) {
// printf("iic pack[%x] crc err\n",flag);
return OTA_CRC_ERROR;
}
break;
default:
// printf("flag[%x] err\n",flag);
return OTA_FLAG_ERROR;
}
return OTA_SUCCESS;
}
uint8_t OtaApi_DealCmd(Respond result) {
uint16_t i=0;
uint8_t pack_len=0;
uint8_t cnt=0;
static uint16_t fw_buf_size=0;
static uint8_t step=0;
static uint32_t fw_len=0;
static uint32_t fw_crc=0;
static uint32_t fw_len_calc=0;
static uint32_t fw_crc_calc=0;
if(result) {
com_send_buf[0]=com_recv_buf[0];
com_send_buf[1]=0x01;
com_send_buf[2]=result;
send_length=4;
com_send_buf[send_length-1]=Crc_Respon();
return 0;
}
else {
com_send_buf[0]=com_recv_buf[0];
com_send_buf[1]=0x01;
com_send_buf[2]=OTA_SUCCESS;
send_length=4;
com_send_buf[send_length-1]=Crc_Respon();
}
switch(com_recv_buf[0]) {
case OTA_START: //<2F><><EFBFBD><EFBFBD>MCU<43><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Set_Ota_Status(1);
step=OTA_START;
fw_len=0;
fw_crc=0;
fw_len_calc=0;
fw_crc_calc=0;
fw_buf_size=0;
FLASH_Unlock();
FLASH_One_Page_Erase(OTA_FLAG_ADD);
FLASH_One_Page_Erase(OTA_PATCH_ADD);
memset(fw_buf.u8buf,0,sizeof(fw_buf.u8buf));
VsyncApi_StopCap();
// Fb_Stop_Detect(); //ֹͣFB
printf("enter ota\n");
break;
case OTA_FW_MESSAGE: //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ MCU<43>ϱ<EFBFBD><CFB1>̼<EFBFBD><CCBC><EFBFBD>Ϣ
fw_len=com_recv_buf[2]<<24| com_recv_buf[3]<<16| com_recv_buf[4]<<8| com_recv_buf[5];
fw_crc=com_recv_buf[6]<<24| com_recv_buf[7]<<16| com_recv_buf[8]<<8| com_recv_buf[9];
break;
case READ_VERSION: //<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ MCU<43>ϱ<EFBFBD><CFB1>̼<EFBFBD><CCBC><EFBFBD>Ϣ
// printf("read version:");
com_send_buf[0]=READ_VERSION;
com_send_buf[1]=sizeof(BconVersion);
memcpy(&com_send_buf[2],BconVersion,sizeof(BconVersion));
send_length=3+sizeof(BconVersion);
com_send_buf[send_length-1]=Crc_Respon();
break;
case OTA_PACK: //<2F>̼<EFBFBD><CCBC><EFBFBD>
if(step==OTA_START) {
// printf("ota pack %d\n",fw_len_calc);
pack_len=com_recv_buf[1];
memset(fw_buf.u8buf,0xff,sizeof(fw_buf.u8buf));
memcpy(fw_buf.u8buf,&com_recv_buf[2],pack_len);
I2C_Interrupts_Disable(I2C2, I2C_INT_EVENT | I2C_INT_ERR);
for(i=0; i<32; i++) {
FLASH_Word_Program(OTA_PATCH_ADD+fw_len_calc+i*4,fw_buf.u32buf[i]);
}
I2C_Interrupts_Enable(I2C2, I2C_INT_EVENT | I2C_INT_ERR);
fw_buf_size+=pack_len;
fw_len_calc+=pack_len;
if(fw_buf_size==2048) {
FLASH_One_Page_Erase(OTA_PATCH_ADD+fw_len_calc);
fw_buf_size=0;
}
}
else { //<2F><><EFBFBD><EFBFBD><EFBFBD>쳣
step=0;
com_send_buf[2]=OTA_EXCEPTION;
send_length=4;
com_send_buf[send_length-1]=Crc_Respon();
}
break;
case OTA_COMPLETE: //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(step==OTA_START) {
step=OTA_COMPLETE;
if(fw_len_calc!=fw_len) { //len err
printf("ota len err:%d[real len:%d]\n",fw_len_calc,fw_len);
com_send_buf[2]=OTA_CRC_ERROR; //4
com_send_buf[send_length-1]=Crc_Respon();
}
else {
fw_crc_calc=crc32(0xffffffff,(uint8_t *)OTA_PATCH_ADD,fw_len_calc);
if(fw_crc_calc!=fw_crc) { //CRC err
printf("ota crc err:%d[real crc:%d]\n",fw_crc_calc,fw_crc);
com_send_buf[2]=OTA_CRC_ERROR; //4
com_send_buf[send_length-1]=Crc_Respon();
}
else {
printf("ota complete len=%d[%d] crc=%x[%x]\n",fw_len_calc,fw_len,fw_crc_calc,fw_crc);
do {
if(cnt==3) {
FLASH_One_Page_Erase(OTA_FLAG_ADD);
printf("ota write flag or len err\n");
return 0;
}
cnt++;
FLASH_One_Page_Erase(OTA_FLAG_ADD);
FLASH_Word_Program(OTA_FLAG_ADD,OTA_FLAG); //ota<74><61><EFBFBD><EFBFBD><EFBFBD><EFBFBD>־
FLASH_Word_Program(OTA_FLAG_ADD+4,fw_len_calc); //ota pack len
}
while( ((*(uint32_t *)(OTA_FLAG_ADD))!=OTA_FLAG) || ((*(uint32_t *)(OTA_FLAG_ADD+4))!=fw_len_calc) );
fw_len_calc=0;
fw_buf_size=0;
memset(fw_buf.u8buf,0,sizeof(fw_buf.u8buf));
Set_Ota_Status(0);
Start_Cap_Vsync();
// Fb_Start_Detect();
printf("restart bcon\n");
delay_ms(50);
NVIC_SystemReset();//<2F><>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>
}
}
}
else { //<2F><><EFBFBD><EFBFBD><EFBFBD>쳣
step=0;
com_send_buf[2]=OTA_EXCEPTION;
send_length=4;
com_send_buf[send_length-1]=Crc_Respon();
}
break;
case RESET_MCU: //<2F><>λMCU
printf("reset mcu\n");
delay_ms(50);
NVIC_SystemReset();//<2F><>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>
break;
}
return 0;
}
void OtaApi_Process(void)
{
Respond res;
uint16_t len=0;
do {
if(ota_recv_flag&&real_recv_cnt)
{
len=real_recv_cnt;
real_recv_cnt=0;
Reset_Send_Buf();
res=OtaApi_AnalysisCmd(com_recv_buf,len);
OtaApi_DealCmd(res);
ota_recv_flag=0;
}
}
while(Get_Ota_Status());
}

120
A5H_9225_8108_SPIV3.0/APP/ota/OtaApi.h
View File

@@ -1,120 +0,0 @@
#ifndef __OTAAPI_H__
#define __OTAAPI_H__
#include "hy9225.h"
#define I2C_SLAVE_BOARD0 0x4C
#define I2C_SLAVE_BOARD1 0X46
#define I2C_SPEED 100000
#define IIC_LINT_LOGO_EN 0x22
#define IIC_LINT_LOGO_DIS 0x11
#define OTA_FLAG 0x55555555
#define OTA_FLAG_ADD 0x1800 //6K
//<2F><><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>flash<73>еĵ<D0B5>ַ
#define FIRMWARE_ADD 0x2000 //8k
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>flash<73>еĵ<D0B5>ַ
//#define OTA_PATCH_ADD 0xE800 //58k
#define OTA_PATCH_ADD 0x9000 //36k
#define IIC_PORT GPIOB
#define IIC_SDA_PIN GPIO_PIN_11
#define IIC_CLK_PIN GPIO_PIN_10
#define I2CT_LONG_TIMEOUT 100
#define OTA_IIC I2C2
typedef struct {
uint8_t flag;
uint8_t len;
uint8_t data[512];
} Cmd_pack;
#if 1
typedef struct {
uint8_t flag;
union {
uint8_t len;
uint8_t pack_num;
}len_num;
uint8_t data[128];
uint8_t crc;
uint8_t pack_len; //from flag to valid data except crc
}Respon_pack;
typedef enum{
OTA_SUCCESS=0,
OTA_FLAG_ERROR,
OTA_CRC_ERROR,
OTA_FAIL,
OTA_EXCEPTION,
}Respond;
enum{
READ_VERSION=1,
FW_PACK=2,
PACK_CHECK=3,
TRANSFER_END=4,
ERASE_FLASH=6,
FACTORY_TEST_RUNNING_HORSE=0x30,
START_UPDATE=0X90
};
#else
typedef struct {
uint8_t data[128];
uint8_t pack_len; //from flag to valid data except crc
}Respon_pack;
typedef enum{
OTA_SUCCESS=0,
OTA_FLAG_ERROR,
OTA_CRC_ERROR,
OTA_FAIL,
OTA_EXCEPTION,
}Respond;
enum{
OTA_START=1,
OTA_PACK,
OTA_FW_MESSAGE,
OTA_COMPLETE,
READ_VERSION,
RESET_MCU,
};
#endif
typedef enum {
STATUS_INIT = 0,
STATUS_DISABLE_LOGOBL = 1,
STATUS_ENABLE_LOGOBL = 2,
STATUS_FINISH = 3,
}BACKLIGHT_LOGO_STATUS;
extern volatile uint8_t check_led_flag;
extern volatile BACKLIGHT_LOGO_STATUS LINIT_LOGO_flag;
extern const uint8_t BconVersion[16];
void I2c_Init(void);
void Show_Fw_Version(void);
void Reset_Send_Buf(void);
Respond Analysis_Cmd(uint8_t *data,uint16_t len);
uint8_t Deal_Cmd(Respond result);
void Set_Ota_Status(uint8_t value);
uint8_t Get_Ota_Status(void);
uint8_t Get_Ota_Flag(void);
void Ota_Process(void);
#endif