static cedarx_result_e vbv_add_stream_frame(vstream_data_t* stream, Handle h)
{
vbv_t* vbv = (vbv_t*)h;
stream_frame_t* frame;
u32 write_index;
u8* new_write_addr;
if (!stream || !vbv)
return CEDARX_RESULT_NO_INIT;
if (vbv->frame_fifo.frame_num >= vbv->frame_fifo.max_frame_num) {
printf("Warning: The fifo is full!\n");
return CEDARX_RESULT_VBV_BUFFER_FULL;
}
if (vbv->valid_size >= vbv->max_size) {
printf("Warning: The buffer is full!\n");
return CEDARX_RESULT_VBV_BUFFER_FULL;
}
if (stream->length + vbv->valid_size > vbv->max_size) {
printf("Warning: There are not enough memory!\n");
return CEDARX_RESULT_VBV_BUFFER_NO_ENOUGH;
}
pthread_mutex_lock(&vbv->mutex);
new_write_addr = vbv->write_addr + stream->length;
if (new_write_addr >= vbv->vbv_buf_end) {
u32 size = vbv->vbv_buf_end - vbv->write_addr;
mem_cpy(vbv->write_addr, stream->data, size);
mem_cpy(vbv->vbv_buf, stream->data + size, stream->length - size);
new_write_addr -= vbv->max_size;
} else {
mem_cpy(vbv->write_addr, stream->data, stream->length);
}
write_index = vbv->frame_fifo.write_index;
frame = &vbv->frame_fifo.in_frames[write_index];
frame->vstream.data = stream->data;
frame->vstream.length = stream->length;
frame->vstream.pts = stream->pts;
frame->vstream.pcr = stream->pcr;
frame->vstream.valid = stream->valid;
frame->vstream.stream_type = stream->stream_type;
frame->vstream.pict_prop = stream->pict_prop;
frame->vstream.data = vbv->write_addr;
write_index ++;
if (write_index >= vbv->frame_fifo.max_frame_num) {
write_index = 0;
}
vbv->frame_fifo.write_index = write_index;
vbv->frame_fifo.frame_num++;
vbv->valid_size += stream->length;
vbv->write_addr = new_write_addr;
vbv_enqueue_tail(frame, &vbv->frame_queue); //* add this frame to the queue tail.
pthread_mutex_unlock(&vbv->mutex);
return CEDARX_RESULT_OK;
}
void Store_Op_ID(INT8U Op_ID[],INT8U *pDst, INT8U *pDst_Start, INT8U DstLen)
{
DIS_PD_INT;
mem_cpy(pDst, (void *)Operator_ID.Op_ID, sizeof(Operator_ID.Op_ID), pDst_Start, DstLen);
mem_cpy((void *)Operator_ID.Op_ID, Op_ID, sizeof(Op_ID), (void *)Operator_ID.Op_ID, sizeof(Operator_ID.Op_ID));
SET_STRUCT_SUM(Event_Data._Operator_ID);
SET_STRUCT_SUM(Event_Data);
EN_PD_INT;
}
void OSUptimeInfo(char *string)
{
OSTime Uptime;
OSDate UpDate;
CHAR8 str[6];
UserEnterCritical();
Uptime = OSUptime();
UpDate = OSUpDate();
UserExitCritical();
string += mem_cpy(string, "\n\rBRTOS UPTIME: ");
// Só funciona até 255 dias
if(UpDate.RTC_Day > 0)
{
string += mem_cpy(string,PrintDecimal(UpDate.RTC_Day, str));
string += mem_cpy(string, "d ");
}
string += mem_cpy(string,PrintDecimal(Uptime.RTC_Hour, str));
string += mem_cpy(string, "h ");
string += mem_cpy(string,PrintDecimal(Uptime.RTC_Minute, str));
string += mem_cpy(string, "m ");
string += mem_cpy(string,PrintDecimal(Uptime.RTC_Second, str));
string += mem_cpy(string, "s\n\r");
// End of string
*string = '\0';
}
//================================================
static void write_mem(void)
{
u32 addr = 0;
u16 i = 0;
u8 temp[4];
u16 length = 0;
u32 data = 0;
u8 crc = 0;
FLASH_Status status = FLASH_COMPLETE;
// Receive start address
for(i=0;i<4;i++)
temp[i] = USART_GetC();
crc = USART_GetC();
if(crc == (temp[0]^temp[1]^temp[2]^temp[3]))
{
mem_cpy(&addr,temp,4);
USART_PutC(ACK);
length = USART_GetC();
length = (length<<8) | USART_GetC();
for(i = 0;i<length;i++)
fwBuff[i] = USART_GetC();
crc = USART_GetC();
// Write memmory
FLASH_UnlockBank1();
if(!fUpdating)
{
// Disable systick
SysTick->CTRL &=~( SysTick_CTRL_CLKSOURCE_Msk |
SysTick_CTRL_TICKINT_Msk |
SysTick_CTRL_ENABLE_Msk);
status = FLASH_ErasePage(FLAG_ADDR);
if(status == FLASH_COMPLETE)
status = FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATING);
fUpdating = true;
}
if(status == FLASH_COMPLETE)
status = FLASH_ErasePage(addr);
for(i = 0;i<length;i+=4)
{
mem_cpy(&data,&fwBuff[i],((length-i)>4?4:(length-i)));
if(status != FLASH_COMPLETE)
break;
status = FLASH_ProgramWord(addr,data);
addr += 4;
}
FLASH_LockBank1();
if(status == FLASH_COMPLETE)
USART_PutC(ACK);
else
USART_PutC(NACK);
}
else
USART_PutC(NACK);
}
void interactive_kernel_loop() {
char *buff = (char*) 0x10000;
uint32_t len = 0x20000 - 0x10000;
char *decodebuff = (char*) 0x20000;
uint32_t decodebufflen = 0x30000 - 0x20000;
int status = 0;
while (1) {
status = uart_getln(buff, len);
if (status == 0) {
uart_puts(uart_newline);
if (str_startswith(buff, "b64 ")) {
uint32_t bytes_decoded = b64_decode(buff+4, decodebuff, decodebufflen);
uart_puts("base64 decoded #bytes: ");
char tmp[32];
uint32_t tmplen = ARR_LEN(tmp);
uart_puts(str_int_to_str(bytes_decoded, tmp, tmplen));
uart_puts(uart_newline);
// Copy the code of bootstrap_decoded_binary somewhere safe.
uint32_t func_len = 64; // wild guess
mem_cpy((uint32_t)bootstrap_decoded_binary, 0x30000, func_len);
// Call bootstrap_decoded_binary from that safe location
BRANCHTO(0x30000);
} else if (str_startswith(buff, "m ")) {
inspect_memory(buff+2);
} else if (str_startswith(buff, "r ")) {
inspect_reg(buff+2);
} else if (str_startswith(buff, "icky")) {
uart_puts(yoo);
} else if (str_startswith(buff, "usr0")) {
if (pr0) {
switch_to_user_process(pr0);
}
} else if (str_startswith(buff, "freloc")) {
char tmp[32];
uint32_t tmplen = ARR_LEN(tmp);
uint32_t func_len = ((uint32_t) str_parse_int) - ((uint32_t) str_len);
mem_cpy((uint32_t)str_len, 0x30000, func_len);
uart_puts(str_int_to_str(CALL_1(0x30000, "xyz"), tmp, tmplen));
} else if (str_startswith(buff, "version")) {
uart_puts(version);
uart_puts("\r\n");
} else {
int strlen = str_len(buff) - 1;
int j = 0;
for (; strlen != -1; --strlen, ++j) {
decodebuff[j] = buff[strlen];
}
decodebuff[j] = 0;
uart_puts(decodebuff);
}
}
uart_puts(uart_newline);
}
}
/* ========================================================== */
static void wavefront_tran (asy::object_inst* dest, void* param,
const vec3d_t* rote, const vec3d_t* move,
const vec3d_t* scale)
{
sWAVEFRONT* mesh;
const sD3D9_CALL* call;
call = (const sD3D9_CALL*)param;
if (rote == NULL)
call->util_make_tran2(&dest->tran, scale, NULL, 0.0f, move);
else
call->util_make_tran1(&dest->tran, scale, rote->x, rote->y, rote->z, move);
if (dest->type == INST_TYPE_STATIC) {
if (rote == NULL && scale == NULL) {
mem_cpy(&dest->bound.aabb, &dest->base->aabb, sizeof(sAABB));
if (move != NULL) {
for (int idx = 0; idx < 8; idx++) {
dest->bound.aabb.v[idx].x += move->x;
dest->bound.aabb.v[idx].y += move->y;
dest->bound.aabb.v[idx].z += move->z;
}
}
}
else
{
vec3d_t min, max, tmp;
// rebuild AABB box
mesh = (sWAVEFRONT*)dest->base->real;
call->util_tran_vec3d(&tmp, mesh->p_v, &dest->tran);
mem_cpy(&min, &tmp, sizeof(vec3d_t));
mem_cpy(&max, &tmp, sizeof(vec3d_t));
for (leng_t idx = 1; idx < mesh->n_v; idx++) {
call->util_tran_vec3d(&tmp, &mesh->p_v[idx], &dest->tran);
if (tmp.x < min.x) min.x = tmp.x;
if (tmp.y < min.y) min.y = tmp.y;
if (tmp.z < min.z) min.z = tmp.z;
if (tmp.x > max.x) max.x = tmp.x;
if (tmp.y > max.y) max.y = tmp.y;
if (tmp.z > max.z) max.z = tmp.z;
}
bound_gen_aabb(&dest->bound.aabb, &min, &max);
}
}
else { // dynamic object don't support scaling
mem_cpy(&dest->bound.ball, &dest->base->ball, sizeof(sSPHERE));
if (move != NULL) {
dest->bound.ball.center.x += move->x;
dest->bound.ball.center.y += move->y;
dest->bound.ball.center.z += move->z;
}
}
}
/* ================================= */
bool doit (void* ctx, commit_pipe* obj)
{
IMesh* mesh;
size_t size;
IAttrib* attr;
commit_unit* list;
crh3d9_cmmt_ctx* parm;
if (obj->effect != NULL)
obj->effect->enter();
size = obj->stuffz.size();
list = obj->stuffz.data();
parm = (crh3d9_cmmt_ctx*)ctx;
for (size_t idx = 0; idx < size; idx++) {
if (parm->inst != list->inst) {
parm->inst = list->inst;
if (list->inst->flag == INST_FLAG_BILLBOARDV) {
mem_cpy(parm->main->get_mat<fp32_t>(), &parm->bllv, sizeof(mat4x4_t));
parm->main->mul_mat(&list->inst->tran);
parm->devs->SetTransform(D3DTS_WORLD, parm->main->get_mat<D3DMATRIX>());
}
else
if (list->inst->flag == INST_FLAG_BILLBOARDH) {
mem_cpy(parm->main->get_mat<fp32_t>(), &parm->bllh, sizeof(mat4x4_t));
parm->main->mul_mat(&list->inst->tran);
parm->devs->SetTransform(D3DTS_WORLD, parm->main->get_mat<D3DMATRIX>());
}
else {
parm->devs->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&list->inst->tran));
}
}
attr = list->unit->attr;
if (attr != NULL) {
attr->commit();
parm->nv += attr->get_vnum();
parm->nt += attr->get_tnum();
}
if (list->unit->mesh != NULL) {
for (size_t ii = 0; ; ii++) {
mesh = list->unit->mesh[ii];
if (mesh == NULL)
break;
mesh->commit();
parm->nv += mesh->get_vnum();
parm->nt += mesh->get_tnum();
}
}
list += 1;
}
return (true);
}
/*
=======================================
显示后台缓冲
=======================================
*/
CR_API void_t
screen_copy (
__CR_IN__ uint_t line
)
{
/* 更新整个屏幕 */
if (line >= SCREEN_LINE) {
mem_cpy(s_front, s_backs, SCREEN_SIZE);
return;
}
/* 只更新一行 */
line *= (SCREEN_BPL * 16);
mem_cpy(&s_front[line], &s_backs[line], SCREEN_BPL * 16);
}
/*******************************************************************************
* Function Name : ptp_rcv_proc
* Description :
* Input :
* Output :
* Return :
*******************************************************************************/
void ptp_rcv_proc(DLL_RCV_HANDLE pd)
{
if(pd->dll_rcv_valid)
{
PTP_STACK_RCV_HANDLE pptp;
PHY_RCV_HANDLE pp;
pptp = &_ptp_rcv_obj[pd->phase];
pp = GET_PHY_HANDLE(pd);
pptp->phase = pd->phase;
pptp->comm_mode = (pp->phy_rcv_supposed_ch) | (pp->phy_rcv_valid & 0x0B);
mem_cpy(pptp->src_uid,&pd->lpdu[SEC_LPDU_SRC],6);
pptp->apdu = &pd->lpdu[SEC_LPDU_PTP_APDU];
pptp->apdu_len = pd->lpdu_len-(LEN_LPCI+LEN_PTP_NPCI+LEN_MPCI);
pptp->ptp_rcv_indication = 1;
#if NODE_TYPE == NODE_SLAVE
set_ptp_comm_mode(pptp->comm_mode);
#else
if(!(pptp->apdu[1] & 0x10)) //FOR DEBUG!!!
{
set_ptp_comm_mode(pptp->comm_mode);
}
#endif
}
}
/**
* Tworzy kopię segmentu.
* @param dst deskryptor segmentu docelowego.
* @param space przestrzeń adresowa segmentu docelowego.
* @param src segment źródłowy.
*/
int
vm_seg_clone(vm_seg_t *dst, vm_space_t *space, vm_seg_t *src)
{
vm_seg_create(dst, space, src->base, src->size, src->limit,
src->prot, src->flags);
vm_region_t *reg = NULL;
vm_region_t *clonereg;
// TRACE_IN("dst=%p space=%p src=%p", dst, space, src);
while ( (reg = list_next(&src->regions, reg)) ) {
clonereg = vm_lpool_alloc(&vm_unused_regions);
clonereg->begin = reg->begin;
clonereg->size = reg->size;
clonereg->end = reg->end;
clonereg->segment = dst;
list_insert_tail(&dst->regions, clonereg);
// TRACE_IN("%p-%p", clonereg->begin, clonereg->end);
vm_pmap_fill(&space->pmap, clonereg->begin, clonereg->size,
dst->prot);
vm_addr_t SRC,DST;
vm_segmap(dst, clonereg->begin, clonereg->size, &DST);
vm_segmap(src, reg->begin, reg->size, &SRC);
mem_cpy((void*)DST, (void*)SRC, reg->size);
vm_unmap(DST, reg->size);
vm_unmap(SRC, reg->size);
}
#if 0
TRACE_IN("present %u %u",
vm_pmap_is_avail(&dst->space->pmap, 0xbfffff00),
vm_pmap_is_avail(&src->space->pmap, 0xbfffff00)
);
#endif
return 0;
}
/* ================== */
bool see (T* data) const
{
if (m_head == m_tail)
return (false);
mem_cpy(data, &m_list[m_head], sizeof(T));
return (true);
}
/* =============================================================== */
atree_unit<T>* insert (atree_unit<T>* node, const T* obj, size_t idx)
{
cnode_ptr next;
atree_unit<T>* nnew;
list2<cnode_ptr>* list;
list2_unit<cnode_ptr>* unit;
nnew = struct_new(atree_unit<T>);
if (nnew == NULL)
return (NULL);
next.ptr = (void*)nnew;
list = &node->next;
if (idx >= list->size()) {
unit = list->append(&next);
}
else
if (idx == 0) {
unit = list->sthead(&next);
}
else {
unit = list->get(idx);
unit = list->insert(unit, &next);
}
if (unit == NULL) {
mem_free(nnew);
return (NULL);
}
m_cnts += 1;
nnew->node = unit;
nnew->uppe = node;
nnew->deep = node->deep + 1;
mem_cpy(&nnew->user, obj, sizeof(T));
nnew->next.init();
return (nnew);
}
extern Tuple *tuple_cpy(Tuple *t)
{
Tuple *res = mem_alloc(t->size);
mem_cpy(res, t, t->size);
init(res);
return res;
}
void Restore_Op_ID(INT8U *pSrc)
{
DIS_PD_INT;
mem_cpy((void *)Operator_ID.Op_ID, pSrc, sizeof(Operator_ID.Op_ID), (void *)Operator_ID.Op_ID, sizeof(Operator_ID.Op_ID));
SET_STRUCT_SUM(Event_Data._Operator_ID);
SET_STRUCT_SUM(Event_Data);
EN_PD_INT;
}
/*
typedef struct
{
INT32U Chang_Plus_AcEnerg[4]; //A/B/C/SUM各元件正向有功增量:单位:0.01wh
INT32U Chang_Nega_AcEnerg[4]; //A/B/C/SUM各元件反向有功增量:单位:0.01wh
//INT32U Chang_Plus_ReacEnerg[4]; //A/B/C/SUM各元件正向无功增量(无功组合1):单位:0.01warh
//INT32U Chang_Nega_ReacEnerg[4]; //A/B/C/SUM各元件反向无功增量(无功组合2):单位:0.01warh
INT32U Chang_Quad_ReacEnerg[4][4]; //A/B/C/SUM各元件四象限无功增量,Chang_Quad_ReacEnerg[1][2]表示B向3象限无功
INT32U Add_AmpaHour[3]; //AH累计:0.0001As,累计量
INT32U Add_CopperLoss[4]; //A,B,C,sum铜损,单位为0.0000001kA2s,累计量
INT32U Add_IronLoss[4]; //A,B,C,sum铁损,单位为0.0000001KV2s，累计量
INT32U Add_GenaralErr[4]; //A,B,C,sum合成误差,单位:0.01*tgFA*s,累计量
INT8U CS[CS_BYTES];
}MEASU_ENERG;
*/
INT16U Get_Measu_AcculateData_PUCK(INT8U ID,void *DstReal,void *Dst_Start,INT16U DstLen,INT16U DstMaxLen)
{
mem_cpy(DstReal,(void *)(&Measu_Energ_ToPub_PUCK),sizeof(MEASU_ENERG),DstReal,DstMaxLen);
return sizeof(MEASU_ENERG);
}
/* ============ */
bool get (T* data)
{
if (m_head == m_tail)
return (false);
mem_cpy(data, &m_list[m_head++], sizeof(T));
if (m_head >= m_size)
m_head = 0;
return (true);
}
/* ========================================================================================= */
void crhack3d9_commit_fixed (asy::crh3d9_main* main, const asy::tree_l<asy::commit_pipe>* pipe)
{
asy::crh3d9_cmmt_ctx parm;
parm.inst = NULL;
parm.main = main;
main->set_mat();
main->set_billboardv();
mem_cpy(&parm.bllv, main->get_mat<fp32_t>(), sizeof(mat4x4_t));
main->set_mat();
main->set_billboardh();
mem_cpy(&parm.bllh, main->get_mat<fp32_t>(), sizeof(mat4x4_t));
parm.nv = parm.nt = 0;
parm.devs = main->get_main()->dev;
pipe->trav_dfs<asy::crh3d9_cmmt_fixed>(&parm);
main->m_vnum = parm.nv;
main->m_tnum = parm.nt;
}
s32 vbv_add_stream(vstream_data_t* stream, Handle vbv)
{
u32 write_index;
u8* new_write_addr;
vbv_t* v;
v = (vbv_t*)vbv;
printf("vbv add stream\n");
if (stream == NULL || v == NULL)
{
return -1;
}
if(lock(v) != 0)
return -1;
if (v->frame_fifo.frame_num >= v->frame_fifo.max_frame_num)
{
unlock(v);
return -1;
}
if (stream->length + v->valid_size > v->max_size)
{
unlock(v);
return -1;
}
if(stream->valid == 0)
{
stream->valid = 1;
}
write_index = v->frame_fifo.write_index;
mem_cpy(&v->frame_fifo.in_frames[write_index].vstream, stream, sizeof(vstream_data_t));
enqueue_to_tail(&v->frame_fifo.in_frames[write_index], &v->frame_queue); //* add this frame to the queue tail.
write_index++;
if (write_index >= v->frame_fifo.max_frame_num)
{
write_index = 0;
}
v->frame_fifo.write_index = write_index;
v->frame_fifo.frame_num++;
v->valid_size += stream->length;
new_write_addr = v->write_addr + stream->length;
if (new_write_addr > v->vbv_buf_end)
{
new_write_addr -= v->max_size;
}
v->write_addr = new_write_addr;
unlock(v);
return 0;
}
//从ROM中读出当前需量数据
void Read_Demand_Data_From_Rom()
{
INT8U Err,Re,Rate,i;
S_Demand *p;
//先读取掉电存储区数据
//再读普通数据
//最后读备份区数据
Re=CHECK_STRUCT_SUM(Cur_Rate_Info);
if(ASSERT(A_WARNING,0!=Re))
Check_Data_Avail();
OS_Sem_Pend(PUB_BUF0_SEM_ID);
p=(S_Demand *)Pub_Buf0;
if(Read_Storage_Data(CUR_DEMAND_PD,p,p,sizeof(Pub_Buf0),&Err)!=sizeof(Cur_Demand) ||\
Check_Demand_Data((S_Demand *)p)==0)
{
DEBUG_PRINT(HUCK,DEBUG_0,"Read CUR_DEMAND_PD data error");
OS_TimeDly_Ms(500);
//读取总和当前费率需量
for(i=0;i<2;i++)
{
if(i==0)
Rate=0;//读总需量时偏移为0
else
Rate=Cur_Rate_Info.Rate;//非总时根据费率计算偏移
p->Rate=Cur_Rate_Info.Rate;
//从当前数据区读取当前和总费率的需量数据
if(Read_Demand_Rate_Data(Rate,(void *)&p->Demand[i],(void *)&p->Demand[i],sizeof(S_One_Demand))!=ONE_DEMAND_SAVE_SIZE)
{
DEBUG_PRINT(HUCK,DEBUG_0,"Read CUR_DEMAND Rate %d data error",Rate);
mem_set((void *)&p->Demand[i],0,sizeof(p->Demand[i]),(void *)&p->Demand[i],sizeof(p->Demand[i]));
}
}
}
if(Check_Demand_Data((S_Demand *)p)==0)
{
ASSERT(A_WARNING,0);
mem_set(p,0,sizeof(Cur_Demand),p,sizeof(Pub_Buf0));
}
DIS_PD_INT;//更新Cur_Demand数据前关掉电中断
mem_cpy((void *)&Cur_Demand,p,sizeof(Cur_Demand),(void *)&Cur_Demand,sizeof(Cur_Demand));
INIT_STRUCT_VAR(Cur_Demand);
SET_DATA_READY_FLAG(Cur_Demand);
SET_STRUCT_SUM(Cur_Demand);
EN_PD_INT;
OS_Sem_Post(PUB_BUF0_SEM_ID);
//SET_STRUCT_SUM(Cur_Demand);
//更新当前存储区和备份存储区，补冻函数可能要用到这两个区，因此要保证这两个区的数据更新
Save_Cur_Demand_Data();
Save_Cur_Demand_Bak_Data();
}
extern Tuple *tuple_dec(void *mem, int *len)
{
*len = int_dec(mem);
Tuple *res = mem_alloc(*len);
mem_cpy(res, mem, *len);
init(res);
return res;
}
/* =================================================================== */
atree_unit<T>* get (atree_unit<T>* node, size_t idx, T* obj = NULL) const
{
atree_unit<T>* dat;
list2_unit<cnode_ptr>* unt;
unt = node->next.get(idx);
dat = static_cast<atree_unit<T>*>(unt->user.ptr);
if (obj != NULL)
mem_cpy(obj, &dat->user, sizeof(T));
return (dat);
}
/*
---------------------------------------
显示后台缓冲
---------------------------------------
*/
static bool_t
iGFX2_FB_flip (
__CR_IN__ iGFX2* that,
__CR_IN__ bool_t sync
)
{
iGFX2_FB* real = (iGFX2_FB*)that;
CR_NOUSE(sync);
mem_cpy(real->m_main, real->__back__.data, real->m_size);
return (TRUE);
}
//获取pSrc时间点或该时间点之前的最近一个冻结时间点,包括pSrc本身所指向的时间点
//即<=pSrc指向时间的最近一个冻结时间点时间点
void Get_Last_Freeze_Time(S_HEX_Time *pSrc,S_HEX_Time *pDst)
{
S_HEX_Time TempTime;
Get_NowMonth_Freeze_Time(pSrc,&TempTime);//获取当月冻结时间
if(Cmp_Time(pSrc,&TempTime)==TIME_BEF)
{
Time_Dec(&TempTime,1,UNIT_MON,pDst);
}
else
mem_cpy(pDst,&TempTime,sizeof(TempTime),pDst,sizeof(S_HEX_Time));
}
//全失压数据累加处理
//Start_Time表示起始时间,Start_Time[0]->Start_Time[4]表示分、时、日、月、年,BCD码
//End_Time表示终止时间,End_Time[0]->End_Time[4]表示分、时、日、月、年，BCD码
//上电后，对上电前的前N(N<=10)次全失压，调用该函数N次
void All_Loss_Vol_Data_Proc(INT8U Start_Time[],INT8U End_Time[], INT32U Curr)
{
TRACE();
Debug_Print("All_Loss_Vol Start_Time:%x-%x-%x %x:%x, End_Time:%x-%x-%x %x:%x, Curr:%ld",\
Start_Time[4],Start_Time[3],Start_Time[2],Start_Time[1],Start_Time[0],\
End_Time[4],End_Time[3],End_Time[2],End_Time[1],End_Time[0], Curr);
All_Loss_Vol_Time.Curr = Curr; //电流
//All_Loss_Vol_Time.Start_Time[0] = 0; //全失压发生的s
//All_Loss_Vol_Time.End_Time[0] = 0;
mem_cpy((INT8U *)All_Loss_Vol_Time.Start_Time, Start_Time, 6, (void *)All_Loss_Vol_Time.Start_Time,sizeof(All_Loss_Vol_Time.Start_Time));
mem_cpy((INT8U *)All_Loss_Vol_Time.End_Time, End_Time, 6, (void *)All_Loss_Vol_Time.End_Time,sizeof(All_Loss_Vol_Time.End_Time));
SET_STRUCT_SUM(All_Loss_Vol_Time);
Event_Separate_Proc(ID_EVENT_ALL_LOSS_VOLT, EVENT_OCCUR, EVENT_REAL);
Event_Separate_Proc(ID_EVENT_ALL_LOSS_VOLT, EVENT_END, EVENT_REAL);
Write_Storage_Data(SDI_LAST_LOSS_VOL_OCCUR_TIME, (void *)All_Loss_Vol_Time.Start_Time, 6);//最近一次全失压发生和结束时刻
Write_Storage_Data(SDI_LAST_LOSS_VOL_END_TIME, (void *)All_Loss_Vol_Time.End_Time, 6);
}
//获取pSrc所指向的时间的当月的冻结时间点,当月指自然月
void Get_NowMonth_Freeze_Time(S_HEX_Time *pSrc,S_HEX_Time *pDst)
{
INT8U Re;
Re=1;
Re=Check_STRUCT_Sum(pSrc,sizeof(S_HEX_Time),pSrc->CS,sizeof(pSrc->CS));
ASSERT(A_WARNING,1==Re);
mem_cpy(pDst->Time,pSrc->Time,sizeof(pSrc->Time),pDst->Time,sizeof(pDst->Time));
pDst->Time[T_HOUR]=Data_Freeze_Time.DDHH[0];
pDst->Time[T_DATE]=Data_Freeze_Time.DDHH[1];
pDst->Time[T_MIN]=0;
Set_STRUCT_Sum(pDst,sizeof(S_HEX_Time),pDst->CS,sizeof(pDst->CS));
}
/* ================== */
bool init (const T* obj)
{
m_root = struct_new(atree_unit<T>);
if (m_root == NULL)
return (false);
m_cnts = 1;
m_root->node = NULL;
m_root->uppe = NULL;
m_root->deep = 0;
mem_cpy(&m_root->user, obj, sizeof(T));
m_root->next.init();
return (true);
}
/* ================== */
bool put (const T* data)
{
size_t tl = m_tail + 1;
if (tl >= N + 1)
tl = 0;
if (tl == m_head)
return (false);
mem_cpy(&m_list[m_tail++], data, sizeof(T));
if (m_tail >= N + 1)
m_tail = 0;
return (true);
}
/*******************************************************************************
* Function Name : ebc_inphase_confirm
* Description :
* Input :
* Output : target_id
* Return :
*******************************************************************************/
STATUS ebc_inphase_confirm(EBC_BROADCAST_STRUCT * pt_ebc, ARRAY_HANDLE target_uid)
{
EBC_BROADCAST_STRUCT ebc;
u8 bsrf_num;
mem_cpy((ARRAY_HANDLE)(&ebc),(ARRAY_HANDLE)(pt_ebc),sizeof(EBC_BROADCAST_STRUCT));
ebc.bid = 0;
ebc.window = 0;
ebc.build_id = 0x00;
ebc.mask = 0x09; // uid, acphase
mem_cpy(ebc.uid,target_uid,6);
bsrf_num = ebc_broadcast(&ebc);
if(bsrf_num)
{
return OKAY;
}
else
{
return FAIL;
}
}
/******************************************************************
* 获取RTC当前时间
*****************************************************************/
void get_rtc_time(INT8U * datetime)
{
uint8_t rtc[16];
INT8U write_rtc[16];
INT8U idx;
INT8U data_len;
data_len = (drv_R8025T_check_read(rtc));
if(data_len == 16)
{
if(rtc[0x0E]&0x02)
{
rtc[0x0D] = 0x00;
rtc[0x0E] = 0x00;
rtc[0x0F] = 0x60;
drv_R8025T_write(0x0D,&rtc[0x0D],3);//正常运行读取时发现VLF位置1，则需要立即清除掉
DateTime2RTCBCD(datetime,rtc);
//写入8025T的星期是按位标识
mem_cpy(write_rtc,rtc,16);
write_rtc[3] = BCD2byte(write_rtc[3]);
if(write_rtc[3]==7)
{
write_rtc[3] = 0;
}
write_rtc[3] = 1<<write_rtc[3];
drv_R8025T_write(0,write_rtc,7);//当VLF置1后，将当期时间写入时钟芯片
}
//rtc[3]是星期，8025T是按位标识的
for(idx=0;idx<7;idx++)
{
if(rtc[3]&(0x01<<idx))
{
break;
}
}
if(idx==0)
{
idx = 7;
}
rtc[3] = byte2BCD(idx);
RTCBCD2DateTime(datetime,rtc);
}
}
//读数据项DI的默认参数
INT16U Read_Def_Para(STORA_DI SDI, void* pDst, INT16U Len, void* pDst_Start, INT16U DstLen)
{
INT16U i;
TRACE();
for(i = 0; i < S_NUM(Def_Para); i++)
{
if(SDI EQ Def_Para[i].SDI || \
(SDI > Def_Para[i].SDI && SDI < Def_Para[i].SDI + Def_Para[i].Num))
{
mem_cpy(pDst, (INT8U *) Def_Para[i].pPara + (SDI - Def_Para[i].SDI) * Len, Len, pDst_Start, DstLen);
return Len;
}
}
return 0;
}
