//等待通信结果,返回正确应答帧返回true,否定返回false, 返回数据域保留在pDst中
bool CcomStatus::waitComEnd(INT8U *pDst, unsigned int maxLen, int *pDstLen)
{
char status;
while(1)//for(int i = 0; i < 100; i ++)
{
Delay_ms(100);
status = comThread->status;
if(comThread->Rcv_Posi >= 500)
{
ASSERT_FAILED();
comThread->Rcv_Posi = 0;
}
if(status EQ COM_FAILED || status EQ COM_OK)
{
if(comThread->Rcv_Posi < maxLen)
{
memcpy(pDst, w->comStatus->comThread->Rcv_Buf + FDATA, w->comStatus->comThread->Rcv_Posi);
*pDstLen = comThread->Rcv_Posi - F_NDATA_LEN;
}
else
{
ASSERT_FAILED();
}
}
if(status EQ COM_FAILED)
return false;
else if(status EQ COM_OK)
return true;
}
}
//刷新显示区域
void updateClockShowArea(CshowArea *area)
{
//CshowArea *area;
QString str;
QTreeWidgetItem *item;
if(area != (CshowArea *)0) //
{
item = area->fileItem;
str = item->data(0,Qt::UserRole).toString();
getClockParaFromSettings(str,area->filePara);
area->imageBk = getLineTextImage(str);
area->updateFlag = true;
getBorderData(str, area->borderData, sizeof(area->borderData));
//qDebug("file_para flag = %d", area->filePara.Temp_Para.Flag);
area->update(); //刷新显示
}
else
{
ASSERT_FAILED();
}
}
void CtimerProperty::getSettingsFromWidget(QString str)
{
settings.beginGroup(str);
int type = settings.value("type").toInt();
if(type EQ TIMER_PROPERTY)
{
settings.setValue("dstYear", dstDateTimeEdit->date().year());
settings.setValue("dstMon", dstDateTimeEdit->date().month());
settings.setValue("dstDay", dstDateTimeEdit->date().day());
settings.setValue("dstHour", dstDateTimeEdit->time().hour());
settings.setValue("dstMin", dstDateTimeEdit->time().minute());
settings.setValue("dstSec", dstDateTimeEdit->time().second());
settings.setValue("color", colorCombo->currentIndex());
settings.setValue("style", styleCombo->currentIndex());
settings.setValue("size", fontSizeCombo->currentIndex());
}
else
ASSERT_FAILED();
settings.endGroup();
if(type EQ TIMER_PROPERTY)
{
nameEdit->getSettingsFromWidget(str);
simpleTextEdit->getSettingsFromWidget(str);
smLineEdit->getSettingsFromWidget(str);
showModeEdit->getSettingsFromWidget(str);
borderEdit->getSettingsFromWidget(str);
}
}
void CtimerProperty::setSettingsToWidget(QString str)
{
int year,month,day,hour,min,sec;
QDate date;
QTime time;
disconnectSignal();
settings.beginGroup(str);
int type = settings.value("type").toInt();
if(type EQ TIMER_PROPERTY)
{
year = settings.value("dstYear").toInt();
month = settings.value("dstMon").toInt();
day = settings.value("dstDay").toInt();
date.setDate(year, month, day);
dstDateTimeEdit->setDate(date);
hour = settings.value("dstHour").toInt();
min = settings.value("dstMin").toInt();
sec = settings.value("dstSec").toInt();
time.setHMS(hour, min, sec, 0);
dstDateTimeEdit->setTime(time);
colorCombo->setCurrentIndex(settings.value("color").toInt());
styleCombo->setCurrentIndex(settings.value("style").toInt());
fontSizeCombo->setCurrentIndex(settings.value("size").toInt());
}
else
ASSERT_FAILED();
settings.endGroup();
if(type EQ TIMER_PROPERTY)
{
nameEdit->setSettingsToWidget(str);
simpleTextEdit->setSettingsToWidget(str);
smLineEdit->setSettingsToWidget(str);
showModeEdit->setSettingsToWidget(str);
borderEdit->setSettingsToWidget(str);
}
else
ASSERT_FAILED();
connectSignal();
}
//資函晩豚�幣議�殆錐業
INT16U Get_DateStr_Pix_Width(INT8U Type, INT8U Font)
{
if(Type >= S_NUM(DateStr))
{
ASSERT_FAILED();
Type = 0;
}
return DateStr[Type].Len*Get_Font_Width(Font);
}
//資函佛豚�幣議�殆錐業
INT16U Get_WeekStr_Pix_Width(INT8U Type, INT8U Font, INT8U Week)
{
if(Type >= S_NUM(WeekStr))
{
ASSERT_FAILED();
Type = 0;
}
return strlen(WeekStr[Type][Week])*Get_Font_Width(Font);
}
/**********************************************************************************
函数功能：检测是否有ACK信号
入口：
出口：1-------------成功；0----------失败
**********************************************************************************/
INT8U I2cSoft_Check_Ack(INT8U Id)
{
INT8U count;
if(Id>IIC_SOFT_MAX_ID) //直接断言，可能影响速度！----------PUCK
{
#ifdef SOFT_I2C_ENV
longjmp(Soft_I2c_Env.Env,1);
#else
return 0;
#endif
}
if(Id!=IIC_SOFT_ID1)
{
CONST_I2C_PORT[Id].Set_Sda_Pin(1); //设置SDA,释放总线-------------PUCK
CONST_I2C_PORT[Id].Set_Sda_Dir(DIR_INPUT);
CONST_I2C_PORT[Id].Set_Sclk_Pin(1); //握总线，查询ACK
for(count=0; count<100; count++)
{
if(CONST_I2C_PORT[Id].Get_Sda_Pin()==0) //ACK回应,为0，表示是ACK
{
CONST_I2C_PORT[Id].Set_Sclk_Pin(0);
CONST_I2C_PORT[Id].Set_Sda_Dir(DIR_OUTPUT);
return 1;
}
}
}
else //16片子
{
SET_16_SDA(1); //CONST_I2C_PORT[Id].Set_Sda_Pin(1); //设置SDA,释放总线-------------PUCK
SET_16_SDA_DIR(DIR_INPUT); //CONST_I2C_PORT[Id].Set_Sda_Dir(DIR_INPUT);
SET_16_SCLK(1); //CONST_I2C_PORT[Id].Set_Sclk_Pin(1); //握总线，查询ACK
for(count=0; count<100; count++)
{
if(GET_16_STATUS EQ 0) //ACK回应,为0，表示是ACK
{
SET_16_SCLK(0); //CONST_I2C_PORT[Id].Set_Sclk_Pin(0);
SET_16_SDA_DIR(DIR_OUTPUT); //CONST_I2C_PORT[Id].Set_Sda_Dir(DIR_OUTPUT);
return 1;
}
}
}
CONST_I2C_PORT[Id].Set_Sclk_Pin(0);
CONST_I2C_PORT[Id].Set_Sda_Dir(DIR_OUTPUT);
ASSERT_FAILED(); //直接断言，可能影响速度！----------PUCK
#ifdef SOFT_I2C_ENV
longjmp(Soft_I2c_Env.Env,1);
#endif
return 0;
}
void paramInit(void)
{
int i;
const char* group = NULL;
int groupLength = 0;
if(isInit)
return;
params = &_param_start;
paramsLen = &_param_stop - &_param_start;
// Calculate a hash of the toc by chaining description of each elements
// Using the CRTP packet as temporary buffer
paramsCrc = 0;
for (int i=0; i<paramsLen; i++)
{
int len = 5;
memcpy(&p.data[0], ¶msCrc, 4);
p.data[4] = params[i].type;
if (params[i].type & PARAM_GROUP) {
if (params[i].type & PARAM_START) {
group = params[i].name;
groupLength = strlen(group);
}
} else {
// CMD_GET_ITEM_V2 result's size is: 4 + strlen(params[i].name) + groupLength + 2
if (strlen(params[i].name) + groupLength + 2 > 26) {
PARAM_ERROR("'%s.%s' too long\n", group, params[i].name);
ASSERT_FAILED();
}
}
if (params[i].name) {
memcpy(&p.data[5], params[i].name, strlen(params[i].name));
len += strlen(params[i].name);
}
paramsCrc = crcSlow(p.data, len);
}
for (i=0; i<paramsLen; i++)
{
if(!(params[i].type & PARAM_GROUP))
paramsCount++;
}
//Start the param task
xTaskCreate(paramTask, PARAM_TASK_NAME,
PARAM_TASK_STACKSIZE, NULL, PARAM_TASK_PRI, NULL);
//TODO: Handle stored parameters!
isInit = true;
}
//等待某事件处理结束
//该函数只用于等待某些特殊事件---只有发生或者只有结束的事件
//例如瞬时快速事件，例如编程、清电量、清需量、清过程等等
void Wait_Event_Data_Proc_End(INT8U Event_ID)
{
TRACE();
OS_Waitfor_Sec(Check_Event_End(Event_ID) EQ 1, 3);//等待5s还没有处理完则报断言错误
if(Check_Event_End(Event_ID) EQ 0)
{
ASSERT_FAILED();
}
//OS_Waitfor(Check_Event_End(Event_ID) EQ 0);
}
/**********************************************************************************
函数功能：关闭模拟IIC口
入口：
出口：
**********************************************************************************/
void I2cSoft_Close(INT8U Id) //将总线置为空闲状态
{
if(Id>IIC_SOFT_MAX_ID) //直接断言，可能影响速度！----------PUCK
{
ASSERT_FAILED();
return ;
}
CONST_I2C_PORT[Id].Set_Sclk_Dir(DIR_INPUT);
CONST_I2C_PORT[Id].Set_Sclk_Pin(1); //改为输出为1
CONST_I2C_PORT[Id].Set_Sda_Dir(DIR_INPUT);
CONST_I2C_PORT[Id].Set_Sda_Pin(1); //改为输出为1
}
//串口接收数据
int CcomThread::comReceive()
{
int bytesRead;
if(COM_Mode EQ COM_MODE)
{
bytesRead = port->read((char *)Rcv_Buf + Rcv_Posi, sizeof(Rcv_Buf)- Rcv_Posi);//(char *)(Rcv_Buf + Rcv_Posi), sizeof(Rcv_ Buf) - Rcv_Posi);
if(bytesRead EQ 0)
return 0;
}
else if(COM_Mode EQ ETH_MODE || COM_Mode EQ WIFI_MODE) //以太网模式
{
QHostAddress address;
quint16 udpPort;
bytesRead = udpSocket->readDatagram((char *)Rcv_Buf + Rcv_Posi, sizeof(Rcv_Buf)- Rcv_Posi, &address, &udpPort);
if(bytesRead <= 0)
return 0;
}
else
return 0;
if(sizeof(Rcv_Buf) >= Rcv_Posi + bytesRead)
{
Rcv_Posi += bytesRead;
Rcv_Buf[Rcv_Posi] = '\0';
}
else
{
ASSERT_FAILED();
Rcv_Posi = 0;
}
for(unsigned int i = 0; i < Rcv_Posi; i ++)
{
//if(Screen_Status.Rcv_Data[i] EQ FRAME_HEAD &&
if(Check_Frame_Format(Rcv_Buf + i, Rcv_Posi - i))
{
if(i != 0) //将数据复制到开始
{
memcpy(Rcv_Buf, Rcv_Buf + i, Rcv_Posi - i);
Rcv_Posi = Rcv_Posi - i;
}
Rcv_Flag = FRAME_FLAG;
Rcv_Ch = CH_COM;
return bytesRead;
}
}
return bytesRead;
}
void CclockProperty::getSettingsFromWidget(QString str)
{
int type;
int tmp;
settings.beginGroup(str);
type = settings.value("type").toInt();
if(type == CLOCK_PROPERTY)
{
tmp = pointRadiusEdit->value();
//qDebug("get pointRadius = %d", tmp);
settings.setValue("pointRadius", pointRadiusEdit->value()); //整点半径
settings.setValue("point369Radius", point369RadiusEdit->value()); //369点半径
settings.setValue("pointMinRadius", pointMinRadiusEdit->value()); //369点半径
settings.setValue("hourWidth", hourWidthEdit->value());//时钟宽度
settings.setValue("minWidth", minWidthEdit->value()); //分钟宽度
settings.setValue("secWidth", secWidthEdit->value()); //分钟宽度
settings.setValue("pointColor", pointColorCombo->currentIndex()); //整点颜色
settings.setValue("point369Color", point369ColorCombo->currentIndex()); //369点颜色
settings.setValue("pointMinColor", pointMinColorCombo->currentIndex()); //369点颜色
settings.setValue("pointStyle", pointStyle->currentIndex()); //整点颜色
settings.setValue("point369Style", point369Style->currentIndex()); //369点颜色
settings.setValue("pointMinStyle", pointMinStyle->currentIndex()); //369点颜色
settings.setValue("hourColor", hourColorCombo->currentIndex()); //时钟颜色
settings.setValue("minColor", minColorCombo->currentIndex()); //分钟颜色
settings.setValue("secColor", secColorCombo->currentIndex()); //秒钟颜色
}
else
ASSERT_FAILED();
settings.endGroup();
if(type == CLOCK_PROPERTY)
{
nameEdit->getSettingsFromWidget(str);
timeDiffEdit->getSettingsFromWidget(str);
simpleTextEdit->getSettingsFromWidget(str);
dateEdit->getSettingsFromWidget(str);
weekEdit->getSettingsFromWidget(str);
showModeEdit->getSettingsFromWidget(str);
borderEdit->getSettingsFromWidget(str);
}
}
//�幣佛豚議忖憲堪
void Show_Week(S_Show_Data *pDst_Buf, INT8U Area_No, INT16U X, INT16U Y, S_Time *pTime, INT8U Language, INT8U Font, INT8U Color)
{
INT8U Week;
if(Language >= S_NUM(WeekStr))
{
Language = 0;
ASSERT_FAILED();
}
Week = pTime->Time[T_WEEK];
if(Week >= 7)
Week = 0;
LED_Print(Font, Color, pDst_Buf, Area_No, X, Y, "%s", WeekStr[Language][Week]);
}
/**********************************************************************************
函数功能：启动软件模拟I2C口,11.0592下，测试SCLK频率为73.5k
入口：
出口：
**********************************************************************************/
INT8U I2cSoft_Start(INT8U Id)
{
if(Id>IIC_SOFT_MAX_ID) //直接断言，可能影响速度！----------PUCK
{
ASSERT_FAILED();
#ifdef SOFT_I2C_ENV
longjmp(Soft_I2c_Env.Env,1);
#else
return 0;
#endif
}
CONST_I2C_PORT[Id].Set_Sda_Pin(1);
CONST_I2C_PORT[Id].Set_Sclk_Pin(1);
CONST_I2C_PORT[Id].Set_Sda_Pin(0); //SDA在SCLK为高时，产生一个下降沿,起始条件产生---------PUCK
return 1;
}
void I2cSoft_Reset(INT8U Id)
{
INT8U i;
Debug_Print("IIC_Error----->Reset I2c_Soft Device,Id=%d!",Id);
ASSERT_FAILED();
I2cSoft_Start(Id);
CONST_I2C_PORT[Id].Set_Sclk_Pin(0);
CONST_I2C_PORT[Id].Set_Sda_Pin(1); //SDA置1,SCL脉冲，释放总线
for(i=0; i<=9; i++)
{
CONST_I2C_PORT[Id].Set_Sclk_Pin(1); //SCL变高，锁存数据
CONST_I2C_PORT[Id].Set_Sclk_Pin(0);
}
I2cSoft_Start(Id);
I2cSoft_Stop(Id);
I2cSoft_Open(Id);
}
//資函蝶倖囂冱議佛豚忖憲堪議恷寄�殆錐業
INT16U Get_WeekStr_Type_Max_Pix_Width(INT8U Type, INT8U Font)
{
INT16U max = 0;
INT8U i;
if(Type >= S_NUM(WeekStr))
{
ASSERT_FAILED();
Type = 0;
}
for(i=0; i < 7; i ++)
{
if(strlen(WeekStr[Type][i]) > max)
max = strlen(WeekStr[Type][i]);
}
return max*Get_Font_Width(Font);
}
bool CcomThread::comRun()
{
FILE *file;
int re;
bool Re = true;
INT16U len;
int len0 = 0;
bool flag = false;
char frameBuf[3000];//[MAX_COM_BUF_LEN + 20];
if(status == COM_ING) //当前在通信过程中,退出
return false;
status = COM_ING; //进入通信状态
this->timeOutFlag = 0;
this->deniedFlag = 0;
if(COM_Mode EQ UDISK_MODE) //U盘模式，直接复制文件就行，不需要通信过程
{
QDir dataDir;
QFile file;
QString fileDir = uDiskName;//getUDiskPath(); //获取U盘路径
//uDiskName = fileDir;
if(fileDir == "") //没有插入U盘
{
comReStr = tr("没有找到U盘,生成U盘数据失败！");
emit this->comStatusChanged(comReStr);
status = COM_FAILED; //进入通信状态
return false;
}
fileDir = fileDir + "LEDDATA";
if(dataDir.exists(fileDir) == false)
{
if(dataDir.mkdir(fileDir) == false)
{
comReStr = uDiskName + tr(",该U盘中创建目录失败，请检查U盘是否写保护");
emit this->comStatusChanged(comReStr);
status = COM_FAILED; //进入通信状态
return false;
}
}
fileDir = fileDir + "\\" + QString::number(this->COM_Para.Addr) + ".dat";
if(file.exists(fileDir))
file.remove(fileDir);
if(file.copy(protoFileName, fileDir) == false)
{
comReStr = uDiskName + tr(",该U盘中复制文件失败，请检查U盘是否写保护");
emit this->comStatusChanged(comReStr);
status = COM_FAILED; //进入通信状态
return false;
}
comReStr = tr("数据成功保存到")+uDiskName;
status = COM_OK; //进入通信状态
return true;
}
file = fopen(protoFileName.toLocal8Bit(), "rb");
if(file EQ 0)
{
ASSERT_FAILED();
comReStr = tr("找不到协议数据文件！");
emit this->comStatusChanged(comReStr);
status = COM_FAILED;
return false;
}
fseek(file, 0, SEEK_SET);
//dialog->show();
if(this->connect() EQ 0)
{
status = COM_FAILED;
this->timeOutFlag = 1;//等同于通信超时处理,重新自动连接
return false;
}
while((re = fread(frameBuf, FLEN + 2, 1, file)) > 0 && frameBuf[0] EQ FRAME_HEAD)
{
len = 0;
memcpy(&len, frameBuf + FLEN, 2);
if(len <= sizeof(frameBuf) && len > FLEN + 2)
{
re = fread(frameBuf + FLEN + 2, len - (FLEN + 2), 1, file);
if(re > 0 && Check_Frame_Format((INT8U *)frameBuf, len))
{
flag = true;
Rcv_Posi = 0;
memset(Rcv_Buf, 0, sizeof(Rcv_Buf));
if(sendFrame(frameBuf, len, sizeof(frameBuf)) EQ false)
{
Re = false;
break;
}
/*
//进入固件升级状态,发送进入升级状态帧后延时200ms,因为复位和初始化过程中收不到帧，必须等待
if(frameBuf[FCMD] EQ C_SELF_TEST && frameBuf[FDATA] EQ (0x02 + 0x33))
{
this->msleep(200);
}
*/
len0 += len;
fseek(file, len0, SEEK_SET);
}
else
{
Re = false;
break;
}
}
else
{
Re = false;
break;
}
}
fclose(file);
this->disConnect();
if(checkComMode(this->COM_Mode))
{
if(flag EQ false)
{
comReStr = tr("无数据发送");
emit this->comStatusChanged(comReStr);
}
else
emit this->comEnd(Re);
}
if(Re EQ true)
status = COM_OK;
else
status = COM_FAILED;
return Re;
}
//上电事件处理
//上电事件处理
void PowerOn_Event_Proc()
{
//上电初始化过程中不需要关掉电中断，因为在此过程中掉电不会存数
if(Get_Sys_Status() != SYS_NORMAL)
return;
Debug_Print("----------PowerOn Event Proc Start----------");
//读出的掉电数据正确且确实发生了掉电
if(Read_Storage_Data(_SDI_EVENT_DATA_PD,(void *)&Event_Data,(void *)&Event_Data,sizeof(Event_Data)) != sizeof(Event_Data))
{
Clr_Event_PD_Data();
}
else if(Event_Data.PD_Flag EQ 1)
{
mem_cpy((void *)&Meter_Instant_Status,(void *)&Event_Data.Meter_Instant_Status,sizeof(Event_Data.Meter_Instant_Status),\
(void *)&Meter_Instant_Status,sizeof(Meter_Instant_Status));
mem_cpy((void *)&Bat_Work_Status,(void *)&Event_Data.Bat_Work_Status,sizeof(Event_Data.Bat_Work_Status),\
(void *)&Bat_Work_Status,sizeof(Bat_Work_Status));
mem_cpy((void *)&Not_Even_Data_PUCK, (void *)&Event_Data.Not_Even_Data, sizeof(Event_Data.Not_Even_Data),\
(void *)&Not_Even_Data_PUCK, sizeof(Not_Even_Data_PUCK));
mem_cpy((void *)&Prg_Key_Status, (void *)&Event_Data.Prg_Key_Status, sizeof(Event_Data.Prg_Key_Status),\
(void *)&Prg_Key_Status, sizeof(Prg_Key_Status));
Relay_Status.Switch_Status = Event_Data.Relay_Status.Switch_Status;
Relay_Status.Switch_Cause = Event_Data.Relay_Status.Switch_Cause;
//设置掉电前时间为当前时间，用于处理掉电前事件
Set_BCD_Array_Time((S_BCD_Time *)&Event_Data.Time, (S_Event_Time *)&Cur_Time2, (S_Event_Time *)&Cur_Time2, sizeof(Cur_Time2));
Init_PD_PO_Time(); //初始化上电和掉电时间
Save_LastPwrOff_Data_PUCK();//上次掉电数据处理
//重新覆盖Cur_Time1时间
Set_BCD_Array_Time((S_BCD_Time *)&Cur_Time1, (S_Event_Time *)&Cur_Time2, (S_Event_Time *)&Cur_Time2, sizeof(Cur_Time2));
/*
//密码锁
if(CHECK_STRUCT_SUM(Event_Data._PSW_Err_Info) EQ 0 || CHECK_STRUCT_VAR(Event_Data._PSW_Err_Info) EQ 0)
{
ASSERT_FAILED();
mem_set((void *)&PSW_Err_Info, 0, sizeof(PSW_Err_Info),(void *)&PSW_Err_Info, sizeof(PSW_Err_Info));
INIT_STRUCT_VAR(PSW_Err_Info);
SET_STRUCT_SUM(PSW_Err_Info);
SET_STRUCT_SUM(Event_Data);
}
PSW_Err_Info.Set_En_Mins = 0; //设置有效时间应该清除
SET_STRUCT_SUM(PSW_Err_Info);
*/
//前一次冻结时间
if(CHECK_STRUCT_SUM(Event_Data._Last_Freeze_Time) EQ 0)
{
ASSERT_FAILED();
mem_set((void *)&Last_Freeze_Time, 0, sizeof(Last_Freeze_Time), (void *)&Last_Freeze_Time, sizeof(Last_Freeze_Time));
SET_STRUCT_SUM(Last_Freeze_Time);
SET_STRUCT_SUM(Event_Data);
}
//事件瞬态字
mem_set((void *)&Event_Data.Meter_Instant_Status,0,sizeof(Event_Data.Meter_Instant_Status),\
(void *)&Event_Data.Meter_Instant_Status,sizeof(Event_Data.Meter_Instant_Status));
SET_STRUCT_SUM(Event_Data.Meter_Instant_Status);
//编程记录
if(CHECK_STRUCT_SUM(Prog_Record) EQ 0)
Clr_Prog_Record_Ram();
//编程操作者代码
mem_set((void *)&Event_Data._Operator_ID,0,sizeof(Event_Data._Operator_ID),\
(void *)&Event_Data._Operator_ID,sizeof(Event_Data._Operator_ID));
SET_STRUCT_SUM(Event_Data._Operator_ID);
//需量越限记录
mem_set((void *)&Event_Data._Demand_Exceed_Limit,0,sizeof(Event_Data._Demand_Exceed_Limit),\
(void *)&Event_Data._Demand_Exceed_Limit,sizeof(Event_Data._Demand_Exceed_Limit));
SET_STRUCT_SUM(Event_Data._Demand_Exceed_Limit);
//前一次校时时间
/*
mem_set((void *)&Event_Data._Last_Adj_Time,0,sizeof(Event_Data._Last_Adj_Time),\
(void *)&Event_Data._Last_Adj_Time,sizeof(Event_Data._Last_Adj_Time));
SET_STRUCT_SUM(Event_Data._Last_Adj_Time);
*/
//当前时间
mem_cpy((void *)&Event_Data.Time,(void *)&Cur_Time1,sizeof(Cur_Time1),(void *)&Event_Data.Time,sizeof(Event_Data.Time));
Event_Data.PD_Flag = 0;
SET_STRUCT_SUM(Event_Data);
Write_Storage_Data(_SDI_EVENT_DATA_PD,(void *)&Event_Data,sizeof(Event_Data));
}
else
{
Debug_Print("PD_Flag != 1");
}
Debug_Print("----------PowerOn Event Proc End----------");
}
// program/01
void CprogManage::newProg()
{
int i,size,type;
int max = 0,tmp;
QTreeWidgetItem *parentItem,*curItem;
curItem = treeWidget->currentItem(); //当前被选中的项
if(curItem == (QTreeWidgetItem *)0)
{
QMessageBox::information(w, tr("提示"),
tr("请在节目管理栏选定一个屏幕"),tr("确定"));
return;
}
type = checkItemType(curItem); //该项目是哪种?
//找到该分区对应的节目的treeWidgetItem
if(type == SCREEN_PROPERTY)
parentItem = curItem;
else if(type == PROG_PROPERTY)
parentItem = curItem->parent();
else if(type == AREA_PROPERTY)
parentItem = curItem->parent()->parent();
else
{
parentItem = (curItem ->parent())->parent()->parent();
}
if(parentItem EQ (QTreeWidgetItem *)0)
{
ASSERT_FAILED();
QMessageBox::information(w, tr("提示"),
tr("请在节目管理栏选定一个屏幕"),tr("确定"));
return;
}
QString QStr = (parentItem ->data(0,Qt::UserRole)).toString();
QStr = QStr + "/program";
settings.beginGroup(QStr); //设置settings到program下面
QStringList groups = settings.childGroups(); //所有节目的列表
size = groups.size();
if(size >= MAX_PROG_NUM)
{
settings.endGroup();
QMessageBox::information(w, tr("提示"),
tr("当前屏幕节目数达到上限！"),tr("确定"));
return;
}
//qDebug("groups size = %d", size);
for(i = 0; i < size; i ++)
{
tmp = groups.at(i).toInt();
if(tmp > max)
max=tmp;
}
max++;
//qDebug("new prog %d",max);
settings.beginGroup(fixWidthNumber(max));
settings.setValue("subIndex", 0); //当前子分区
settings.setValue("name", QString("new prog"));
settings.setValue("type", PROG_PROPERTY);
settings.setValue("subType", 0);
settings.setValue("setFlag", 0); //没有设过参数
//按日期定时
settings.setValue("dateTimerCheck", 0);
settings.setValue("startYear", 2010);
settings.setValue("startMonth", 1);
settings.setValue("startDay", 1);
settings.setValue("endYear", 2010);
settings.setValue("endMonth", 1);
settings.setValue("endDay", 1);
//按星期定时
settings.setValue("weekTimerCheck", 0);
settings.setValue("w0", 0);
settings.setValue("w1", 0);
settings.setValue("w2", 0);
settings.setValue("w3", 0);
settings.setValue("w4", 0);
settings.setValue("w5", 0);
settings.setValue("w6", 0);
//按时间定时
settings.setValue("timeCheck", 0);
settings.setValue("startHour", 0);
settings.setValue("startMin", 0);
settings.setValue("endHour", 0);
settings.setValue("endMin", 0);
//定长播放
settings.setValue("playMode", 0);
settings.setValue("playTime", 60);
settings.setValue("playCount", 1);
//边框选择
settings.setValue("borderCheck", 0);
settings.setValue("width", 1);
settings.setValue("speed", 1);
settings.setValue("style", 1);
settings.setValue("color", 1);
settings.setValue("checkState", true);
//qDebug("progs size = %d", settings.childGroups().size());
settings.endGroup();
settings.endGroup();
QTreeWidgetItem* item = new QTreeWidgetItem(parentItem,QStringList(QString::number(size + 1)+tr("节目")));
item->setData(0, Qt::UserRole, QStr + "/" + fixWidthNumber(max));
item->setCheckState(0, Qt::Checked);
QIcon icon = getTypeIcon(PROG_PROPERTY);
item->setIcon(0,icon);
//parentItem->addChild(item);
//treeWidget->addTopLevelItem(item);
//treeWidget->setCurrentItem(item);
//saveCurItem(item); //当前点钟的
//w->progManage->clickItem(item, 0);
w->progManage->treeWidget->setCurrentItem(item);
/*
updateTextHead(parentItem);
w->property->updateProperty(item);
w->screenArea->updateShowArea(item);// progSettingsInit(QStr);
*/
}
//删除项目
//flag == 0表示强制删除
//flag == 1表示密码删除
void CprogManage::_deleteItem(int flag)
{
QTreeWidgetItem *curItem;
int type;
QTreeWidgetItem *parent;
QString str;
int index;
curItem = treeWidget->currentItem(); //当前被选中的项
if(curItem == 0)
return;
str = curItem->data(0, Qt::UserRole).toString();
type = checkItemType(curItem);
if(type EQ SCREEN_PROPERTY)//---是屏幕的不能删除
{
if(flag)
{
if(verifyPSW() EQ 0)
return;
}
index = treeWidget->indexOfTopLevelItem(curItem);
treeWidget->takeTopLevelItem(index);
updateTextHead(0);
curItem = treeWidget->currentItem(); //当前被选中的项
QList<QMdiSubWindow *>subWinList = w->mdiArea->subWindowList();
QMdiSubWindow *subWin = subWinList.at(index);
w->mdiArea->removeSubWindow(subWin);
for(int i = 0; i < subWinList.count(); i ++)
{
subWinList.at(i)->setWindowTitle(QString::number(i+1)+tr("屏幕"));
}
//删除所有配置项
settings.beginGroup(str);
//qDebug("remove str:%s",(const char *)str.toLocal8Bit());
settings.remove("");
settings.endGroup();
}
else
{
if(type != PROG_PROPERTY) //分区和文件类型
{
if(type == AREA_PROPERTY)
{
settings.beginGroup(str);
int index = settings.value("index").toInt();
if(index < MAX_AREA_NUM)
w->screenArea->setAreaVisible(index, 0);
else
ASSERT_FAILED();
settings.endGroup();
}
parent = curItem->parent();
curItem->parent()->removeChild(curItem);
//updateItemSubIndex(curItem);
updateTextHead(parent);
if(type != AREA_PROPERTY)//当前删除的是文件播放类型
{
if(parent->childCount() EQ 0) //改分区下没有其他文件播放类型了
{
w->screenArea->updateShowArea(parent); //更新改分区的显示部分.---已经没有文件了，清除该分区的显示
}
}
}
else
{/*
index = treeWidget->indexOfTopLevelItem(curItem);
treeWidget->takeTopLevelItem(index);
updateTextHead(0);
*/
parent = curItem->parent();
curItem->parent()->removeChild(curItem);
//updateItemSubIndex(curItem);
updateTextHead(parent);
for(int i = 0; i < MAX_AREA_NUM; i ++)
w->screenArea->setAreaVisible(i, 0);
}
settings.beginGroup(str);
//qDebug("remove str:%s",(const char *)str.toLocal8Bit());
settings.remove("");
settings.endGroup();
//settings.remove(str);//删除这个组
if(parent->childCount() == 0)//子项都删除则将父项的子索引清0
{
str = parent->data(0, Qt::UserRole).toString();//.toString();
settings.beginGroup(str);
settings.setValue("subIndex", 0);
settings.endGroup();
}
//qDebug("remove : %s", (const char *)(Qvar.toString().toLocal8Bit()));
curItem = treeWidget->currentItem(); //当前被选中的项
if(curItem == 0)
{
for(int i = 0; i < MAX_AREA_NUM; i ++)
w->screenArea->setAreaVisible(i, 0);
//return;
}
}
saveCurItem((QTreeWidgetItem *)0xFFFFFFFF); //删除后当前没有点中项
//w->progManage->clickItem(curItem, 0);
w->progManage->treeWidget->setCurrentItem(curItem);
}
//更新边框数据
void Update_Border_Data(INT8U Area_No)
{
INT32U Max_Step;//, Size;
static S_Int8U InitFlag = {CHK_BYTE, 0, CHK_BYTE};
//S_Simple_Border_Data *p;
INT8U i;
//还在移动状态
static S_Int16U Timer[MAX_AREA_NUM + 1];// = {CHK_BYTE, 0, CHK_BYTE};
static S_Int8U Flag[MAX_AREA_NUM + 1];// = {CHK_BYTE, 0, CHK_BYTE};
INT16U Step_Time = 0; //步进时间
INT8U Border_Width;//,Border_Height;
//INT8U *pBorder_Data;
INT8U Border_Mode;
//INT8U Type;
if(Prog_Status.Play_Status.New_Prog_Flag ||\
(Area_No < MAX_AREA_NUM &&\
(Prog_Status.Area_Status[Area_No].New_File_Flag ||\
Prog_Status.Area_Status[Area_No].New_SCN_Flag))) //该节目或该分区还没有进入播放状态?
return;
//第一次进入该函数，初始化相关函数头尾
if(InitFlag.Var EQ 0)
{
InitFlag.Var = 1;
for(i = 0; i < MAX_AREA_NUM + 1; i ++)
{
SET_HT(Timer[i]);
SET_HT(Flag[i]);
}
}
if(Area_No EQ MAX_AREA_NUM) //总的节目的边框
{
if(Prog_Para.Border_Check EQ 0)
return;
TRACE();
Step_Time = (INT16U)(Prog_Para.Border_Speed + 1)*MOVE_STEP_PERIOD;//(Prog_Para.Border_Speed+ 1)*MAX_STEP_NUM; //MAX_STEP_NUMms的的一个速度步进
Prog_Status.Border_Status[Area_No].Timer += MOVE_STEP_PERIOD;
Max_Step = 0xFFFFFFFF;//Screen_Para.Base_Para.Width + Screen_Para.Base_Para.Height;
Border_Mode = Prog_Para.Border_Mode;
}
else
{
if(Area_No > MAX_AREA_NUM)
{
ASSERT_FAILED();
return;
}
if(Prog_Status.File_Para[Area_No].Pic_Para.Border_Check EQ 0)
return;
TRACE();
Step_Time = (INT16U)(Prog_Status.File_Para[Area_No].Pic_Para.Border_Speed + 1)*MOVE_STEP_PERIOD;//(Prog_Para.Border_Speed+ 1)*MAX_STEP_NUM; //MAX_STEP_NUMms的的一个速度步进
Prog_Status.Border_Status[Area_No].Timer += MOVE_STEP_PERIOD;
Max_Step = 0xFFFFFFFF;
Border_Mode = Prog_Status.File_Para[Area_No].Pic_Para.Border_Mode;
}
Border_Width = Get_Area_Border_Width(Area_No);
//Border_Height = Get_Area_Border_Height(Area_No);
if(Prog_Status.Border_Status[Area_No].Timer >= Step_Time)
{
Prog_Status.Border_Status[Area_No].Timer = 0;
if(Prog_Status.Border_Status[Area_No].Step + MOVE_STEP + Border_Width >= Max_Step)
Prog_Status.Border_Status[Area_No].Step = 0;//Max_Step - Prog_Status.Border_Status[Area_No].Step;
Prog_Status.Border_Status[Area_No].Step += MOVE_STEP;
Timer[Area_No].Var ++;
if(Timer[Area_No].Var >= 2)
{
Timer[Area_No].Var = 0;
Flag[Area_No].Var = 1 - Flag[Area_No].Var;
}
if(Border_Mode EQ BORDER_STATIC) //静态
{
Copy_Border(Area_No, 0);
}
else if(Border_Mode EQ BORDER_FLASH) //闪烁
{
if(Flag[Area_No].Var EQ 0)
Copy_Border(Area_No, 0);
else
Clr_Border(&Show_Data, Area_No);
}
else if(Border_Mode EQ BORDER_CLKWS) //顺时针
{
Copy_Border(Area_No, Max_Step - Border_Width - Prog_Status.Border_Status[Area_No].Step);
}
else if(Border_Mode EQ BORDER_CCLKWS) //逆时针
{
Copy_Border(Area_No, Prog_Status.Border_Status[Area_No].Step);
}
else if(Border_Mode EQ BORDER_CLKWS_FLASH) //顺时针闪烁
{
if(Flag[Area_No].Var EQ 0)
Copy_Border(Area_No, Max_Step - Border_Width - Prog_Status.Border_Status[Area_No].Step);
else
Clr_Border(&Show_Data, Area_No);
}
else if(Border_Mode EQ BORDER_CCLKWS_FLASH) //逆时针闪烁
{
if(Flag[Area_No].Var EQ 0)
Copy_Border(Area_No, Prog_Status.Border_Status[Area_No].Step);
else
Clr_Border(&Show_Data, Area_No);
}
}
//}
/*
if(Timer[Area_No].Var >= 500)
{
Timer[Area_No].Var = 0;
if(Flag[Area_No].Var > 0)
Flag[Area_No].Var = 0;
else
Flag[Area_No].Var = 1;
}
*/
}
//显示一个表盘
//pDst_Buf目标显示缓冲区
//Area_No 目标分区
//pClock_Para 时钟参数
void Show_Clock(S_Show_Data *pDst_Buf, INT8U Area_No, S_Time *pTime, S_Clock_Para *pClock_Para)
{
INT16U Radius;
INT16U Width,Height;
S_Point Point;
//INT16S Angle;
//return;
if(Area_No >= MAX_AREA_NUM)
{
ASSERT_FAILED();
return;
}
if(pTime->Time[T_SEC] >= 60 ||\
pTime->Time[T_MIN] >= 60 ||\
pTime->Time[T_HOUR] >= 24)
return;
Width = Get_Area_Width(Area_No);
Height = Get_Area_Height(Area_No);
Radius = ((Width < Height)? Width:Height) * 95 /100 / 2; //表盘的半径
//Get_Area_TopLeft(Area_No, &Point); //分区左上位置
Point.X = 0;
Point.Y = 0;
//分区中心位置
Point.X += Width/2;
Point.Y += Height/2;
/*
//分点
if(pClock_Para->Min_Point_Radius)
{
for(Angle = 0; Angle < 360; Angle = Angle + 360/60)
{
if(Angle % 90 == 0 || Angle % (360/12) == 0) //369点已经绘制过了，跳过
continue;
//距离中心点的角度是Angle，长度是Radius * 0.9, 该点半径为Hour369_Point_Radius,颜色为 Hour369_Point_Color
Fill_Clock_Point(pDst_Buf, Area_No, &Point, Angle, (INT16S)(Radius * 0.9), \
pClock_Para->Min_Point_Radius, pClock_Para->Min_Point_Style, pClock_Para->Min_Point_Color);
}
}
//整点
if(pClock_Para->Hour_Point_Radius)
{
for(Angle = 0; Angle < 360; Angle = Angle + 360/12)
{
if(Angle % 90 == 0) //369点已经绘制过了，跳过
continue;
//距离中心点的角度是Angle，长度是Radius * 0.9, 该点半径为Hour369_Point_Radius,颜色为 Hour369_Point_Color
Fill_Clock_Point(pDst_Buf, Area_No, &Point, Angle, (INT16S)(Radius * 0.9), \
pClock_Para->Hour_Point_Radius, pClock_Para->Hour_Point_Style, pClock_Para->Hour_Point_Color);
}
}
//369点
if(pClock_Para->Hour369_Point_Radius)
{
for(Angle = 0; Angle < 360; Angle = Angle + 90)
{
//距离中心点的角度是Angle，长度是Radius * 0.9, 该点半径为Hour369_Point_Radius,颜色为 Hour369_Point_Color
Fill_Clock_Point(pDst_Buf, Area_No, &Point, Angle, Radius * 9 / 10, \
pClock_Para->Hour369_Point_Radius, pClock_Para->Hour369_Point_Style, pClock_Para->Hour369_Point_Color);
}
}
*/
//----------至此0-11点所有的点都已经绘制完成------------
//时钟
if(pClock_Para->Hour_Line_Width)
Fill_Clock_Line(pDst_Buf, Area_No, &Point, 90 - (360 * ((pTime->Time[T_HOUR] % 12) * 60 + pTime->Time[T_MIN]) / 720), Radius * 8 / 10,\
pClock_Para->Hour_Line_Width, pClock_Para->Hour_Line_Color);
//分钟
if(pClock_Para->Min_Line_Width)
Fill_Clock_Line(pDst_Buf, Area_No, &Point, 90 - 360 * pTime->Time[T_MIN] / 60, Radius * 10 / 10,\
pClock_Para->Min_Line_Width, pClock_Para->Min_Line_Color);
//秒钟
//pTime->Time[T_SEC] = 15;
if(pClock_Para->Sec_Line_Width)
Fill_Clock_Line(pDst_Buf, Area_No, &Point, 90 - 360 * pTime->Time[T_SEC] / 60, Radius * 12 / 10,\
pClock_Para->Sec_Line_Width, pClock_Para->Sec_Line_Color);
}
bool CcomThread::sendFrame(char *data, int len, int bufLen)
{
int i,re;
INT8U mode = COM_Mode;
const char temp[3] = {0xEE, 0xEE, 0xEE};
this->timeOutFlag = 0;
this->deniedFlag = 0;
if(mode EQ PREVIEW_MODE)//预览模式
{
Rcv_Frame_Proc(CH_SIM, (INT8U *)data, (INT16U)len, bufLen); //接收函数处理。在仿真情况下，将参数写入了硬盘文件。模拟写入EEROM
return true;
}
else if(mode EQ SIM_MODE) //仿真模式
{/*
for(i = 0; i < len; i ++)
Com_Rcv_Byte(CH_SIM, *(data + i));
while(1)
{
Delay_ms(100);
if(Screen_Status.Rcv_Flag EQ 0) //等待线程处理完该帧
break;
}
*/
// Rcv_Frame_Proc(CH_SIM, (INT8U *)data, (INT16U)len, bufLen); //接收函数处理。在仿真情况下，将参数写入了硬盘文件。模拟写入EEROM
for(i = 0; i < len; i ++)
Com_Rcv_Byte(CH_SIM, *(data + i));
Screen_Com_Proc();
comReStr = tr("发送第") + QString::number(frameCounts + 1)+"/"+QString::number(totalFrameCounts)+tr("帧,等待应答...");
emit this->comStatusChanged(comReStr);
frameCounts++;
if((Rcv_Buf[FCMD] & 0xC0) EQ 0x40) //肯定应答
{
emit comProgressChanged(100*frameCounts/totalFrameCounts);
comReStr = tr("收到肯定应答");
emit this->comStatusChanged(comReStr);
return true;
}
else if((Rcv_Buf[FCMD] & 0xC0) EQ 0x80) //否定应答
{
comReStr = tr("收到否定应答");
this->deniedFlag = 1;
comReStr += QString(":") + getRcvErrInfo(Rcv_Buf[FDATA]);
emit this->comStatusChanged(comReStr);
return false;
}
else
{
comReStr = tr("收到无效应答");
emit this->comStatusChanged(comReStr);
return false;
}
}
else if(mode EQ COM_MODE)//串口通信模式
{
for(i = 0; i < 2; i ++)
{
port->write(temp, sizeof(temp));
port->write(data, len);
if(i EQ 0)
comReStr = tr("发送第") + QString::number(frameCounts + 1)+"/"+QString::number(totalFrameCounts)+tr("帧,等待应答...");// + QString::number(len);
else
comReStr = tr("重复发送第") + QString::number(frameCounts + 1)+"/"+QString::number(totalFrameCounts)+tr("帧,等待应答...");
emit this->comStatusChanged(comReStr);
re = waitComRcv(comTimeOutSec); //等待应答
if(re > 0)
{
frameCounts++;
emit comProgressChanged(100*frameCounts/totalFrameCounts);
if((Rcv_Buf[FCMD] & 0xC0) EQ 0x40) //肯定应答
{
comReStr = tr("收到肯定应答");
emit this->comStatusChanged(comReStr);
return true;
}
else if((Rcv_Buf[FCMD] & 0xC0) EQ 0x80) //否定应答
{
comReStr = tr("收到否定应答");
this->deniedFlag = 1;
comReStr += QString(":") + getRcvErrInfo(Rcv_Buf[FDATA]);
emit this->comStatusChanged(comReStr);
return false;
}
else
{
comReStr = tr("收到无效应答");
emit this->comStatusChanged(comReStr);
return false;
}
}
}
this->timeOutFlag = 1; //超时标志
comReStr = tr("等待应答超时");
emit this->comStatusChanged(comReStr);
return false;
}
else if(mode EQ ETH_MODE || mode EQ WIFI_MODE)//以太网模式
{
QHostAddress host;
//host.setAddress("192.168.001.122");//Net_Para.IP);
if(mode EQ ETH_MODE)
host.setAddress(RevIP(Net_Para.IP));
else
host.setAddress(DEF_WIFI_DST_IP);
for(i = 0; i < 2; i ++)
{
//port->write(data, len);
if(udpSocket->writeDatagram(data,len,host, 8000) != len)//将data中的数据发送
{
comReStr = tr("发送数据失败");
emit this->comStatusChanged(comReStr);
return false;
}
if(i EQ 0)
comReStr = tr("发送第") + QString::number(frameCounts + 1)+"/"+QString::number(totalFrameCounts)+tr("帧,等待应答...");// + QString::number(len);
else
comReStr = tr("重复发送第") + QString::number(frameCounts + 1)+"/"+QString::number(totalFrameCounts)+tr("帧,等待应答...");
emit this->comStatusChanged(comReStr);
re = waitComRcv(15); //等待应答
if(re > 0)
{
frameCounts++;
emit comProgressChanged(100*frameCounts/totalFrameCounts);
if((Rcv_Buf[FCMD] & 0xC0) EQ 0x40) //肯定应答
{
comReStr = tr("收到肯定应答");
emit this->comStatusChanged(comReStr);
return true;
}
else if((Rcv_Buf[FCMD] & 0xC0) EQ 0x80) //否定应答
{
comReStr = tr("收到否定应答");
this->deniedFlag = 1;
comReStr += QString(":") + getRcvErrInfo(Rcv_Buf[FDATA]);
emit this->comStatusChanged(comReStr);
return false;
}
else
{
comReStr = tr("收到无效应答");
emit this->comStatusChanged(comReStr);
return false;
}
}
}
comReStr = tr("等待应答超时");
emit this->comStatusChanged(comReStr);
return false;
}
else if(mode EQ GPRS_MODE)
{
}
else if(mode EQ UDISK_MODE)
{
ASSERT_FAILED();
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//得到明文+mac 对esam进行设置 ,pSrc为从数据标示开始的数据， SrcLen为数据长度 即 645帧中L字段的值
//不需要告诉黄工 修改esam参数，
INT8U Set_Esam_Para( INT8U *pSrc, INT8U SrcLen)
{//一类数据修改
INT8U DataPdi[4];
INT8U i,j;
INT16U Temp;
struct Far_Deal_Para_Flag_T1 Far_Deal_Para_Flag_T1;
struct Far_645_Frame_T1 Far_645_Frame_T1;
//
//查看 身份认证有效时间有没有到
Far_Identity_Auth_Ok_Flag=!Chk_Pay_Time_Arrive();
if(Far_Identity_Auth_Ok_Flag != 1)
{
Reset_Pay_Timer(0);
ASSERT_FAILED();
return 0;
}
//
CPU_ESAM_CARD_Control(ESAM);
if( Select_Directry(0,0x3F,0) != OK )
{
ASSERT_FAILED();
Card_Error_State.CardErrorState.CPU_CARD_ESAM_ATR_ERR=1;
return 0;
}
if(FarPrePayment.ID_Ins_Counter >=15 )
{
ASSERT_FAILED();
return 0;
}
mem_cpy(DataPdi,pSrc,4,DataPdi,4);
mem_cpy(&Far_645_Frame_T1,pSrc+4,sizeof(Far_645_Frame_T1),&Far_645_Frame_T1,sizeof(Far_645_Frame_T1));
for( i=0;i<S_NUM(Far_Deal_Para_List_T1);i++ )
{
if(memcmp(&Far_Deal_Para_List_T1[i].Data_ID[0],&DataPdi[0],4) EQ 0 )
{
break;
}
}
if( i EQ S_NUM(Far_Deal_Para_List_T1))
{
ASSERT_FAILED();
return 0;
}
//长度不对 // SrcLen 应该 和 数据实际长度，+4字节mac +12 字节 数据标示，密码，操作者代码， 相等
if( SrcLen != (Far_Deal_Para_List_T1[i].Esam_Length+16) )
{
ASSERT_FAILED();
return 0;
}
///////
for( j=0;j<LENGTH_FAR_DEAL_PARA_FLAG_T1;j++ )
*(((INT8U *)(&Far_Deal_Para_Flag_T1))+j) = *(((const INT8U *)&Far_Deal_Para_List_T1[i])+j);
//检查数据合法性因为多了4个字节mac 所以这里要减去4
if( Set_Data_Format_Check(pSrc,SrcLen-4, &Temp) )
{
ASSERT_FAILED();
return 0;
}
if(Far_Write_Esam(0x04,Update_Binary,0x80+Far_Deal_Para_Flag_T1.Esam_File,
(INT8U)Far_Deal_Para_Flag_T1.Esam_Offset,
Far_Deal_Para_Flag_T1.Esam_Length,
pSrc+LENGTH_FAR_645_FRAME_T1+4,0)!=OK)//这里为偏移16个字节即实际数据为N1N2...Nm
{
FarPrePayment.Far_Error_State.CpuCardInternlAuthenticationErr=1; //这里的赋值没有任何意义
ReNew_Err_Code(DIS_CERTI_ERR);
ASSERT_FAILED();
return 0;
}
return 1;
}
//#undef Debug_Print
//#define Debug_Print _Debug_Print
//全失压次数和时间统计
//上电后调用该函数一次，Counts表示掉电期间失压总次数，Mins表示掉电期间失压总分钟数
void All_Loss_Vol_Counts_Time_Proc(INT32U Counts,INT32U Mins)
{
//INT16U Re;
//INT8U Temp[20];
INT32U Counts0,Mins0;
INT16U Len;
TRACE();
Debug_Print("All_Loss_Vol Counts:%ld, Mins:%ld", Counts, Mins);
OS_Mutex_Pend(PUB_BUF0_SEM_ID);
Len = Read_Storage_Data(EC_DI(0x03050000), (void *)Pub_Buf0, (void *)Pub_Buf0, sizeof(Pub_Buf0));
if(Len EQ 0)
{
ASSERT_FAILED();
Len = Read_Storage_Data(EC_DI(0x03050001), (void *)Pub_Buf0, (void *)Pub_Buf0, sizeof(Pub_Buf0));
}
if(Len > 0)
{
mem_cpy(&Counts0, (INT8U *)Pub_Buf0 + 5, 4, &Counts0, sizeof(Counts0));
mem_cpy(&Mins0, (INT8U *)Pub_Buf0 + 9, 4, &Mins0, sizeof(Mins0));
}
else
{
Counts0 = 0;
Mins0 = 0;
}
Counts0 += Counts;
Mins0 += Mins;
Debug_Print("Total_All_Loss_Vol Counts:%ld, Mins:%ld", Counts0, Mins0);
mem_cpy((INT8U *)Pub_Buf0 + 5, &Counts0, 4, (INT8U *)Pub_Buf0, sizeof(Pub_Buf0));
mem_cpy((INT8U *)Pub_Buf0 + 9, &Mins0, 4, (INT8U *)Pub_Buf0, sizeof(Pub_Buf0));
Write_Storage_Data(EC_DI(0x03050000), (INT8U *)Pub_Buf0, 13);
Write_Storage_Data(EC_DI(0x03050001), (INT8U *)Pub_Buf0, 13);
OS_Mutex_Post(PUB_BUF0_SEM_ID);
/*
Re=Read_Storage_Data(0x03050000,Temp,Temp,sizeof(Temp));
if(0 EQ Re)
{
ASSERT(0);
Counts0 = Counts;
Mins0 = Mins;
}
else
{
Counts0 = Bcd2Hex(Temp, 3);
Mins0 = Bcd2Hex(Temp + 3, 3);
Counts0 += Counts;//Bcd2Hex(Temp + 5, 4);
Mins0 += Mins;//Bcd2Hex(Temp + 9, 4);
Hex2Bcd(Counts0, Temp, 3, Temp, sizeof(Temp));
Hex2Bcd(Mins0, Temp + 3, 3, Temp, sizeof(Temp));
}
Re=Write_Storage_Data(0x03050000, (void *)&Temp, 6);
ASSERT(1 EQ Re);
*/
//----------------------------------
//对总的失压次数和时间进行统计
if(Get_Total_Event_ID(ID_EVENT_ALL_LOSS_VOLT) EQ ID_EVENT_TOTAL_LOSS_VOL)//全失压的时间和次数是否进入总失压和次数?
{
OS_Mutex_Pend(PUB_BUF0_SEM_ID);
Len = Read_Storage_Data(EC_DI(0x10000101), (void *)Pub_Buf0, (void *)Pub_Buf0, sizeof(Pub_Buf0));
if(Len > 0)
{
mem_cpy(&Counts0, (INT8U *)Pub_Buf0 + 5, 4, &Counts0, sizeof(Counts0));
mem_cpy(&Mins0, (INT8U *)Pub_Buf0 + 9, 4, &Mins0, sizeof(Mins0));
Counts0 += Counts;
Mins0 += Mins;
Debug_Print("Total_Loss_Vol Counts:%ld, Mins:%ld", Counts0, Mins0);
mem_cpy((INT8U *)Pub_Buf0 + 5, &Counts0, 4, (INT8U *)Pub_Buf0, sizeof(Pub_Buf0));
mem_cpy((INT8U *)Pub_Buf0 + 9, &Mins0, 4, (INT8U *)Pub_Buf0, sizeof(Pub_Buf0));
Write_Storage_Data(EC_DI(0x10000101), (INT8U *)Pub_Buf0, Len);
}
OS_Mutex_Post(PUB_BUF0_SEM_ID);
}
}
//-----------------------------------------------------------------------------
//写数据时的esam权限判断和密文解密
//pSrc表示通信协议中的lc字段后面的数据
//SrcLen表示lc 字段的值
//pDst存放解密后的数据 ， ，不要管数据标示之类的东西，
//pDst_Start目标缓冲起始地址
//DstLen 告诉黄工 解密后的数据长度，
//返回值 权限正确且解密成功返回1，否则返回0
//注意：该函数传入的pSrc和pDst可能是同一地址。
INT8U Esam_Auth_Check( INT8U *pSrc, INT16U SrcLen, INT8U * DstLen)
{//二类数据修改
INT8U i,j,Block_Flag;
//INT8U Length;
INT8U DataPdi[4];
struct Far_Deal_Para_Flag_T2 Far_Deal_Para_Flag_T2;
//struct Far_645_Frame_T2 Far_645_Frame_T2;
INT8U ID_a,ID_b,ID_c,ID_d;
CPU_ESAM_CARD_Control(ESAM);
if( Select_Directry(0,0x3F,0) != OK )
{
ASSERT_FAILED();
Card_Error_State.CardErrorState.CPU_CARD_ESAM_ATR_ERR=1;
return 0;
}
//查看 身份认证有效时间有没有到
Far_Identity_Auth_Ok_Flag=!Chk_Pay_Time_Arrive();
// 身份验证没通过，不允许操作
if(Far_Identity_Auth_Ok_Flag != 1)
{
Reset_Pay_Timer(0);
ASSERT_FAILED();
return 0;
}
if( FarPrePayment.ID_Ins_Counter >=15 )
{
ASSERT_FAILED();
return 0;
}
mem_cpy(DataPdi,pSrc,4,DataPdi,4);
//Far_645_Frame_T2 = (struct Far_645_Frame_T2 *)(pSrc+4);
ID_a = *(DataPdi+3 );
ID_b = *(DataPdi+2 );
ID_c = *(DataPdi+1 );
ID_d = *(DataPdi+0 );
Block_Flag = 0x00;
for( i=0;i<S_NUM(Far_Deal_Para_List_T2);i++ ){
if(memcmp(&Far_Deal_Para_List_T2[i].Data_ID[0],&DataPdi[0],4) EQ 0 ){
break;
}
}
if( i EQ S_NUM(Far_Deal_Para_List_T2) ){
Far_Deal_Para_Flag_T2.Source_Length = 16;
Far_Deal_Para_Flag_T2.Data_ID[0] = *(DataPdi+0 );
Far_Deal_Para_Flag_T2.Data_ID[1] = *(DataPdi+1 );
Far_Deal_Para_Flag_T2.Data_ID[2] = *(DataPdi+2 );
Far_Deal_Para_Flag_T2.Data_ID[3] = *(DataPdi+3 );
// if( ( *(ID_Point+0 )>=1 && *(ID_Point+0 )<=8 ) && (*(ID_Point+1 )==0) && ((*(ID_Point+2 )==1) || (*(ID_Point+2 )==2)) )
// Far_Deal_Para_Flag_T2.TX_Length = 3;
//04 03 00 01~~fe
if( ( *(DataPdi+0 )>=1 && *(DataPdi+0 )<=0xFE ) && (*(DataPdi+1 )==0) && (*(DataPdi+2 )==3) )
Far_Deal_Para_Flag_T2.TX_Length = 4;
//04 06 03~~00 05~~00
else if( ( *(DataPdi+0 )<=0x05 ) && (*(DataPdi+1 )<=3) && (*(DataPdi+2 )==6) )
Far_Deal_Para_Flag_T2.TX_Length = 4;
// 0x04010000~0x04010008 0x04020000~0x04020008
else if( ID_a==0x04 && ( ID_b>=0x01 || ID_b<=0x02 ) && ID_c==0x00 && ID_d<=0x08 ){
Block_Flag = 0xFF;
Far_Deal_Para_Flag_T2.TX_Length = 42;
Far_Deal_Para_Flag_T2.Source_Length = 48;
}else{
ASSERT_FAILED();
return 0;
}
}
else{
for( j=0;j<LENGTH_FAR_DEAL_PARA_FLAG_T2;j++ )
*(((INT8U *)(&Far_Deal_Para_Flag_T2))+j) = *(((const INT8U *)&Far_Deal_Para_List_T2[i])+j);
}
//645协议中定义的 L字段的长度 ，应该 和 表中的定义的密文的长度 + 4 字节mac + 12字节 数据标示，密码，操作者代码 相等
//if( SrcLen != (Far_Deal_Para_Flag_T2.Source_Length+16) )
//{
// ASSERT_FAILED();
// return 0;
//}
Far_Deal_Para_Flag_T2.Source_Length = SrcLen-16;
i = *(DataPdi+2 );
i%=5;
j = Data_ID_Offset[i];
//把N1N2....Nm 写到esam中去
if( Far_Write_Esam(0x04,Update_Binary,0x80+j,0x00,Far_Deal_Para_Flag_T2.Source_Length,pSrc+LENGTH_FAR_645_FRAME_T2+4,0)!=OK)
{
FarPrePayment.Far_Error_State.CpuCardInternlAuthenticationErr=1; //这里的赋值没有任何意义
ReNew_Err_Code(DIS_CERTI_ERR);
ASSERT_FAILED();
return 0;
}
//读出长度
if( Read(0x00, Read_Binary, 0x80+j, 0x00, 1) != OK )
{
ASSERT_FAILED();
return ERR;
}
Far_Deal_Para_Flag_T2.TX_Length = receive_send_buffer[0]-4;
if( Read(0x00, Read_Binary, 0x80+j, 0x00, Far_Deal_Para_Flag_T2.TX_Length+5) != OK )
{
ASSERT_FAILED();
return ERR;
}
//判断是否数据标示正确
Reverse_data(receive_send_buffer+1,4);
if( My_Memcmp(receive_send_buffer+1,Far_Deal_Para_Flag_T2.Data_ID,4) != 0 )
{
ASSERT_FAILED();
return ERR;
}
//判断是否 是否
if( Block_Flag EQ 0 )
My_memcpyRev(pSrc+LENGTH_FAR_645_FRAME_T2+4, receive_send_buffer+5, Far_Deal_Para_Flag_T2.TX_Length);
else
{
Block_Flag = Far_Deal_Para_Flag_T2.TX_Length/3;
for( i=0;i<Block_Flag;i++ )
{
My_memcpyRev(pSrc+4+LENGTH_FAR_645_FRAME_T2+i*3, receive_send_buffer+5+i*3, 3);
}
}
///
*DstLen=Far_Deal_Para_Flag_T2.TX_Length +12;//这里只要告诉黄工 解密后的数据 实际长度即可， 不要管其他的
return 1;
}
