/**
*!
* \file b_srv_ota.c
* \version v0.0.1
* \date 2023/08/27
* \author Bean(notrynohigh@outlook.com)
*******************************************************************************
* @attention
*
* Copyright (c) 2023 Bean
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*******************************************************************************
*/
/*Includes ----------------------------------------------*/
#include "services/inc/b_srv_ota.h"
#if (defined(_OTA_SERVICE_ENABLE) && (_OTA_SERVICE_ENABLE == 1))
#include "algorithm/inc/algo_crc.h"
#include "core/inc/b_sem.h"
#include "core/inc/b_task.h"
#include "hal/inc/b_hal.h"
/**
* \addtogroup BABYOS
* \{
*/
/**
* \addtogroup SERVICES
* \{
*/
/**
* \addtogroup OTA
* \{
*/
/**
* \defgroup OTA_Private_TypesDefinitions
* \{
*/
/**
* \}
*/
/**
* \defgroup OTA_Private_Defines
* \{
*/
#ifndef OTA_TIMEOUT_S
#define OTA_TIMEOUT_S (30)
#endif
/**
* \}
*/
/**
* \defgroup OTA_Private_Macros
* \{
*/
/**
* \}
*/
/**
* \defgroup OTA_Private_Variables
* \{
*/
static bProtSrvId_t bProtocolId = NULL;
static bOtaSrvSendData_t bProtocolSend = NULL;
static uint32_t bOtaFileOffset = 0;
B_TASK_CREATE_ATTR(bOtaTaskAttr);
B_SEM_CREATE_ATTR(bOtaSemAttr);
static bTaskId_t bOtaTaskId = NULL;
static bSemId_t bOtaSemId = NULL;
static bProtSrvSubscribe_t bSubInfo = {
.number = 0,
};
const static bProtoCmd_t bCmdTable[] = {B_PROTO_OTA_FILE_INFO, B_PROTO_FILE_DATA};
/**
* \}
*/
/**
* \defgroup OTA_Private_FunctionPrototypes
* \{
*/
/**
* \}
*/
/**
* \defgroup OTA_Private_Functions
* \{
*/
static int _bOtaSendResult(uint8_t result)
{
uint8_t buf[128];
uint16_t olen = 0;
buf[0] = result;
olen = bProtSrvPackage(bProtocolId, B_PROTO_TRANS_FILE_RESULT, buf, sizeof(buf));
if (olen > 0 && bProtocolSend != NULL)
{
bProtocolSend(buf, olen);
}
return 0;
}
PT_THREAD(bOtaTaskFunc)(struct pt *pt, void *arg)
{
uint8_t buf[128];
uint16_t len = 0;
bProtoReqFileData_t *p_req = (bProtoReqFileData_t *)buf;
static uint32_t timeout = 0;
B_TASK_INIT_BEGIN();
timeout = bHalGetSysTick();
B_TASK_INIT_END();
PT_BEGIN(pt);
while (1)
{
bTaskDelayMs(pt, 200);
p_req->offset = bOtaFileOffset;
p_req->size = 512;
len = bProtSrvPackage(bProtocolId, B_PROTO_REQ_FILE_DATA, buf, sizeof(buf));
bProtocolSend(buf, len);
bSemAcquireBlock(pt, bOtaSemId, 3000);
if (bOtaTaskId != NULL && (bIapGetStatus() != B_IAP_STA_START))
{
bTaskRemove(bOtaTaskId);
bOtaTaskId = NULL;
}
if (PT_WAIT_IS_TIMEOUT(pt))
{
if (TICK_DIFF_BIT32(timeout, bHalGetSysTick()) >= (MS2TICKS(OTA_TIMEOUT_S * 1000)))
{
_bOtaSendResult(4);
bTaskDelayMs(pt, 1000);
if (bIapIsInBoot())
{
bIapJump2App();
// 没有成功跳入应用程序,继续等待数据
timeout = bHalGetSysTick();
bHalIntEnable();
}
else
{
// 应用程序中，则停止请求数据
if (bOtaTaskId != NULL)
{
bTaskRemove(bOtaTaskId);
bOtaTaskId = NULL;
}
}
}
}
else
{
timeout = bHalGetSysTick();
}
}
PT_END(pt);
}
static void _OtaProtStart()
{
if (bOtaTaskId != NULL)
{
bTaskRemove(bOtaTaskId);
bOtaTaskId = NULL;
}
bOtaTaskId = bTaskCreate("ota", bOtaTaskFunc, NULL, &bOtaTaskAttr);
if (bOtaSemId == NULL)
{
bOtaSemId = bSemCreate(1, 0, &bOtaSemAttr);
}
bSemAcquireNonblock(bOtaSemId);
bOtaFileOffset = 0;
}
static int _OtaProtCallback(bProtoCmd_t cmd, void *param)
{
if (cmd == B_PROTO_OTA_FILE_INFO)
{
bProtoFileInfo_t *file_info = (bProtoFileInfo_t *)param;
bIapFwInfo_t fwinfo;
fwinfo.crc = file_info->fcrc32;
fwinfo.crc_type = ALGO_CRC32;
fwinfo.len = file_info->size;
memcpy(fwinfo.name, file_info->name, sizeof(fwinfo.name));
if (0 == bIapEventHandler(B_IAP_EVENT_START, &fwinfo))
{
_OtaProtStart();
}
}
else if ((cmd == B_PROTO_FILE_DATA) && (bIapGetStatus() == B_IAP_STA_START))
{
bProtoFileData_t *pFileData = (bProtoFileData_t *)param;
if (pFileData->size > 0 && pFileData->offset == bOtaFileOffset)
{
bIapFwData_t fwdata;
fwdata.pbuf = pFileData->dat;
fwdata.len = pFileData->size;
fwdata.release = NULL;
int ret = bIapEventHandler(B_IAP_EVENT_DATA, &fwdata);
if (ret >= 0)
{
bOtaFileOffset = ret;
}
}
if ((bIapGetStatus() == B_IAP_STA_READY) && (bIapIsInBoot() == 0))
{
bIapJump2Boot();
}
else if ((bIapGetStatus() == B_IAP_STA_FINISHED) && (bIapIsInBoot()))
{
bIapJump2App();
}
else if (bIapGetStatus() == B_IAP_STA_START)
{
bSemRelease(bOtaSemId);
}
}
return 0;
}
/**
* \}
*/
/**
* \addtogroup OTA_Exported_Functions
* \{
*/
int bOtaSrvInit(bProtSrvId_t protocol_id, bOtaSrvSendData_t send, uint32_t cache_dev_no,
uint32_t backup_dev_no, uint32_t backup_time_s)
{
int ret = 0;
if (protocol_id == NULL || send == NULL)
{
return -1;
}
bProtocolId = protocol_id;
bProtocolSend = send;
ret = bIapInit(cache_dev_no, backup_dev_no, backup_time_s);
bOtaFileOffset = 0;
bSubInfo.number = sizeof(bCmdTable) / sizeof(bProtoCmd_t);
bSubInfo.pcmd_table = &bCmdTable[0];
bSubInfo.callback = _OtaProtCallback;
bProtSrvSubscribe(protocol_id, &bSubInfo);
if ((bIapIsInBoot()) && (bIapGetStatus() == B_IAP_STA_START))
{
_OtaProtStart();
}
if ((bIapIsInBoot() == 0) && (ret == 1))
{
_bOtaSendResult(0);
}
return 0;
}
/**
* \}
*/
/**
* \}
*/
/**
* \}
*/
/**
* \}
*/
#endif
/************************ Copyright (c) 2023 Bean *****END OF FILE****/