ALERROR CGroupOfGenerators::LoadFromXML (SDesignLoadCtx &Ctx, CXMLElement *pDesc)
// LoadFromXML
//
// Load from XML
{
int i;
ALERROR error;
// Load content elements
m_Table.InsertEmpty(pDesc->GetContentElementCount());
for (i = 0; i < m_Table.GetCount(); i++)
{
CXMLElement *pEntry = pDesc->GetContentElement(i);
m_Table[i].iChance = pEntry->GetAttributeInteger(CHANCE_ATTRIB);
if (m_Table[i].iChance == 0)
m_Table[i].iChance = 100;
CString sCount = pEntry->GetAttribute(COUNT_ATTRIB);
if (sCount.IsBlank())
m_Table[i].Count = DiceRange(0, 0, 1);
else
m_Table[i].Count.LoadFromXML(sCount);
if (error = IItemGenerator::CreateFromXML(Ctx, pEntry, &m_Table[i].pItem))
return error;
}
// See if we force an average value
CString sAttrib;
if (pDesc->FindAttribute(LEVEL_VALUE_ATTRIB, &sAttrib))
{
TArray<int> Values;
ParseIntegerList(sAttrib, 0, &Values);
m_AverageValue.InsertEmpty(MAX_ITEM_LEVEL + 1);
m_AverageValue[0] = 0;
for (i = 0; i < Values.GetCount(); i++)
m_AverageValue[i + 1] = Values[i];
for (i = Values.GetCount() + 1; i <= MAX_ITEM_LEVEL; i++)
m_AverageValue[i] = 0;
}
else if (pDesc->FindAttribute(VALUE_ATTRIB, &sAttrib))
{
int iValue = strToInt(sAttrib, 0);
m_AverageValue.InsertEmpty(MAX_ITEM_LEVEL + 1);
m_AverageValue[0] = 0;
for (i = 1; i <= MAX_ITEM_LEVEL; i++)
m_AverageValue[i] = iValue;
}
return NOERROR;
}
void NoiseFloorCommand(int client)
{
int nfc[MCHAIN],nfe[MCHAIN];
int ip, np;
int error;
int attempt;
int margin;
int index;
int code;
int timeout;
int ngot;
int nf[2*MCHAIN];
int nfmany;
char buffer[MBUFFER];
char *name;
int frequency;
int ht40;
int rxchain;
int reset;
int bandwidth;
//
// prepare beginning of error message in case we need to use it
//
error=0;
timeout= 100;
nfmany=1;
nf[0]=-110;
margin=MERROR;
attempt=MATTEMPT;
frequency= -1;
ht40=2;
bandwidth=BW_AUTOMATIC;
rxchain=0x7;
reset=0;
//
// parse arguments and do it
//
np=CommandParameterMany();
for(ip=0; ip<np; ip++)
{
name=CommandParameterName(ip);
index=ParameterSelectIndex(name,NoiseFloorParameter,sizeof(NoiseFloorParameter)/sizeof(NoiseFloorParameter[0]));
if(index>=0)
{
code=NoiseFloorParameter[index].code;
switch(code)
{
case LinkParameterFrequency:
ngot=ParseIntegerList(ip,name,&frequency,&NoiseFloorParameter[index]);
if(ngot<=0)
{
error++;
}
break;
case LinkParameterHt40:
ngot=ParseIntegerList(ip,name,&ht40,&NoiseFloorParameter[index]);
if(ngot<=0)
{
error++;
}
else
{
switch(ht40){
case 0:
bandwidth=BW_HT20;
break;
case 1:
bandwidth=BW_HT40_PLUS;
break;
case -1:
bandwidth=BW_HT40_MINUS;
break;
case 2:
bandwidth=BW_AUTOMATIC;
break;
default:
error++;
break;
}
}
break;
case LinkParameterChain:
case LinkParameterRxChain:
ngot=ParseIntegerList(ip,name,&rxchain,&NoiseFloorParameter[index]);
if(ngot<=0)
{
error++;
}
break;
case LinkParameterReset:
ngot=ParseIntegerList(ip,name,&reset,&NoiseFloorParameter[index]);
if(ngot<=0)
{
error++;
}
break;
case NoiseFloorValue:
nfmany=ParseInteger(ip,name,2*MCHAIN,nf);
if(nfmany<=0)
{
error++;
}
break;
case NoiseFloorTimeout:
ngot=ParseInteger(ip,name,1,&timeout);
if(ngot<=0)
{
error++;
}
break;
case NoiseFloorMargin:
ngot=ParseInteger(ip,name,1,&margin);
if(ngot<=0)
{
error++;
}
break;
case NoiseFloorAttempt:
ngot=ParseInteger(ip,name,1,&attempt);
if(ngot<=0)
{
error++;
}
break;
case LinkParameterBandwidth:
ngot=ParseIntegerList(ip,name,&bandwidth,&NoiseFloorParameter[index]);
if(ngot<=0)
{
error++;
}
break;
default:
ErrorPrint(ParseBadParameter,name);
error++;
break;
}
}
else
{
error++;
ErrorPrint(ParseBadParameter,name);
}
}
if(nfmany<=0)
{
SendError(client,"target noise floor value is required.");
error++;
}
if(reset)
{
if(frequency<=0)
{
SendError(client,"frequency is required.");
error++;
}
}
if(attempt>0 && (attempt%2)==0)
{
attempt++;
}
//
// do it
//
if(error==0)
{
//
// if there's no card loaded, return error
//
if(CardCheckAndLoad(-1)!=0)
{
ErrorPrint(CardNoneLoaded);
return;
}
if(frequency>0)
{
error=CardResetIfNeeded(frequency,rxchain,rxchain,reset,bandwidth);
if(error!=0)
{
return;
}
}
error=NoiseFloorDo(frequency,nf,nfmany,margin,attempt,timeout,0,nfc,nfe,MCHAIN);
if(error!=0)
{
SformatOutput(buffer,MBUFFER-1,"Noise Floor Calibration error = %d",error);
buffer[MBUFFER-1]=0;
SendError(client,buffer);
}
}
SendDone(client);
}
//
// interpolates into the stored data structure and returns the value that will be used
//
void TargetPowerGetCommand(int client)
{
int np, ip;
char *name;
char buffer[MBUFFER];
int error;
int parseStatus=0, nc=0, lc=0;
int index;
int code;
int it, nfrequency, frequency[MLOOP];
int ir, nrate, rate[MRATE], nvrate, vrate[MRATE];
double tp;
int rlegacy,rht20,rht40,rerror,ngot,extra;
int nvalue;
//
// install default parameter values
//
error=0;
//
// a bunch of frequencies
//
nfrequency=1;
frequency[0]= 2412;
//
// all rates
//
nrate=1;
rate[0]=RATE_INDEX_6;
//
// parse arguments and do it
//
np=CommandParameterMany();
for(ip=0; ip<np; ip++)
{
name=CommandParameterName(ip);
index=ParameterSelectIndex(name,TargetPowerParameter,sizeof(TargetPowerParameter)/sizeof(TargetPowerParameter[0]));
if(index>=0)
{
code=TargetPowerParameter[index].code;
switch(code)
{
case LinkParameterFrequency:
nfrequency=ParseIntegerList(ip,name,frequency,&TargetPowerParameter[index]);
if(nfrequency<=0)
{
error++;
}
break;
case LinkParameterRate:
nvalue=CommandParameterValueMany(ip);
//
// check if it might be the old mask codes
//
rerror=1;
if(nvalue==3)
{
rerror=0;
rlegacy=0;
rht20=0;
rht40=0;
ngot=SformatInput(CommandParameterValue(ip,0)," %x %1c",&rlegacy,&extra);
if(ngot!=1)
{
rerror++;
}
if(nvalue>=2)
{
ngot=SformatInput(CommandParameterValue(ip,1)," %x %1c",&rht20,&extra);
if(ngot!=1)
{
rerror++;
}
}
if(nvalue>=3)
{
ngot=SformatInput(CommandParameterValue(ip,2)," %x %1c",&rht40,&extra);
if(ngot!=1)
{
rerror++;
}
}
if(rerror<=0)
{
nrate=RateCount(rlegacy,rht20,rht40,rate);
UserPrint("Note: Please use rate names as possible. Rate masks will be obsolete in the future.\n");
}
}
if(rerror!=0)
{
nrate=ParseIntegerList(ip,name,rate,&TargetPowerParameter[index]);
if(nrate<=0)
{
error++;
}
else
{
nrate=RateExpand(rate,nrate);
nrate=vRateExpand(rate,nrate);
}
}
break;
default:
ErrorPrint(ParseBadParameter,name);
error++;
break;
}
}
else
{
error++;
ErrorPrint(ParseBadParameter,name);
}
}
if(error<=0)
{
//
// check if card is loaded
//
if(!CardValid())
{
ErrorPrint(CardNoneLoaded);
}
else
{
ErrorPrint(NartDataHeader,"|tp|frequency|rate||target|");
for(it=0; it<nfrequency; it++)
{
for(ir=0; ir<nrate; ir++)
{
DeviceTargetPowerGet(frequency[it],rate[ir],&tp);
if (IS_vRate(rate[ir]))
SformatOutput(buffer,MBUFFER-1,"|tp|%d|%s||%.1lf|",frequency[it],vRateStrAll[rate[ir]-numRateCodes],tp);
else
SformatOutput(buffer,MBUFFER-1,"|tp|%d|%s||%.1lf|",frequency[it],rateStrAll[rate[ir]],tp);
buffer[MBUFFER-1]=0;
ErrorPrint(NartData,buffer);
}
}
}
}
SendDone(client);
}
//
// interpolates into the stored data structure and returns the value that will be used
//
void NoiseFloorGetCommand(int client)
{
int np, ip;
char *name;
char buffer[MBUFFER];
int error;
int index;
int code;
int it, nfrequency, frequency[MLOOP];
int nchain, chain;
int nf, nfp;
int ich;
//
// prepare beginning of error message in case we need to use it
//
error=0;
nfrequency=1;
frequency[0]= 2412;
nchain=1;
chain= 0x7;
//
// parse arguments and do it
//
np=CommandParameterMany();
for(ip=0; ip<np; ip++)
{
name=CommandParameterName(ip);
index=ParameterSelectIndex(name,NoiseFloorGetParameter,sizeof(NoiseFloorGetParameter)/sizeof(NoiseFloorGetParameter[0]));
if(index>=0)
{
code=NoiseFloorGetParameter[index].code;
switch(code)
{
case LinkParameterFrequency:
nfrequency=ParseIntegerList(ip,name,frequency,&NoiseFloorGetParameter[index]);
if(nfrequency<=0)
{
error++;
}
break;
case LinkParameterChain:
nchain=ParseHexList(ip,name,&chain,&NoiseFloorGetParameter[index]);
if(nchain<=0)
{
error++;
}
break;
default:
ErrorPrint(ParseBadParameter,name);
error++;
break;
}
}
else
{
error++;
ErrorPrint(ParseBadParameter,name);
}
}
if(error<=0)
{
//
// check if card is loaded
//
if(!CardValid())
{
ErrorPrint(CardNoneLoaded);
}
else
{
ErrorPrint(NartDataHeader,"|nfg|frequency|chain||nf|nfp|");
for(it=0; it<nfrequency; it++)
{
for(ich=0; ich<3; ich++)
{
if((1<<ich)&chain)
{
nf=DeviceNoiseFloorGet(frequency[it], ich);
nfp=DeviceNoiseFloorPowerGet(frequency[it], ich);
SformatOutput(buffer,MBUFFER-1,"|nfg|%d|%x||%d|%d|",frequency[it],1<<ich,nf,nfp);
buffer[MBUFFER-1]=0;
ErrorPrint(NartData,buffer);
}
}
}
}
}
SendDone(client);
}