712 lines
16 KiB
C
712 lines
16 KiB
C
|
|
#define _IN_NORPARAS_C
|
|
#include "norparas.h"
|
|
|
|
|
|
#if (MAX_PARA_BLOCK > 0)
|
|
#include "norflash.h"
|
|
#include "inout.h"
|
|
#include "shell.h"
|
|
#include "delay.h"
|
|
|
|
//----------------------------------------------------
|
|
|
|
#define NORPARA_BEG_ADDR (SNF_PARAS_BEGIN) // 参数块起始地址,每个参数块占一个扇区,最大共16个参数块
|
|
|
|
#define NP_BLOCK_BYTES SNF_BYTES_PER_PAGE // 每个参数页大小(一页)
|
|
#define NP_SAVE_BYTES_PER_BLOCK SNF_BYTES_PER_SEC // 每个参数块大小(一个扇区)
|
|
#define NP_SAVE_BLOCKS_PER_SEC 16 // 每个参数块页数,第一页存储参数页有效标志,实际共15个页用于存储参数
|
|
|
|
|
|
#define GET_NORPARA_BLOCK_ADDR(bidx) (NORPARA_BEG_ADDR+(bidx)*NP_SAVE_BYTES_PER_BLOCK) // 获取参数块起始地址
|
|
|
|
//----------------------------------------------------
|
|
|
|
typedef struct
|
|
{
|
|
int paraEn; // 参数块有效标志
|
|
NorParaBlock norParaBlock; // 参数块数据
|
|
s32 * pParaList; // 参数列表(包含参数类型,最小最大值和默认值)
|
|
char * pParasName; // 参数名称列表
|
|
|
|
// 存储
|
|
u32 pageFlag[NP_SAVE_BLOCKS_PER_SEC]; // 参数页标志
|
|
|
|
}NorParaBlockCtrl;
|
|
|
|
NorParaBlockCtrl g_norParaBlockList[MAX_PARA_BLOCK];
|
|
|
|
//----------------------------------------------------
|
|
|
|
const char * SHOWP_STR =
|
|
"\t" " 显示或加载参数 " "\r\n"
|
|
"\t" " p1 p2" "\r\n"
|
|
"\t" " 0 0 显示全部参数 " "\r\n"
|
|
"\t" " b001 0 显示参数块b " "\r\n"
|
|
"\t" " b002 0 参数块b加载默认参数 " "\r\n"
|
|
"\t" " b003 0 参数块b重新加载参数 " "\r\n"
|
|
;
|
|
|
|
void ShowPara(char * para1, char * para2);
|
|
|
|
const char * SETP_STR =
|
|
"\t" "设置参数 " "\r\n"
|
|
"\t" " p1 p2" "\r\n"
|
|
"\t" " b00x val 设置参数块b, 参数ID x, 参数值 val " "\r\n"
|
|
"\t" " 10b000 0 保存参数块b " "\r\n"
|
|
;
|
|
|
|
void SetPara(char * para1, char * para2);
|
|
//----------------------------------------------------
|
|
|
|
void InitNorParas(void)
|
|
{
|
|
static int g_inited = 0;
|
|
|
|
if (g_inited == 0)
|
|
{
|
|
g_inited = 1;
|
|
InitNorSpi(); // 初始化 nor flash 访问 SPI
|
|
SNFlashInit(SetNorSpiNssOn, SetNorSpiNssOff, NorSpiReadByte, NorSpiWriteByte); // 初始化nor flash 并注册读写函数
|
|
|
|
// 参数块初始化
|
|
for(int i = 0; i < MAX_PARA_BLOCK; i++)
|
|
{
|
|
memset(&g_norParaBlockList[i], 0, sizeof(NorParaBlockCtrl));
|
|
LoadNorParas(i);
|
|
}
|
|
AddShellCmd("SHOWPARA", SHOWP_STR, ShowPara);
|
|
AddShellCmd("SETPARA", SETP_STR, SetPara);
|
|
}
|
|
}
|
|
|
|
// 获取参数块有效标志
|
|
int GetNorParaEn(int bIdx)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return g_norParaBlockList[bIdx].paraEn;
|
|
}
|
|
|
|
// 加载参数页有效标志
|
|
int LoadParaPageFlag(int bIdx)
|
|
{
|
|
NorParaBlockCtrl * pCtrl;
|
|
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
pCtrl = &g_norParaBlockList[bIdx];
|
|
|
|
return DatFlashRdData(GET_NORPARA_BLOCK_ADDR(bIdx), (u8 *)(&pCtrl->pageFlag[0]), NP_SAVE_BLOCKS_PER_SEC*sizeof(u32));
|
|
}
|
|
|
|
// 保存参数页有效标志
|
|
int SaveParaPageFlag(int bIdx)
|
|
{
|
|
NorParaBlockCtrl * pCtrl;
|
|
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
pCtrl = &g_norParaBlockList[bIdx];
|
|
|
|
return DatFlashWrData(GET_NORPARA_BLOCK_ADDR(bIdx), (u8 *)(&pCtrl->pageFlag[0]), NP_SAVE_BLOCKS_PER_SEC*sizeof(u32));
|
|
}
|
|
|
|
// 设置参数页有效标志
|
|
int SetParaPageFlagValue(int bIdx, int pIdx, int enFlag)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK || pIdx < 0 || pIdx >= NP_SAVE_BLOCKS_PER_SEC)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (enFlag == 0)
|
|
{
|
|
g_norParaBlockList[bIdx].pageFlag[pIdx] = 0; // 失效,0xffffffff未使用页
|
|
}
|
|
else
|
|
{
|
|
g_norParaBlockList[bIdx].pageFlag[pIdx] = PARA_VALID+pIdx; // 有效
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// 从参数页标志得到当前有效参数页
|
|
int GetSaveIdxFromPageFlag(int bIdx)
|
|
{
|
|
int i;
|
|
NorParaBlockCtrl * pCtrl;
|
|
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
pCtrl = &g_norParaBlockList[bIdx];
|
|
|
|
for(i = 1; i < NP_SAVE_BLOCKS_PER_SEC; i++)
|
|
{
|
|
if (pCtrl->pageFlag[i] == PARA_VALID+i)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -2;
|
|
}
|
|
|
|
// 得到下一个未使用页
|
|
int GetNextSaveIdxFromPageFlag(int bIdx)
|
|
{
|
|
int i;
|
|
NorParaBlockCtrl * pCtrl;
|
|
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
pCtrl = &g_norParaBlockList[bIdx];
|
|
|
|
for (i = 1; i < NP_SAVE_BLOCKS_PER_SEC; i++)
|
|
{
|
|
if (pCtrl->pageFlag[i] == 0xffffffff)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -2;
|
|
}
|
|
|
|
// 读取参数
|
|
// bIdx:参数块ID
|
|
// return: -1:参数加载错误,所有参数页都被废弃,未找到有效参数
|
|
// 0:正确返回值
|
|
int LoadNorParas(int bIdx)
|
|
{
|
|
u32 addr; //
|
|
NorParaBlockCtrl * pCtrl;
|
|
int idx, rslt;
|
|
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
pCtrl = &g_norParaBlockList[bIdx];
|
|
|
|
memset(pCtrl, 0, sizeof(NorParaBlockCtrl));
|
|
|
|
// 读入扇区存储参数有效标志
|
|
rslt = LoadParaPageFlag(bIdx);
|
|
if (rslt < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
idx = GetSaveIdxFromPageFlag(bIdx); // 得到当前有效参数页id
|
|
|
|
if (idx < 0)
|
|
{
|
|
printf("load nor para error, code=%d\r\n", idx);
|
|
return -1;
|
|
}
|
|
|
|
printf("load nor para block %d, page is %d\r\n", bIdx, idx);
|
|
|
|
addr = GET_NORPARA_BLOCK_ADDR(bIdx) + (idx * NP_BLOCK_BYTES);
|
|
DatFlashRdData(addr, (u8*)&pCtrl->norParaBlock, sizeof(NorParaBlock));
|
|
|
|
g_norParaBlockList[bIdx].paraEn = PARA_VALID; // 参数有效
|
|
|
|
return 0;
|
|
}
|
|
|
|
// 保存参数
|
|
//bIdx 定义的参数块ID
|
|
int SaveNorParas(int bIdx)
|
|
{
|
|
u32 addr;
|
|
int cidx, nidx;
|
|
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
cidx = GetSaveIdxFromPageFlag(bIdx);
|
|
nidx = GetNextSaveIdxFromPageFlag(bIdx);
|
|
if (cidx < 0)
|
|
{
|
|
cidx = 0;
|
|
}
|
|
|
|
if (nidx < 0) // 超出扇区
|
|
{
|
|
printf("overflow, erase 4k\r\n");
|
|
DatFlash4kErase(GET_NORPARA_BLOCK_ADDR(bIdx), 1); // 擦除整个扇区
|
|
LoadParaPageFlag(bIdx);
|
|
cidx = 0;
|
|
nidx = GetNextSaveIdxFromPageFlag(bIdx);
|
|
}
|
|
|
|
if (nidx < 0) //
|
|
{
|
|
printf("SaveNorParas error\r\n");
|
|
return -2;
|
|
}
|
|
|
|
// 将参数存储在之后的页中
|
|
addr = GET_NORPARA_BLOCK_ADDR(bIdx) + ((nidx) * NP_BLOCK_BYTES);
|
|
DatFlashWrDataWithErase(addr, (u8 *)&g_norParaBlockList[bIdx].norParaBlock, sizeof(NorParaBlock));
|
|
|
|
SetParaPageFlagValue(bIdx, nidx, 1); // 设置新参数存储页有效
|
|
|
|
SetParaPageFlagValue(bIdx, cidx, 0); // 废弃旧的参数存储页
|
|
|
|
SaveParaPageFlag(bIdx); // 保存参数页标志
|
|
|
|
g_norParaBlockList[bIdx].paraEn = PARA_VALID; // 参数有效
|
|
|
|
printf("save nor para successful, page is %d \r\n", nidx);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 获取并返回参数块
|
|
NorParaBlock * GetNorParaBlock(int bIdx)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return &g_norParaBlockList[bIdx].norParaBlock;
|
|
}
|
|
|
|
// 设置参数名称
|
|
void SetNorParaNameString(int bIdx, void * pName)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK )
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_norParaBlockList[bIdx].pParasName = pName;
|
|
}
|
|
|
|
// 设置参数列表(参数类型,最小最大值默认值)
|
|
void SetNorParaList(int bIdx, void * pPara)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK )
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_norParaBlockList[bIdx].pParaList = pPara;
|
|
}
|
|
|
|
// 加载默认参数
|
|
void LoadNorDefPara(int bIdx)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK || g_norParaBlockList[bIdx].pParaList == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for(int i = 0; i < PARA_NUM_PER_BLK; i++)
|
|
{
|
|
int offset = i * 4 + 3;
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[i] = * ( g_norParaBlockList[bIdx].pParaList + offset );
|
|
}
|
|
}
|
|
|
|
|
|
// 参数范围检测(检测参数块内的全部参数)
|
|
void CheckParaRange(int bIdx)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK || g_norParaBlockList[bIdx].pParaList == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for(int i = 0; i < PARA_NUM_PER_BLK; i++)
|
|
{
|
|
int paratype, minOffset, maxOffset; // 参数类型,最小最大值指针偏移量
|
|
paratype = (i * 4);
|
|
minOffset = (i * 4 + 1);
|
|
maxOffset = (i * 4 + 2);
|
|
if ((*(g_norParaBlockList[bIdx].pParaList + paratype)) == PTYPE_S)
|
|
{
|
|
if (g_norParaBlockList[bIdx].norParaBlock.buff[i] < (*(g_norParaBlockList[bIdx].pParaList + minOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[i] = (*( g_norParaBlockList[bIdx].pParaList + minOffset));
|
|
printf("less than min, equal min, block %d, id is %d\r\n", bIdx, i+1);
|
|
}
|
|
else if (g_norParaBlockList[bIdx].norParaBlock.buff[i] > (*( g_norParaBlockList[bIdx].pParaList + maxOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[i] = (*( g_norParaBlockList[bIdx].pParaList + maxOffset));
|
|
printf("more than max, equal max, block %d, id is %d\r\n", bIdx, i+1);
|
|
}
|
|
}
|
|
else if ((*(g_norParaBlockList[bIdx].pParaList + paratype)) == PTYPE_U)
|
|
{
|
|
if ((u32)g_norParaBlockList[bIdx].norParaBlock.buff[i] < (u32)(*(g_norParaBlockList[bIdx].pParaList + minOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[i] = (*( g_norParaBlockList[bIdx].pParaList + minOffset));
|
|
printf("less than min, equal min, block %d, id is %d\r\n", bIdx, i+1);
|
|
}
|
|
else if ((u32)g_norParaBlockList[bIdx].norParaBlock.buff[i] > (u32)(*( g_norParaBlockList[bIdx].pParaList + maxOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[i] = (*( g_norParaBlockList[bIdx].pParaList + maxOffset));
|
|
printf("more than max, equal max, block %d, id is %d\r\n", bIdx, i+1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 参数范围检测(检测参数块内的某个参数)
|
|
void CheckAParaRange(int bIdx, int id)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK || g_norParaBlockList[bIdx].pParaList == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (id >= 0 && id < PARA_NUM_PER_BLK)
|
|
{
|
|
int paratype, minOffset, maxOffset; // 参数类型,最小最大值指针偏移量
|
|
paratype = (id * 4);
|
|
minOffset = (id * 4 + 1);
|
|
maxOffset = (id * 4 + 2);
|
|
if ((*(g_norParaBlockList[bIdx].pParaList + paratype)) == PTYPE_S)
|
|
{
|
|
if (g_norParaBlockList[bIdx].norParaBlock.buff[id] < (*( g_norParaBlockList[bIdx].pParaList + minOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[id] = (*( g_norParaBlockList[bIdx].pParaList + minOffset));
|
|
printf("less than min, equal min\r\n");
|
|
}
|
|
else if (g_norParaBlockList[bIdx].norParaBlock.buff[id] > (*( g_norParaBlockList[bIdx].pParaList + maxOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[id] = (*( g_norParaBlockList[bIdx].pParaList + maxOffset));
|
|
printf("more than max, equal max\r\n");
|
|
}
|
|
}
|
|
else if ((*(g_norParaBlockList[bIdx].pParaList + paratype)) == PTYPE_U)
|
|
{
|
|
if ((u32)g_norParaBlockList[bIdx].norParaBlock.buff[id] < (u32)(*( g_norParaBlockList[bIdx].pParaList + minOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[id] = (*( g_norParaBlockList[bIdx].pParaList + minOffset));
|
|
printf("less than min, equal min\r\n");
|
|
}
|
|
else if ((u32)g_norParaBlockList[bIdx].norParaBlock.buff[id] > (u32)(*( g_norParaBlockList[bIdx].pParaList + maxOffset)) )
|
|
{
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[id] = (*( g_norParaBlockList[bIdx].pParaList + maxOffset));
|
|
printf("more than max, equal max\r\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 获取一个参数
|
|
s32 GetANorPara(int bIdx, int id)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (GetNorParaEn(bIdx) == PARA_VALID)
|
|
{
|
|
int idx = id - 1;
|
|
|
|
if (idx >= 0 && idx < PARA_NUM_PER_BLK)
|
|
{
|
|
return g_norParaBlockList[bIdx].norParaBlock.buff[idx];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// 设置一个参数
|
|
// 该函数不提供保存功能,需参数设置完成后手动保存
|
|
// 注:norflash不宜频繁写
|
|
void SetANorPara(int bIdx, int id, s32 val)
|
|
{
|
|
if (bIdx < 0 || bIdx >= MAX_PARA_BLOCK )
|
|
{
|
|
return;
|
|
}
|
|
|
|
char * pInfo = NULL;
|
|
int idx = id - 1;
|
|
|
|
if (idx >= 0 && idx < PARA_NUM_PER_BLK)
|
|
{
|
|
if ((*(g_norParaBlockList[bIdx].pParaList + idx*4)) == PTYPE_S)
|
|
{
|
|
s32 old;
|
|
|
|
pInfo = (g_norParaBlockList[bIdx].pParasName+(idx)*PARA_STR_LEN);
|
|
|
|
printf("set para block %d\r\n", bIdx+1);
|
|
|
|
old = g_norParaBlockList[bIdx].norParaBlock.buff[idx];
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[idx] = val;
|
|
|
|
CheckAParaRange(bIdx, idx);
|
|
|
|
if (pInfo == NULL)
|
|
{
|
|
pInfo = "";
|
|
}
|
|
|
|
printf("%d. (%s) = %d, oldvalue=%d\r\n", (id), pInfo, val, old);
|
|
}
|
|
else
|
|
{
|
|
u32 old;
|
|
|
|
pInfo = (g_norParaBlockList[bIdx].pParasName+(idx)*PARA_STR_LEN);
|
|
|
|
printf("set para block %d\r\n", bIdx+1);
|
|
|
|
old = (u32)g_norParaBlockList[bIdx].norParaBlock.buff[idx];
|
|
g_norParaBlockList[bIdx].norParaBlock.buff[idx] = val;
|
|
|
|
CheckAParaRange(bIdx, idx);
|
|
|
|
if (pInfo == NULL)
|
|
{
|
|
pInfo = "";
|
|
}
|
|
|
|
printf("%d. (%s) = %d, oldvalue=%d\r\n", (id), pInfo, (u32)val, old);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* p1 p2
|
|
* 1001 val // 设置参数块1,参数ID 1,参数值val
|
|
* 1002 val // 设置参数块1,参数ID 2,参数值val
|
|
......
|
|
* 2001 val // 设置参数块2,参数ID 1,参数值val
|
|
* 2002 val // 设置参数块2,参数ID 2,参数值val //不提供保存功能
|
|
......
|
|
* 101000 // 保存参数块1
|
|
* 102000 // 保存参数块2
|
|
*/
|
|
|
|
void SetPara(char * para1, char * para2)
|
|
{
|
|
int p1, p2, p3;
|
|
|
|
if (para1 == NULL || para2 == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
printf("para1=%s, para2=%s\r\n", para1, para2);
|
|
|
|
p1 = 0;
|
|
p2 = 0;
|
|
if (strcmp(para1, "") != 0)
|
|
{
|
|
p1 = atoi(para1);
|
|
}
|
|
if (strcmp(para2, "") != 0)
|
|
{
|
|
p2 = atoi(para2);
|
|
}
|
|
if (p1 == p2)
|
|
{
|
|
}
|
|
|
|
p3 = p1 / 1000; // 参数块id
|
|
p1 = p1 % 1000; // 参数id
|
|
// p2:参数值
|
|
|
|
if (p3 > 0 && p3 <= MAX_PARA_BLOCK)
|
|
{
|
|
SetANorPara(p3-1, p1, p2);
|
|
}
|
|
else if (p3 > 100 && p3 <= 116)
|
|
{
|
|
p3 -= 101;
|
|
printf("save block %d\r\n", p3+1);
|
|
SaveNorParas(p3);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* p1 p2
|
|
* // 显示全部参数
|
|
* 1001 // 显示参数块1
|
|
* 2001 // 显示参数块2
|
|
* 1002 // 参数块1加载默认参数
|
|
* 2002 // 参数块2加载默认参数
|
|
* 1003 // 参数块1重新加载参数
|
|
* 2003 // 参数块2重新加载参数
|
|
*/
|
|
void ShowPara(char * para1, char * para2)
|
|
{
|
|
int p1, p2, p3;
|
|
|
|
if (para1 == NULL || para2 == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
printf("para1=%s, para2=%s\r\n", para1, para2);
|
|
|
|
p1 = 0;
|
|
p2 = 0;
|
|
if (strcmp(para1, "") != 0)
|
|
{
|
|
p1 = atoi(para1);
|
|
}
|
|
if (strcmp(para2, "") != 0)
|
|
{
|
|
p2 = atoi(para2);
|
|
}
|
|
if (p1 == p2)
|
|
{
|
|
}
|
|
p3 = p1 / 1000; // 参数块id
|
|
p1 = p1 % 1000; // 功能码
|
|
// p2: 参数ID
|
|
|
|
if (p3 <= MAX_PARA_BLOCK)
|
|
{
|
|
switch(p1)
|
|
{
|
|
case 0:
|
|
{
|
|
// 显示全部块参数
|
|
for (int j = 0; j < MAX_PARA_BLOCK; j++)
|
|
{
|
|
printf("\r\npara block %d:\r\n", j+1);
|
|
|
|
if (g_norParaBlockList[j].pParasName == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for(int i = 0; i < PARA_NUM_PER_BLK; i++)
|
|
{
|
|
char * pStr;
|
|
pStr = g_norParaBlockList[j].pParasName + (i*PARA_STR_LEN);
|
|
if (pStr == NULL)
|
|
{
|
|
pStr = "";
|
|
}
|
|
|
|
if ( strcmp(pStr, "") != 0 )
|
|
{
|
|
if ((*(g_norParaBlockList[j].pParaList+i*4)) == PTYPE_S)
|
|
{
|
|
printf("%d. (%s) val=%d, min=%d, max=%d, def=%d\r\n", i+1, pStr,
|
|
GetANorPara(j, i+1),
|
|
*(g_norParaBlockList[j].pParaList+ i*4+1),
|
|
*(g_norParaBlockList[j].pParaList+ i*4+2),
|
|
*(g_norParaBlockList[j].pParaList+ i*4+3) );
|
|
}
|
|
else
|
|
{
|
|
printf("%d. (%s) val=%d, min=%d, max=%d, def=%d\r\n", i+1, pStr,
|
|
(u32)GetANorPara(j, i+1),
|
|
(u32)(*(g_norParaBlockList[j].pParaList+ i*4+1)),
|
|
(u32)(*(g_norParaBlockList[j].pParaList+ i*4+2)),
|
|
(u32)(*(g_norParaBlockList[j].pParaList+ i*4+3)) );
|
|
}
|
|
}
|
|
DelayMs(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
// 显示某个参数块
|
|
printf("\r\npara block %d:\r\n", p3);
|
|
|
|
if (g_norParaBlockList[p3-1].pParasName != NULL)
|
|
{
|
|
for(int i = 0; i < PARA_NUM_PER_BLK; i++)
|
|
{
|
|
char * pStr;
|
|
pStr = g_norParaBlockList[p3-1].pParasName + (i*PARA_STR_LEN);
|
|
if (pStr == NULL)
|
|
{
|
|
pStr = "";
|
|
}
|
|
|
|
if ( strcmp(pStr, "") != 0 )
|
|
{
|
|
if ((*(g_norParaBlockList[j].pParaList+i*4)) == PTYPE_S)
|
|
{
|
|
printf("%d. (%s) val=%d, min=%d, max=%d, def=%d\r\n", i+1, pStr,
|
|
GetANorPara(p3-1, i+1),
|
|
*(g_norParaBlockList[p3-1].pParaList+ i*4+1),
|
|
*(g_norParaBlockList[p3-1].pParaList+ i*4+2),
|
|
*(g_norParaBlockList[p3-1].pParaList+ i*4+3) );
|
|
}
|
|
else
|
|
{
|
|
printf("%d. (%s) val=%d, min=%d, max=%d, def=%d\r\n", i+1, pStr,
|
|
(u32)GetANorPara(p3-1, i+1),
|
|
(u32)(*(g_norParaBlockList[p3-1].pParaList+ i*4+1)),
|
|
(u32)(*(g_norParaBlockList[p3-1].pParaList+ i*4+2)),
|
|
(u32)(*(g_norParaBlockList[p3-1].pParaList+ i*4+3)) );
|
|
}
|
|
}
|
|
DelayMs(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
int bidx = p3 - 1;
|
|
// 加载默认参数
|
|
if (bidx >= 0)
|
|
{
|
|
printf("load def para block %d:\r\n", p3);
|
|
LoadNorDefPara(bidx);
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
int bidx = p3 - 1;
|
|
if (bidx >= 0)
|
|
{
|
|
printf("load para block %d:\r\n", p3);
|
|
// 重新加载参数
|
|
LoadNorParas(bidx);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|