int borrarPersona(ePersona lista[], int tam)
{
int i;
int dni;
char respuesta;
printf("Ingrese el DNI de la persona a borrar: ");
scanf("%d", &dni);
i = buscarPorDni(lista,tam,dni);
if(i == -1)
{
return -1;
}
else
{
system("cls");
printf("Nombre: %s",lista[i].nombre);
printf("\nDNI: %d",lista[i].dni);
printf("\nEdad: %d",lista[i].edad);
getSN(&respuesta,"\nEsta seguro que desea eliminar? s/n","\nError. Opcion no valida");
if(respuesta == 's')
{
lista[i].estado = 0;
return 0;
}
return 1;
}
}
int main() {
//Boltzmann constant Units of [eV/K]
static const double kB = 8.6173324E-5;
//Planck constant Units of [eV s]
static const double hbar = 6.58211928E-16;
//printf("Value of fracSeed %e.\n",fracSeed);
int attempts = 15;
int rv;
double SiteDistance = 1; //units of [nm]
double AttemptToHop = 1E-13;
double gamma = 2; //Units of [1/nm]
int XElecOn = 1;
int YElecOn = 0;
int ZElecOn = 0;
double reOrgEnergy = 1;
double KT = 1;
double MarcusJ0 = pow( AttemptToHop*hbar*pow(4*reOrgEnergy*kB*300/M_PI,1/2),1/2);
//Calculating full Marcus Coefficient;
double MarcusCoeff = pow(MarcusJ0,2)/hbar * pow(M_PI/(4*reOrgEnergy*KT),1/2)*exp(2*gamma*SiteDistance);
/////////////////////////////////////////////////////////////////////////////////////////////////
//There should be no clusters
//Case Study one clusters in the center Periodic
int OrderLT;
int OrderHT;
int MidPtsTotalT;
int PeriodicXT = 1;
int PeriodicYT = 1;
int PeriodicZT = 1;
int XElecOnT = 1;
int YElecOnT = 0;
int ZElecOnT = 0;
SNarray snAT = newSNarray( 3,4,3);
//Create an artificial trap in snAT which in increment length is
//length 0-2 width 0-3 and height 0-2
SiteNode snT = getSN(snAT,1,1,1);
//printSNarray(snAT);
rv = setEnergy(snT, -3);
assert(rv==0);
snT = getSN(snAT,1,2,1);
rv = setEnergy(snT, -3);
assert(rv==0);
//printSNarray(snAT);
//Testing Periodic x,y and z 0 biasX 0 biasY 0 biasZ KT=1 and reOrgEnergy=1
printf("\nCase Study T Periodic Conditions\n");
matrix mtxT = CalculateAllHops(snAT, 0,0,0, 1,1, SiteDistance,AttemptToHop,gamma,PeriodicXT, PeriodicYT, PeriodicZT);
//printMatrix(mtxT);
//Sorts all the data into midpoints
ArbArray mpAT = MPsort( &OrderLT, &OrderHT, &MidPtsTotalT, mtxT, snAT, PeriodicXT, PeriodicYT, PeriodicZT);
//Sorts midpoints into Nodes in link lists. Each element of mpAT is composed of a
//link list all of the same order of magnitude
//printf("Order Low %d Order High %d\n",OrderLT, OrderHT);
//printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
//printArbArray(mpAT);
//printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbT2 = SortOrderMag( OrderHT-OrderLT+1, OrderLT, mpAT);
assert(ArbT2!=NULL);
int TotalOrdersT = OrderHT-OrderLT+1;
//Sorts nodes into clusters
//printf("********************************************\n");
//printArbArray(ArbT2, OrderLT);
//printf("********************************************\n");
ArbArray ArbT = ClusterSort( TotalOrdersT, OrderLT, ArbT2);
//printf("TotalOrdersT %d OrderLowT %d Elements used by ArbT2 %d\n",TotalOrdersT, OrderLT, getElementsUsed(ArbT2));
assert(ArbT!=NULL);
//Filtering Cluster
rv = FilterCluster( TotalOrdersT, OrderLT, mtxT, &ArbT, snAT, PeriodicXT, PeriodicYT, PeriodicZT, XElecOnT, YElecOnT, ZElecOnT);
assert(rv==0);
//printf("****************CHECK***********************\n");
rv = PrintCheck( TotalOrdersT, OrderLT, ArbT, snAT, mtxT);
//Because the cluster is smaller energy than the rest of the nodes the rest
//of the nodes are not considered to be a cluster
deleteArbArray(&ArbT2);
/*
////////////////////////////////////////////////////////////////////////////////////////
//Case Study no clusters Periodic
int OrderLU;
int OrderHU;
int MidPtsTotalU;
int PeriodicXU = 1;
int PeriodicYU = 1;
int PeriodicZU = 1;
int XElecOnU = 1;
int YElecOnU = 0;
int ZElecOnU = 0;
SNarray snAU = newSNarray( 3,4,3);
//Create an artificial trap in snAT which in increment length is
//length 0-2 width 0-3 and height 0-2
printSNarray(snAU);
//Testing Periodic x,y and z 0 biasX 0 biasY 0 biasZ KT=1 and reOrgEnergy=1
matrix mtxU = CalculateAllHops(snAU, 0,0,0, 1,1, SiteDistance,AttemptToHop,gamma,PeriodicXU, PeriodicYU, PeriodicZU);
printMatrix(mtxU);
//Sorts all the data into midpoints
ArbArray mpAU = MPsort( &OrderLU, &OrderHU, &MidPtsTotalU, mtxU, snAU, PeriodicXU, PeriodicYU, PeriodicZU);
//Sorts midpoints into Nodes in link lists. Each element of mpAT is composed of a
//link list all of the same order of magnitude
printf("Order Low %d Order High %d\n",OrderLU, OrderHU);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAU);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbU2 = SortOrderMag( OrderHU-OrderLU+1, OrderLU, mpAU);
assert(ArbU2!=NULL);
int TotalOrdersU = OrderHU-OrderLU+1;
//Sorts nodes into clusters
printf("********************************************\n");
printArbArray(ArbU2, OrderLU);
printf("********************************************\n");
ArbArray ArbU = ClusterSort( TotalOrdersU, OrderLU, ArbU2);
printf("TotalOrdersT %d OrderLowT %d Elements used by ArbT2 %d\n",TotalOrdersU, OrderLU, getElementsUsed(ArbU2));
printf("****************STARTING FILTER****************************\n");
assert(ArbU!=NULL);
//Filtering Cluster
rv = FilterCluster( TotalOrdersU, OrderLU, mtxU, &ArbU, snAU, PeriodicXU, PeriodicYU, PeriodicZU, XElecOnU, YElecOnU, ZElecOnU);
assert(rv==0);
printf("****************CHECK***********************\n");
rv = PrintCheck( TotalOrdersU, OrderLU, ArbU, snAU, mtxU);
deleteArbArray(&ArbU2);
deleteArbArray(&ArbU);
deleteMatrix(mtxU);
deleteSNarray(snAU);
deleteAllMidPointArray(&mpAU);
//Case Study two clusters in middle non periodic
int OrderLS;
int OrderHS;
int MidPtsTotalS;
int PeriodicXS = 0;
int PeriodicYS = 0;
int PeriodicZS = 0;
int XElecOnS = 1;
int YElecOnS = 0;
int ZElecOnS = 0;
SNarray snAS = newSNarray( 4, 3, 3);
//Create Trap Sites
SiteNode snS = getSN(snAS,2,1,1);
printSNarray(snAS);
rv = setEnergy(snS, -4);
assert(rv==0);
snS = getSN(snAS, 1,1,1);
rv = setEnergy(snS, -4);
assert(rv==0);
printSNarray(snAS);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxS = CalculateAllHops(snAS, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXS, PeriodicYS, PeriodicZS);
printMatrix(mtxS);
ArbArray mpAS = MPsort( &OrderLS, &OrderHS, &MidPtsTotalS, mtxS, snAS, PeriodicXS, PeriodicYS, PeriodicZS);
printf("Order Low %d Order High %d\n",OrderLS, OrderHS);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAS);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbS2 = SortOrderMag( OrderHS-OrderLS+1, OrderLS, mpAS);
assert(ArbS2!=NULL);
int TotalOrdersS = OrderHS-OrderLS+1;
printf("********************************************\n");
printArbArray(ArbS2, OrderLS);
printf("********************************************\n");
ArbArray ArbS = ClusterSort( TotalOrdersS, OrderLS, ArbS2);
printf("TotalOrdersS %d OrderLowS %d Elements used by ArbS2 %d\n",TotalOrdersS, OrderLS, getElementsUsed(ArbS2));
assert(ArbS!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbS, OrderLS);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersS, OrderLS, mtxS, &ArbS, snAS, PeriodicXS, PeriodicYS, PeriodicZS, XElecOnS, YElecOnS, ZElecOnS);
assert(rv==0);
printf("****************CHECK***********************\n");
rv = PrintCheck( TotalOrdersS, OrderLS, ArbS, snAS, mtxS);
deleteMatrix(mtxS);
deleteSNarray(snAS);
deleteArbArray(&ArbS);
deleteAllMidPointArray(&mpAS);
deleteArbArray(&ArbS2);
//Case Study two cluster on oposite edges non periodic
int OrderLR;
int OrderHR;
int MidPtsTotalR;
int PeriodicXR = 0;
int PeriodicYR = 0;
int PeriodicZR = 0;
int XElecOnR = 1;
int YElecOnR = 0;
int ZElecOnR = 0;
SNarray snAR = newSNarray( 4, 3, 3);
//Create Trap Sites one at the left electrode
//One at the right electrode should not consider
//any clusters in the sample
SiteNode snR = getSN(snAR,0,1,1);
printSNarray(snAR);
rv = setEnergy(snR, -4);
assert(rv==0);
snS = getSN(snAR, 3,1,1);
rv = setEnergy(snR, -4);
assert(rv==0);
printSNarray(snAR);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxR = CalculateAllHops(snAR, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXR, PeriodicYR, PeriodicZR);
printMatrix(mtxR);
ArbArray mpAR = MPsort( &OrderLR, &OrderHR, &MidPtsTotalR, mtxR, snAR, PeriodicXR, PeriodicYR, PeriodicZR);
printf("Order Low %d Order High %d\n",OrderLR, OrderHR);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAR);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbR2 = SortOrderMag( OrderHR-OrderLR+1, OrderLR, mpAR);
assert(ArbR2!=NULL);
int TotalOrdersR = OrderHR-OrderLR+1;
printf("********************************************\n");
printArbArray(ArbR2, OrderLR);
printf("********************************************\n");
ArbArray ArbR = ClusterSort( TotalOrdersR, OrderLR, ArbR2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersR, OrderLR, getElementsUsed(ArbR2));
assert(ArbR!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbR, OrderLR);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersR, OrderLR, mtxR, &ArbR, snAR, PeriodicXR, PeriodicYR, PeriodicZR, XElecOnR, YElecOnR, ZElecOnR);
assert(rv==0);
printf("****************CHECK***********************\n");
rv = PrintCheck( TotalOrdersR, OrderLR, ArbR, snAR, mtxR);
deleteMatrix(mtxR);
deleteSNarray(snAR);
deleteAllMidPointArray(&mpAR);
deleteArbArray(&ArbR2);
deleteArbArray(&ArbR);
//Case Study two cluster on oposite edges periodic in x
int OrderLP;
int OrderHP;
int MidPtsTotalP;
int PeriodicXP = 1;
int PeriodicYP = 0;
int PeriodicZP = 0;
int XElecOnP = 1;
int YElecOnP = 0;
int ZElecOnP = 0;
SNarray snAP = newSNarray( 4, 3, 3);
//Create Trap Sites one at the left electrode
//One at the right electrode should not consider
//any clusters in the sample
SiteNode snP = getSN(snAP,0,1,1);
printSNarray(snAP);
rv = setEnergy(snP, -4);
assert(rv==0);
snP = getSN(snAP, 3,1,1);
rv = setEnergy(snP, -4);
assert(rv==0);
printSNarray(snAP);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxP = CalculateAllHops(snAP, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXP, PeriodicYP, PeriodicZP);
printMatrix(mtxP);
ArbArray mpAP = MPsort( &OrderLP, &OrderHP, &MidPtsTotalP, mtxP, snAP, PeriodicXP, PeriodicYP, PeriodicZP);
printf("Order Low %d Order High %d\n",OrderLP, OrderHP);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAP);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbP2 = SortOrderMag( OrderHP-OrderLP+1, OrderLP, mpAP);
assert(ArbP2!=NULL);
int TotalOrdersP = OrderHP-OrderLP+1;
printf("********************************************\n");
printArbArray(ArbP2, OrderLP);
printf("********************************************\n");
ArbArray ArbP = ClusterSort( TotalOrdersP, OrderLP, ArbP2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersP, OrderLP, getElementsUsed(ArbP2));
assert(ArbP!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbP, OrderLP);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersP, OrderLP, mtxP, &ArbP, snAP, PeriodicXP, PeriodicYP, PeriodicZP, XElecOnP, YElecOnP, ZElecOnP);
assert(rv==0);
printf("****************CHECK***********************\n");
rv = PrintCheck( TotalOrdersP, OrderLP, ArbP, snAP, mtxP);
deleteArbArray(&ArbP2);
//Case Study two cluster on oposite edges periodic in y
int OrderLO;
int OrderHO;
int MidPtsTotalO;
int PeriodicXO = 0;
int PeriodicYO = 1;
int PeriodicZO = 0;
int XElecOnO = 1;
int YElecOnO = 0;
int ZElecOnO = 0;
SNarray snAO = newSNarray( 4, 3, 3);
//Create Trap Sites one at the left electrode
//One at the right electrode should not consider
//any clusters in the sample
SiteNode snO = getSN(snAO,1,0,1);
printSNarray(snAO);
rv = setEnergy(snO, -4);
assert(rv==0);
snO = getSN(snAO, 1,2,1);
rv = setEnergy(snO, -4);
assert(rv==0);
printSNarray(snAO);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxO = CalculateAllHops(snAO, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXO, PeriodicYO, PeriodicZO);
printMatrix(mtxO);
ArbArray mpAO = MPsort( &OrderLO, &OrderHO, &MidPtsTotalO, mtxO, snAO, PeriodicXO, PeriodicYO, PeriodicZO);
printf("Order Low %d Order High %d\n",OrderLO, OrderHO);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAO);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbO2 = SortOrderMag( OrderHO-OrderLO+1, OrderLO, mpAO);
assert(ArbO2!=NULL);
int TotalOrdersO = OrderHO-OrderLO+1;
printf("********************************************\n");
printArbArray(ArbO2, OrderLO);
printf("********************************************\n");
ArbArray ArbO = ClusterSort( TotalOrdersO, OrderLO, ArbO2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersP, OrderLO, getElementsUsed(ArbO2));
assert(ArbO!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbO, OrderLO);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersP, OrderLO, mtxO, &ArbO, snAO, PeriodicXO, PeriodicYO, PeriodicZO, XElecOnO, YElecOnO, ZElecOnO);
assert(rv==0);
printf("****************CHECK***********************\n");
rv = PrintCheck( TotalOrdersO, OrderLO, ArbO, snAO, mtxO);
deleteArbArray(&ArbO2);
//Case Study two cluster on oposite edges non-periodic in y
int OrderLM;
int OrderHM;
int MidPtsTotalM;
int PeriodicXM = 0;
int PeriodicYM = 0;
int PeriodicZM = 0;
int XElecOnM = 1;
int YElecOnM = 0;
int ZElecOnM = 0;
SNarray snAM = newSNarray( 4, 3, 3);
//Create Trap Sites one at the left electrode
//One at the right electrode should not consider
//any clusters in the sample
SiteNode snM = getSN(snAM,1,0,1);
printSNarray(snAM);
rv = setEnergy(snM, -4);
assert(rv==0);
snM = getSN(snAM, 1,2,1);
rv = setEnergy(snM, -4);
assert(rv==0);
printSNarray(snAM);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ, KT=0.024, and reOrgEnergy =1
matrix mtxM = CalculateAllHops(snAM, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXM, PeriodicYM, PeriodicZM);
printMatrix(mtxM);
ArbArray mpAM = MPsort( &OrderLM, &OrderHM, &MidPtsTotalM, mtxM, snAM, PeriodicXM, PeriodicYM, PeriodicZM);
printf("Order Low %d Order High %d\n",OrderLM, OrderHM);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAM);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbM2 = SortOrderMag( OrderHM-OrderLM+1, OrderLM, mpAM);
assert(ArbM2!=NULL);
int TotalOrdersM = OrderHM-OrderLM+1;
printf("********************************************\n");
printArbArray(ArbM2, OrderLM);
printf("********************************************\n");
ArbArray ArbM = ClusterSort( TotalOrdersM, OrderLM, ArbM2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersM, OrderLM, getElementsUsed(ArbM2));
assert(ArbM!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbM, OrderLM);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersM, OrderLM, mtxM, &ArbM, snAM, PeriodicXM, PeriodicYM, PeriodicZM, XElecOnM, YElecOnM, ZElecOnM);
assert(rv==0);
printf("****************CHECK M***********************\n");
rv = PrintCheck( TotalOrdersM, OrderLM, ArbM, snAM, mtxM);
deleteArbArray(&ArbM2);
//Case Study two cluster on oposite edges periodic in z
int OrderLN;
int OrderHN;
int MidPtsTotalN;
int PeriodicXN = 0;
int PeriodicYN = 0;
int PeriodicZN = 0;
int XElecOnN = 1;
int YElecOnN = 0;
int ZElecOnN = 0;
SNarray snAN = newSNarray( 4, 3, 3);
//Create Trap Sites one at the left electrode
//One at the right electrode should not consider
//any clusters in the sample
SiteNode snN = getSN(snAN,1,1,0);
printSNarray(snAN);
rv = setEnergy(snN, -4);
assert(rv==0);
snN = getSN(snAN, 1,1,2);
rv = setEnergy(snN, -4);
assert(rv==0);
printSNarray(snAN);
//Testing non-periodic x, y and z 0 biasX, 0 biasY, 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxN = CalculateAllHops(snAN, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXN, PeriodicYN, PeriodicZN);
printMatrix(mtxN);
ArbArray mpAN = MPsort( &OrderLN, &OrderHN, &MidPtsTotalN, mtxN, snAN, PeriodicXN, PeriodicYN, PeriodicZN);
printf("Order Low %d Order High %d\n",OrderLN, OrderHN);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAN);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbN2 = SortOrderMag( OrderHN-OrderLN+1, OrderLN, mpAN);
assert(ArbN2!=NULL);
int TotalOrdersN = OrderHN-OrderLN+1;
printf("********************************************\n");
printArbArray(ArbN2, OrderLN);
printf("********************************************\n");
ArbArray ArbN = ClusterSort( TotalOrdersN, OrderLN, ArbN2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersN, OrderLN, getElementsUsed(ArbN2));
assert(ArbN!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbN, OrderLN);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersN, OrderLN, mtxN, &ArbN, snAN, PeriodicXN, PeriodicYN, PeriodicZN, XElecOnN, YElecOnN, ZElecOnN);
assert(rv==0);
printf("****************CHECK N***********************\n");
rv = PrintCheck( TotalOrdersN, OrderLN, ArbN, snAN, mtxN);
deleteArbArray(&ArbN2);
//Case Study two cluster on oposite edges periodic in z
int OrderLK;
int OrderHK;
int MidPtsTotalK;
int PeriodicXK = 0;
int PeriodicYK = 0;
int PeriodicZK = 1;
int XElecOnK = 1;
int YElecOnK = 0;
int ZElecOnK = 0;
SNarray snAK = newSNarray( 4, 3, 3);
//Create Trap Sites one at the left electrode
//One at the right electrode should not consider
//any clusters in the sample
SiteNode snK = getSN(snAK,1,1,0);
printSNarray(snAK);
rv = setEnergy(snK, -4);
assert(rv==0);
snK = getSN(snAK, 1,1,2);
rv = setEnergy(snK, -4);
assert(rv==0);
printSNarray(snAK);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxK = CalculateAllHops(snAK, 0,0,0, 1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXK, PeriodicYK, PeriodicZK);
printMatrix(mtxK);
ArbArray mpAK = MPsort( &OrderLK, &OrderHK, &MidPtsTotalK, mtxK, snAK, PeriodicXK, PeriodicYK, PeriodicZK);
printf("Order Low %d Order High %d\n",OrderLK, OrderHK);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAK);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbK2 = SortOrderMag( OrderHK-OrderLK+1, OrderLK, mpAK);
assert(ArbK2!=NULL);
int TotalOrdersK = OrderHK-OrderLK+1;
printf("********************************************\n");
printArbArray(ArbK2, OrderLK);
printf("********************************************\n");
ArbArray ArbK = ClusterSort( TotalOrdersK, OrderLK, ArbK2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersK, OrderLK, getElementsUsed(ArbK2));
assert(ArbK!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbK, OrderLK);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersK, OrderLK, mtxK, &ArbK, snAK, PeriodicXK, PeriodicYK, PeriodicZK, XElecOnK, YElecOnK, ZElecOnK);
assert(rv==0);
printf("****************CHECK K***********************\n");
rv = PrintCheck( TotalOrdersK, OrderLK, ArbK, snAK, mtxK);
deleteArbArray(&ArbK2);
//Case Study periodic conditions percolation pathway across sample
int OrderLJ;
int OrderHJ;
int MidPtsTotalJ;
int PeriodicXJ = 1;
int PeriodicYJ = 1;
int PeriodicZJ = 1;
int XElecOnJ = 1;
int YElecOnJ = 0;
int ZElecOnJ = 0;
SNarray snAJ = newSNarray( 4, 3, 3);
//Create Trap Sites that cross the sample
SiteNode snJ = getSN(snAJ,0,1,1);
printSNarray(snAJ);
rv = setEnergy(snJ, -4);
assert(rv==0);
snJ = getSN(snAJ, 1,1,1);
rv = setEnergy(snJ, -4);
assert(rv==0);
snJ = getSN(snAJ, 2,1,1);
rv = setEnergy(snJ, -4);
assert(rv==0);
snJ = getSN(snAJ, 3, 1, 1);
rv = setEnergy(snJ, -4);
assert(rv==0);
printSNarray(snAJ);
//Testing non-periodic x, y and z 0 biasX 0 biasY 0 biasZ KT=0.024, and reOrgEnergy =1
matrix mtxJ = CalculateAllHops(snAJ, 0, 0,0,1, 1, SiteDistance,AttemptToHop,gamma,PeriodicXJ, PeriodicYJ, PeriodicZJ);
printMatrix(mtxJ);
ArbArray mpAJ = MPsort( &OrderLJ, &OrderHJ, &MidPtsTotalJ, mtxJ, snAJ, PeriodicXJ, PeriodicYJ, PeriodicZJ);
printf("Order Low %d Order High %d\n",OrderLJ, OrderHJ);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
printArbArray(mpAJ);
printf("oooooooooooooooooooooooooooooooooooooooooooo\n");
ArbArray ArbJ2 = SortOrderMag( OrderHJ-OrderLJ+1, OrderLJ, mpAJ);
assert(ArbJ2!=NULL);
int TotalOrdersJ = OrderHJ-OrderLJ+1;
printf("********************************************\n");
printArbArray(ArbJ2, OrderLJ);
printf("********************************************\n");
ArbArray ArbJ = ClusterSort( TotalOrdersJ, OrderLJ, ArbJ2);
printf("TotalOrdersR %d OrderLowR %d Elements used by ArbR2 %d\n",TotalOrdersJ, OrderLJ, getElementsUsed(ArbJ2));
assert(ArbJ!=NULL);
printf("--------------------------------------------\n");
printArbArray(ArbJ, OrderLJ);
printf("--------------------------------------------\n");
rv = FilterCluster( TotalOrdersJ, OrderLJ, mtxJ, &ArbJ, snAJ, PeriodicXJ, PeriodicYJ, PeriodicZJ, XElecOnJ, YElecOnJ, ZElecOnJ);
assert(rv==0);
printf("****************CHECJ***********************\n");
rv = PrintCheck( TotalOrdersJ, OrderLJ, ArbJ, snAJ, mtxJ);
printf("****************CHECK J NeighNodes*********************\n");
rv = CalculateNeighNodes(TotalOrdersJ, OrderLJ, &ArbJ, snAJ, PeriodicXJ, PeriodicYJ, PeriodicZJ);
assert(rv==0);
rv = PrintCheck( TotalOrdersJ, OrderLJ, ArbJ, snAJ, mtxJ);
deleteArbArray(&ArbJ2);
printf("****************CHECK K NeighNodes*********************\n");
//SNarray snAK = newSNarray( 4, 3, 3);
//int PeriodicXK = 0;
//int PeriodicYK = 0;
//int PeriodicZK = 1;
//SiteNode snK = getSN(snAK,1,1,0);
//snK = getSN(snAK, 1,1,2);
rv = PrintCheck( TotalOrdersK, OrderLK, ArbK, snAK, mtxK);
rv = CalculateNeighNodes(TotalOrdersK, OrderLK, &ArbK, snAK, PeriodicXK, PeriodicYK, PeriodicZK);
assert(rv==0);
rv = PrintCheck( TotalOrdersK, OrderLK, ArbK, snAK, mtxK);
deleteAllMidPointArray(&mpAK);
deleteMatrix(mtxK);
deleteSNarray(snAK);
deleteArbArray(&ArbK);
printf("****************CHECK M NeighNodes*********************\n");
//int PeriodicXM = 0;
//int PeriodicYM = 0;
//int PeriodicZM = 0;
//SNarray snAM = newSNarray( 4, 3, 3);
//SiteNode snM = getSN(snAM,1,0,1);
//snM = getSN(snAM, 1,2,1);
rv = PrintCheck( TotalOrdersM, OrderLM, ArbM, snAM, mtxM);
rv = CalculateNeighNodes(TotalOrdersM, OrderLM, &ArbM, snAM, PeriodicXM, PeriodicYM, PeriodicZM);
assert(rv==0);
rv = PrintCheck( TotalOrdersM, OrderLM, ArbM, snAM, mtxM);
printf("****************CHECK N NeighNodes*********************\n");
//int PeriodicXN = 0;
//int PeriodicYN = 0;
//int PeriodicZN = 0;
//SNarray snAN = newSNarray( 4, 3, 3);
//SiteNode snN = getSN(snAN,1,1,0);
//snN = getSN(snAN, 1,1,2);
rv = PrintCheck( TotalOrdersN, OrderLN, ArbN, snAN, mtxN);
rv = CalculateNeighNodes(TotalOrdersN, OrderLN, &ArbN, snAN, PeriodicXN, PeriodicYN, PeriodicZN);
assert(rv==0);
rv = PrintCheck( TotalOrdersN, OrderLN, ArbN, snAN, mtxN);
printf("****************CHECK O NeighNodes*********************\n");
//int PeriodicXO = 0;
//int PeriodicYO = 1;
//int PeriodicZO = 0;
//SNarray snAO = newSNarray( 4, 3, 3);
//SiteNode snO = getSN(snAO,1,0,1);
//snO = getSN(snAO, 1,2,1);
rv = PrintCheck( TotalOrdersO, OrderLO, ArbO, snAO, mtxO);
rv = CalculateNeighNodes(TotalOrdersO, OrderLO, &ArbO, snAO, PeriodicXO, PeriodicYO, PeriodicZO);
assert(rv==0);
rv = PrintCheck( TotalOrdersO, OrderLO, ArbO, snAO, mtxO);
printf("****************CHECK P NeighNodes*********************\n");
//int PeriodicXP = 1;
//int PeriodicYP = 0;
//int PeriodicZP = 0;
//SNarray snAP = newSNarray( 4, 3, 3);
//SiteNode snP = getSN(snAP,1,1,1);
//snP = getSN(snAP, 1,2,1);
rv = PrintCheck( TotalOrdersP, OrderLP, ArbP, snAP, mtxP);
rv = CalculateNeighNodes(TotalOrdersP, OrderLP, &ArbP, snAP, PeriodicXP, PeriodicYP, PeriodicZP);
assert(rv==0);
rv = PrintCheck( TotalOrdersP, OrderLP, ArbP, snAP, mtxP);
printf("****************CHECK T NeighNodes*********************\n");
//int PeriodicXT = 1;
//int PeriodicYT = 1;
//int PeriodicZT = 1;
//SNarray snAP = newSNarray( 3, 4, 3);
//SiteNode snP = getSN(snAP,0,1,1);
//snP = getSN(snAP, 3,1,1);
rv = PrintCheck( TotalOrdersT, OrderLT, ArbT, snAT, mtxT);
rv = CalculateNeighNodes(TotalOrdersT, OrderLT, &ArbT, snAT, PeriodicXT, PeriodicYT, PeriodicZT);
assert(rv==0);
rv = PrintCheck( TotalOrdersT, OrderLT, ArbT, snAT, mtxT);
printf("****************Calculate Pval J*********************\n");
rv = PrintCheck( TotalOrdersJ, OrderLJ, ArbJ, snAJ, mtxJ);
rv = CalculateSumAndP(TotalOrdersJ, snAJ, &ArbJ, mtxJ, attempts, PeriodicXJ, PeriodicYJ, PeriodicZJ);
printf("\n** After Run **\n");
rv = PrintCheck( TotalOrdersJ, OrderLJ, ArbJ, snAJ, mtxJ);
printf("****************Calculate Pval M*********************\n");
//int PeriodicXM = 0;
//int PeriodicYM = 0;
//int PeriodicZM = 0;
//SNarray snAM = newSNarray( 4, 3, 3);
//SiteNode snM = getSN(snAM,1,0,1);
//snM = getSN(snAM, 1,2,1);
rv = PrintCheck( TotalOrdersM, OrderLM, ArbM, snAM, mtxM);
printMatrix(mtxM);
rv = CalculateSumAndP(TotalOrdersM, snAM, &ArbM, mtxM, attempts, PeriodicXM, PeriodicYM, PeriodicZM);
printf("\n** After Run **\n");
rv = PrintCheck( TotalOrdersM, OrderLM, ArbM, snAM, mtxM);
deleteAllMidPointArray(&mpAM);
deleteMatrix(mtxM);
deleteSNarray(snAM);
deleteArbArray(&ArbM);
printf("****************Calculate Pval N*********************\n");
//int PeriodicXN = 0;
//int PeriodicYN = 0;
//int PeriodicZN = 0;
//SNarray snAN = newSNarray( 4, 3, 3);
//SiteNode snN = getSN(snAN,1,1,0);
//snN = getSN(snAN, 1,1,2);
rv = PrintCheck( TotalOrdersN, OrderLN, ArbN, snAN, mtxN);
printMatrix(mtxN);
rv = CalculateSumAndP(TotalOrdersN, snAN, &ArbN, mtxN, attempts, PeriodicXN, PeriodicYN, PeriodicZN);
printf("\n** After Run **\n");
rv = PrintCheck( TotalOrdersN, OrderLN, ArbN, snAN, mtxN);
deleteAllMidPointArray(&mpAN);
deleteMatrix(mtxN);
deleteSNarray(snAN);
deleteArbArray(&ArbN);
printf("****************Calculate Pval O*********************\n");
//int PeriodicXO = 0;
//int PeriodicYO = 1;
//int PeriodicZO = 0;
//SNarray snAO = newSNarray( 4, 3, 3);
//SiteNode snO = getSN(snAO,1,0,1);
//snO = getSN(snAO, 1,2,1);
rv = PrintCheck( TotalOrdersO, OrderLO, ArbO, snAO, mtxO);
printMatrix(mtxO);
rv = CalculateSumAndP(TotalOrdersO, snAO, &ArbO, mtxO, attempts, PeriodicXO, PeriodicYO, PeriodicZO);
printf("\n** After Run **\n");
rv = PrintCheck( TotalOrdersO, OrderLO, ArbO, snAO, mtxO);
printf("\nPrintArb Array\n");
printArbArray(ArbO,OrderLO);
printf("****************Calculate Pval P*********************\n");
//int PeriodicXP = 1;
//int PeriodicYP = 0;
//int PeriodicZP = 0;
//SNarray snAP = newSNarray( 4, 3, 3);
//SiteNode snP = getSN(snAP,0,1,1);
//snP = getSN(snAP, 3,1,1);
//Periodic in the X
rv = PrintCheck( TotalOrdersP, OrderLP, ArbP, snAP, mtxP);
printMatrix(mtxP);
rv = CalculateSumAndP(TotalOrdersP, snAP, &ArbP, mtxP, attempts, PeriodicXP, PeriodicYP, PeriodicZP);
printf("\n** After Run **\n");
rv = PrintCheck( TotalOrdersP, OrderLP, ArbP, snAP, mtxP);
printf("****************Calculate Pval T*********************\n");
if(ArbT==NULL){
printf("Arb T is NULL\n");
}else if(snAT==NULL){
printf("snAT is NULL\n");
}else if(mtxT==NULL){
printf("mtxT is NULL\n");
}
printf("Total Orders %d OrderL %d\n",TotalOrdersT, OrderLT);
rv = PrintCheck( TotalOrdersT, OrderLT, ArbT, snAT, mtxT);
printf("Printing Matrix T\n");
printMatrix(mtxT);
rv = CalculateSumAndP(TotalOrdersT, snAT, &ArbT, mtxT, attempts, PeriodicXT, PeriodicYT, PeriodicZT);
printf("\n** After Run **\n");
rv = PrintCheck( TotalOrdersT, OrderLT, ArbT, snAT, mtxT);
printf("PrintArb Array\n");
printArbArray(ArbT,OrderLT);
deleteAllMidPointArray(&mpAT);
deleteMatrix(mtxT);
deleteSNarray(snAT);
deleteArbArray(&ArbT);
printf("***************Connect Cluster J Check*****************\n");
//int PeriodicXJ = 1;
//int PeriodicYJ = 1;
//int PeriodicZJ = 1;
//SNarray snAJ = newSNarray( 4, 3, 3);
//Create Trap Sites that cross the sample
//SiteNode snJ = getSN(snAJ,0,1,1);
//snJ = getSN(snAJ, 1,1,1);
//snJ = getSN(snAJ, 2,1,1);
//snJ = getSN(snAJ, 3, 1, 1);
rv = ConnectClusterSN( TotalOrdersJ, snAJ, ArbJ);
printSNarray(snAJ);
printf("***************Connect Cluster O Check*****************\n");
//int PeriodicXO = 0;
//int PeriodicYO = 1;
//int PeriodicZO = 0;
//SNarray snAO = newSNarray( 4, 3, 3);
//SiteNode snO = getSN(snAO,1,0,1);
//snO = getSN(snAO, 1,2,1);
rv = ConnectClusterSN( TotalOrdersO, snAO, ArbO);
printSNarray(snAO);
deleteAllMidPointArray(&mpAO);
deleteMatrix(mtxO);
deleteSNarray(snAO);
deleteArbArray(&ArbO);
printf("***************FindCluster J Check*****************\n");
//int PeriodicXJ = 1;
//int PeriodicYJ = 1;
//int PeriodicZJ = 1;
//SNarray snAJ = newSNarray( 4, 3, 3);
//Create Trap Sites that cross the sample
//SiteNode snJ = getSN(snAJ,0,1,1);
//snJ = getSN(snAJ, 1,1,1);
//snJ = getSN(snAJ, 2,1,1);
//snJ = getSN(snAJ, 3, 1, 1);
ParameterFrame PF = newParamFrame();
PFset_AttemptToHop(PF,AttemptToHop);
PFset_gamma(PF,gamma);
PFset_Px(PF,PeriodicXJ);
PFset_Py(PF,PeriodicYJ);
PFset_Pz(PF,PeriodicZJ);
PFset_XElecOn(PF,XElecOnJ);
PFset_YElecOn(PF,YElecOnJ);
PFset_ZElecOn(PF,ZElecOnJ);
PFset_Attempts(PF,15);
PFset_reOrg(PF,1);
PFset_MovieFrames(PF,10);
PFset_SiteDist(PF,SiteDistance);
ArbArray ClArLLJJ;
rv = FindCluster( &OrderLJ, snAJ, 0,0,0, &ClArLLJJ, 1,PF);
printf("\nOld\n");
printArbArray(ArbJ,OrderLJ);
printf("\nNew\n");
printArbArray(ClArLLJJ, OrderLJ);
deleteAllMidPointArray(&mpAJ);
deleteMatrix(mtxJ);
deleteSNarray(snAJ);
deleteArbArray(&ArbJ);
deleteArbArray(&ClArLLJJ);
printf("***************FindCluster P Check*****************\n");
//int PeriodicXP = 1;
//int PeriodicYP = 0;
//int PeriodicZP = 0;
//SNarray snAP = newSNarray( 4, 3, 3);
//SiteNode snP = getSN(snAP,0,1,1);
PFset_Px(PF,PeriodicXJ);
PFset_Py(PF,PeriodicYJ);
PFset_Pz(PF,PeriodicZJ);
PFset_XElecOn(PF,XElecOnJ);
PFset_YElecOn(PF,YElecOnJ);
PFset_ZElecOn(PF,ZElecOnJ);
//snP = getSN(snAP, 3,1,1);
char FileName[] = "Data";
ArbArray ClArLLPP;
rv = FindCluster( &OrderLP, snAP, 0,0,0, &ClArLLPP, 1, PF);
printArbArray(ClArLLPP);
//rv = SaveCluster( FileName,OrderLP, snAP, 0.0,0.0,0.0, ClArLLPP, 1.0, PF);
printf("\nOld\n");
printArbArray(ArbP,OrderLP);
printf("\nNew\n");
printArbArray(ClArLLPP, OrderLP);
deleteAllMidPointArray(&mpAP);
deleteMatrix(mtxP);
deleteSNarray(snAP);
deleteArbArray(&ArbP);
deleteArbArray(&ClArLLPP);
deleteParamFrame(&PF);
double electricEnergyPx;
double electricEnergyPy;
double electricEnergyPz;
double KbT;
LoadCluster( FileName, &OrderLP, &snAP,&electricEnergyPx,&electricEnergyPy,&electricEnergyPz,&ClArLLPP,&KbT,&PF);
printSNarray_Detailed(snAP);
deleteSNarray(snAP);
deleteArbArray(&ClArLLPP);
deleteParamFrame(&PF);
int OrderLB;
int OrderHB;
int MidPtsTotalB;
int PeriodicXB = 1;
int PeriodicYB = 1;
int PeriodicZB = 1;
int XElecOnB = 1;
int YElecOnB = 0;
int ZElecOnB = 0;
SNarray snAB = newSNarray( 3,4,3);
//Create an artificial trap in snAB which in increment length is
//length 0-2 width 0-3 and height 0-2
SiteNode snB = getSN(snAB,1,1,1);
rv = setEnergy(snB, -3);
snB = getSN(snAB,1,2,1);
rv = setEnergy(snB, -3);
//Testing Periodic x,y and z 0 biasX 0 biasY 0 biasZ KT=1 and reOrgEnergy=1
matrix mtxB = CalculateAllHops(snAB, 0,0,0, 1,1,SiteDistance, AttemptToHop, gamma, PeriodicXB, PeriodicYB, PeriodicZB);
//Sorts all the data into midpoints
ArbArray mpAB = MPsort( &OrderLB, &OrderHB, &MidPtsTotalB, mtxB, snAB, PeriodicXB, PeriodicYB, PeriodicZB);
//Sorts midpoints into Nodes in link lists. Each element of mpAT is composed of a
//link list all of the same order of magnitude
int TotalOrdersB = OrderHB-OrderLB+1;
ArbArray ArbB2 = SortOrderMag( TotalOrdersB, OrderLB, mpAB);
//Sorts nodes into clusters
printf("Sorting Nodes into Clusters\n");
ArbArray ArbB = ClusterSort( TotalOrdersB, OrderLB, ArbB2);
//Filtering Cluster
printf("Filtering Clusters\n");
rv = FilterCluster( TotalOrdersB, OrderLB, mtxB, &ArbB, snAB,\
PeriodicXB, PeriodicYB, PeriodicZB,\
XElecOnB, YElecOnB, ZElecOnB);
printf("Calculating NeighNodes\n");
CalculateNeighNodes(TotalOrdersB, OrderLB, &ArbB, snAB, PeriodicXB, PeriodicYB, PeriodicZB);
printf("Calculating P values\n");
CalculateSumAndP( TotalOrdersB, snAB, &ArbB, mtxB, 15, PeriodicXB, PeriodicYB, PeriodicZB);
printf("Connecting nodes to clusters\n");
ConnectClusterSN( TotalOrdersB, snAB, ArbB);
//Deleting Every thing
printf("Deleting Phase\n");
deleteSNarray(snAB);
deleteAllMidPointArray(&mpAB);
deleteMatrix(mtxB);
deleteArbArray(&ArbB2);
deleteArbArray(&ArbB);
//atexit(mem_term);
*/
/*
printf("\nCreating Matrix with data to test cluster functions\n");
SNarray snA=newSNarray(SLength,SWidth,SHeight);
double electricField;
double electricEnergy;
electricField = voltage /(SLength*SiteDistance);
electricEnergy= SiteDistance*electricField;
initSite(electricEnergy, snA);
printf("\nCalling FindCluster Function\n");
ArbArray ClArLL;
ArbArray NeighClArLL;
FindCluster(snA, electricEnergy,0,0, &ClArLL, &NeighClArLL);
*/
return 0;
}
int asus_ate_command(const char *command, const char *value, const char *value2)
{
_dprintf("===[ATE %s %s]===\n", command, value);
#ifdef RTCONFIG_QTN
if(!nvram_match("qtn_ready", "1")){
_dprintf("ATE Error: wireless 5G not ready\n");
return 0;
}
#endif
/*** ATE Set function ***/
if(!strcmp(command, "Set_StartATEMode")) {
nvram_set("asus_mfg", "1");
if(nvram_match("asus_mfg", "1")) {
puts("1");
#ifdef RTCONFIG_FANCTRL
stop_phy_tempsense();
#endif
stop_wpsaide();
stop_wps();
#ifdef RTCONFIG_BCMWL6
stop_igmp_proxy();
#ifdef RTCONFIG_HSPOT
stop_hspotap();
#endif
stop_acsd();
#ifdef BCM_BSD
stop_bsd();
#endif
#ifdef BCM_SSD
stop_ssd();
#endif
#endif
stop_upnp();
stop_lltd();
stop_rstats();
stop_wanduck();
stop_logger();
stop_wanduck();
stop_dnsmasq(0);
stop_ots();
stop_networkmap();
#ifdef RTCONFIG_USB
stop_usbled();
#ifdef RTCONFIG_USB_PRINTER
stop_lpd();
stop_u2ec();
#endif
#endif
platform_start_ate_mode();
}
else
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Set_AllLedOn")) {
return setAllLedOn();
}
else if (!strcmp(command, "Set_AllLedOn2")) {
return setAllLedOn2();
}
else if (!strcmp(command, "Set_AllLedOff")) {
return setAllLedOff();
}
else if (!strcmp(command, "Set_AllLedOn_Half")) {
puts("ATE_ERROR"); //Need to implement for EA-N66U
return EINVAL;
}
#ifdef RTCONFIG_BCMARM
else if (!strcmp(command, "Set_AteModeLedOn")) {
return setATEModeLedOn();
}
#endif
else if (!strcmp(command, "Set_MacAddr_2G")) {
if( !setMAC_2G(value) )
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Set_MacAddr_5G")) {
#ifdef RTCONFIG_QTN
if( !setMAC_5G_qtn(value))
#else
if( !setMAC_5G(value))
#endif
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#ifdef RTAC3200
else if (!strcmp(command, "Set_MacAddr_5G_2")) {
if( !setMAC_5G_2(value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#endif
#endif /* RTCONFIG_HAS_5G */
#if defined(RTN14U)
else if (!strcmp(command, "eeprom")) {
if ( !eeprom_upgrade(value, 1))
return EINVAL;
return 0;
}
else if (!strcmp(command, "eeover")) {
if ( !eeprom_upgrade(value, 0))
return EINVAL;
return 0;
}
#endif
#if defined(RTCONFIG_NEW_REGULATION_DOMAIN)
else if (!strcmp(command, "Set_RegSpec")) {
if (setRegSpec(value) < 0)
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
getRegSpec();
return 0;
}
else if (!strcmp(command, "Set_RegulationDomain_2G")) {
if (setRegDomain_2G(value) == -1) {
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
getRegDomain_2G();
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Set_RegulationDomain_5G")) {
if (setRegDomain_5G(value) == -1) {
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
getRegDomain_5G();
return 0;
}
#endif /* RTCONFIG_HAS_5G */
#else /* ! RTCONFIG_NEW_REGULATION_DOMAIN */
else if (!strcmp(command, "Set_RegulationDomain_2G")) {
if ( !setCountryCode_2G(value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
#ifdef RTCONFIG_QCA
if ((value2==NULL) || strcmp(value2,"noctl"))
setCTL(value);
#endif
return 0;
}
#endif /* RTCONFIG_NEW_REGULATION_DOMAIN */
#ifdef CONFIG_BCMWL5
else if (!strcmp(command, "Set_RegulationDomain_5G")) {
#ifdef RTCONFIG_QTN
if ( !setCountryCode_5G_qtn(value))
#else
if ( !setCountryCode_5G(value))
#endif
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
else if (!strcmp(command, "Set_Regrev_2G")) {
if( !setRegrev_2G(value) )
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
else if (!strcmp(command, "Set_Regrev_5G")) {
#ifdef RTCONFIG_QTN
if( !setRegrev_5G_qtn(value))
#else
if( !setRegrev_5G(value))
#endif
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
else if (!strcmp(command, "Set_Commit")) {
setCommit();
return 0;
}
#endif
#if defined(RTN14U)
else if (!strcmp(command, "pkt_flood")) {
if (nvram_invmatch("asus_mfg", "0"))
{
#if 0 // TBD
struct sockaddr_ll dev,dev2;
int fd,fd2,do_flag=3;
unsigned char buffer[1514];
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
dev.sll_family = AF_PACKET;
dev.sll_protocol = htons(ETH_P_ALL);
dev.sll_ifindex = 4; // LAN
bind( fd, (struct sockaddr *) &dev, sizeof(dev));
fd2 = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
dev2.sll_family = AF_PACKET;
dev2.sll_protocol = htons(ETH_P_ALL);
dev2.sll_ifindex = 5; // WAN
bind( fd2, (struct sockaddr *) &dev2, sizeof(dev2));
if (value) {
if(strcmp(value,"WAN")==0)
do_flag = 2;
else if(strcmp(value,"LAN")==0)
do_flag = 1;
}
memset(buffer,0xff,6);
FRead(buffer+6, OFFSET_MAC_ADDR_2G, 6);
memset(buffer+12,0x55,1502);
while(1)
{
if (do_flag & 1)
send( fd, buffer, 1514, 0);
if (do_flag & 2)
send( fd2, buffer, 1514, 0);
}
#endif
}
return 0;
}
#endif
else if (!strcmp(command, "Set_SerialNumber")) {
if(!setSN(value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#ifdef RTCONFIG_ODMPID
else if (!strcmp(command, "Set_ModelName")) {
if(!setMN(value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#endif
else if (!strcmp(command, "Set_PINCode")) {
if (!setPIN(value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
else if (!strcmp(command, "Set_40M_Channel_2G")) {
if(!set40M_Channel_2G((char*)value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Set_40M_Channel_5G")) {
if(!set40M_Channel_5G((char*)value))
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#endif /* RTCONFIG_HAS_5G */
else if (!strcmp(command, "Set_RestoreDefault")) {
nvram_set("restore_defaults", "1");
ResetDefault();
nvram_set(ASUS_STOP_COMMIT, "1");
return 0;
}
else if (!strcmp(command, "Set_Eject")) {
if( !Ej_device(value)) {
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#ifdef RTCONFIG_FANCTRL
else if (!strcmp(command, "Set_FanOn")) {
setFanOn();
return 0;
}
else if (!strcmp(command, "Set_FanOff")) {
setFanOff();
return 0;
}
#endif
#ifdef CONFIG_BCMWL5
else if (!strcmp(command, "Set_WaitTime")) {
if( !setWaitTime(value) )
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
else if (!strcmp(command, "Set_WiFi_2G")) {
if( !setWiFi2G(value) )
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Set_WiFi_5G")) {
if( !setWiFi5G(value) )
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
#endif /* RTCONFIG_HAS_5G */
#endif
#ifdef RTCONFIG_RALINK
else if (!strcmp(command, "Set_DevFlags")) {
if( Set_Device_Flags(value) < 0 )
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
return 0;
}
else if (!strcmp(command, "Set_WanToLan")) {
set_wantolan();
modprobe_r("hw_nat");
modprobe("hw_nat");
system("killall -9 wanduck");
system("killall -9 udhcpc");
return 0;
}
#if defined(RTAC1200HP) || defined(RTN56UB1)
else if (!strcmp(command, "Set_FixChannel")) {
FWrite("1", OFFSET_FIX_CHANNEL, 1);
puts("1");
return 0;
}
else if (!strcmp(command, "Set_FreeChannel")) {
FWrite("0", OFFSET_FIX_CHANNEL, 1);
nvram_set("wl0_channel","0");
nvram_set("wl1_channel","0");
nvram_set("lan_stp","1");
nvram_commit();
puts("1");
return 0;
}
#endif
#endif
else if (!strcmp(command, "Set_XSetting")) {
if(value == NULL || strcmp(value, "1")) {
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
else {
nvram_set("x_Setting", "1");
puts(nvram_get("x_Setting"));
}
return 0;
}
/*** ATE Get functions ***/
else if (!strcmp(command, "Get_FWVersion")) {
char fwver[12];
sprintf(fwver, "%s.%s", nvram_safe_get("firmver"), nvram_safe_get("buildno"));
puts(fwver);
return 0;
}
else if (!strcmp(command, "Get_BootLoaderVersion")) {
getBootVer();
return 0;
}
else if (!strcmp(command, "Get_ResetButtonStatus")) {
puts(nvram_safe_get("btn_rst"));
return 0;
}
else if (!strcmp(command, "Get_WpsButtonStatus")) {
puts(nvram_safe_get("btn_ez"));
return 0;
}
#ifdef RT4GAC55U
else if (!strcmp(command, "Get_LteButtonStatus")) {
puts(nvram_safe_get("btn_lte"));
return 0;
}
#endif
#ifdef RTCONFIG_WIFI_TOG_BTN
else if (!strcmp(command, "Get_WirelessButtonStatus")) {
puts(nvram_safe_get("btn_wifi_toggle"));
return 0;
}
#endif
else if (!strcmp(command, "Get_SWMode")) {
puts(nvram_safe_get("sw_mode"));
return 0;
}
else if (!strcmp(command, "Get_MacAddr_2G")) {
getMAC_2G();
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Get_MacAddr_5G")) {
#ifdef RTCONFIG_QTN
getMAC_5G_qtn();
#else
getMAC_5G();
#endif
return 0;
}
#ifdef RTAC3200
else if (!strcmp(command, "Get_MacAddr_5G_2")) {
getMAC_5G_2();
return 0;
}
#endif
#endif /* RTCONFIG_HAS_5G */
else if (!strcmp(command, "Get_Usb2p0_Port1_Infor")) {
Get_USB_Port_Info("1");
return 0;
}
else if (!strcmp(command, "Get_Usb2p0_Port1_Folder")) {
Get_USB_Port_Folder("1");
return 0;
}
else if (!strcmp(command, "Get_Usb2p0_Port2_Infor")) {
Get_USB_Port_Info("2");
return 0;
}
else if (!strcmp(command, "Get_Usb2p0_Port2_Folder")) {
Get_USB_Port_Folder("2");
return 0;
}
else if (!strcmp(command, "Get_SD_Infor")) {
Get_SD_Card_Info();
return 0;
}
else if (!strcmp(command, "Get_SD_Folder")) {
Get_SD_Card_Folder();
return 0;
}
#if defined(RTCONFIG_NEW_REGULATION_DOMAIN)
else if (!strcmp(command, "Get_RegSpec")) {
getRegSpec();
return 0;
}
else if (!strcmp(command, "Get_RegulationDomain_2G")) {
getRegDomain_2G();
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Get_RegulationDomain_5G")) {
getRegDomain_5G();
return 0;
}
#endif /* RTCONFIG_HAS_5G */
#else /* ! RTCONFIG_NEW_REGULATION_DOMAIN */
else if (!strcmp(command, "Get_RegulationDomain_2G")) {
getCountryCode_2G();
return 0;
}
#endif /* ! RTCONFIG_NEW_REGULATION_DOMAIN */
#ifdef CONFIG_BCMWL5
else if (!strcmp(command, "Get_RegulationDomain_5G")) {
#ifdef RTCONFIG_QTN
getCountryCode_5G_qtn();
#else
getCountryCode_5G();
#endif
return 0;
}
else if (!strcmp(command, "Get_Regrev_2G")) {
getRegrev_2G();
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Get_Regrev_5G")) {
#ifdef RTCONFIG_QTN
getRegrev_5G_qtn();
#else
getRegrev_5G();
#endif
return 0;
}
#endif /* RTCONFIG_HAS_5G */
#endif
else if (!strcmp(command, "Get_SerialNumber")) {
getSN();
return 0;
}
#ifdef RTCONFIG_ODMPID
else if (!strcmp(command, "Get_ModelName")) {
getMN();
return 0;
}
#endif
else if (!strcmp(command, "Get_PINCode")) {
getPIN();
return 0;
}
else if (!strcmp(command, "Get_WanLanStatus")) {
if( !GetPhyStatus())
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_FwReadyStatus")) {
puts(nvram_safe_get("success_start_service"));
return 0;
}
else if (!strcmp(command, "Get_Build_Info")) {
puts(nvram_safe_get("buildinfo"));
return 0;
}
#ifdef RTCONFIG_RALINK
else if (!strcmp(command, "Get_RSSI_2G")) {
getrssi(0);
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Get_RSSI_5G")) {
getrssi(1);
return 0;
}
#endif /* RTCONFIG_HAS_5G */
#endif
else if (!strcmp(command, "Get_ChannelList_2G")) {
if(!Get_ChannelList_2G())
puts("ATE_ERROR");
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Get_ChannelList_5G")) {
#ifdef RTCONFIG_QTN
if (!Get_ChannelList_5G_qtn())
#else
if (!Get_ChannelList_5G())
#endif
puts("ATE_ERROR");
return 0;
}
#ifdef RTAC3200
else if (!strcmp(command, "Get_ChannelList_5G_2")) {
if (!Get_ChannelList_5G_2())
puts("ATE_ERROR");
return 0;
}
#endif
#endif /* RTCONFIG_HAS_5G */
#if defined(RTCONFIG_USB_XHCI)
else if (!strcmp(command, "Get_Usb3p0_Port1_Infor")) {
if (!Get_USB3_Port_Info("1"))
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port2_Infor")) {
if (!Get_USB3_Port_Info("2"))
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port3_Infor")) {
puts("ATE_ERROR"); //Need to implement
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port1_Folder")) {
if (!Get_USB3_Port_Folder("1"))
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port2_Folder")) {
if (!Get_USB3_Port_Folder("2"))
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port3_Folder")) {
puts("ATE_ERROR"); //Need to implement
return EINVAL;
}
else if (!strcmp(command, "Get_Usb3p0_Port1_DataRate")) {
if (!Get_USB3_Port_DataRate("1"))
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port2_DataRate")) {
if (!Get_USB3_Port_DataRate("2"))
puts("ATE_ERROR");
return 0;
}
else if (!strcmp(command, "Get_Usb3p0_Port3_DataRate")) {
puts("ATE_ERROR"); //Need to implement
return EINVAL;
}
#endif /* RTCONFIG_USB_XHCI */
else if (!strcmp(command, "Get_fail_ret")) {
Get_fail_ret();
return 0;
}
else if (!strcmp(command, "Get_fail_reboot_log")) {
Get_fail_reboot_log();
return 0;
}
else if (!strcmp(command, "Get_fail_dev_log")) {
Get_fail_dev_log();
return 0;
}
#ifdef RTCONFIG_RALINK
#if !defined(RTN14U) && !defined(RTAC52U) && !defined(RTAC51U) && !defined(RTN11P) && !defined(RTN54U) && !defined(RTAC1200HP) && !defined(RTN56UB1) && !defined(RTAC54U)
else if (!strcmp(command, "Ra_FWRITE")) {
return FWRITE(value, value2);
}
else if (!strcmp(command, "Ra_Asuscfe_2G")) {
return asuscfe(value, WIF_2G);
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Ra_Asuscfe_5G")) {
return asuscfe(value, WIF_5G);
}
#endif /* RTCONFIG_HAS_5G */
else if (!strcmp(command, "Set_SwitchPort_LEDs")) {
if(Set_SwitchPort_LEDs(value, value2) < 0)
{
puts("ATE_ERROR");
return EINVAL;
}
return 0;
}
#endif
#endif
#ifdef RTCONFIG_WIRELESS_SWITCH
else if (!strcmp(command, "Get_WifiSwStatus")) {
puts(nvram_safe_get("btn_wifi_sw"));
return 0;
}
#endif
#ifdef RTCONFIG_WIFI_TOG_BTN
else if (!strcmp(command, "Get_WifiButtonStatus")) {
puts(nvram_safe_get("btn_wifi_toggle"));
return 0;
}
#endif
#ifdef RTCONFIG_TURBO
else if (!strcmp(command, "Get_Turbo")) {
puts(nvram_safe_get("btn_turbo"));
return 0;
}
#endif
#ifdef RTCONFIG_LED_BTN
else if (!strcmp(command, "Get_LedButtonStatus")) {
puts(nvram_safe_get("btn_led"));
return 0;
}
#endif
#ifdef RTCONFIG_QTN
else if (!strcmp(command, "Enable_Qtn_TelnetSrv")) {
enable_qtn_telnetsrv(1);
puts("1");
return 0;
}
else if (!strcmp(command, "Disable_Qtn_TelnetSrv")) {
enable_qtn_telnetsrv(0);
puts("1");
return 0;
}
else if (!strcmp(command, "Get_Qtn_TelnetSrv_Status")) {
getstatus_qtn_telnetsrv();
return 0;
}
else if (!strcmp(command, "Del_Qtn_Cal_Files")) {
del_qtn_cal_files();
puts("1");
return 0;
}
#endif
#ifdef CONFIG_BCMWL5
else if (!strcmp(command, "Get_WiFiStatus_2G")) {
if(!getWiFiStatus("2G"))
puts("ATE_ERROR_INCORRECT_PARAMETER");
return 0;
}
else if (!strcmp(command, "Get_WiFiStatus_5G")) {
if(!getWiFiStatus("5G"))
puts("ATE_ERROR_INCORRECT_PARAMETER");
return 0;
}
#else
else if (!strcmp(command, "Get_WiFiStatus_2G")) {
if(get_radio(0, 0))
puts("1");
else
puts("0");
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Get_WiFiStatus_5G")) {
if(get_radio(1, 0))
puts("1");
else
puts("0");
return 0;
}
#endif /* RTCONFIG_HAS_5G */
#endif
else if (!strcmp(command, "Set_WiFiStatus_2G")) {
int act = !strcmp(value, "on");
if(!strcmp(value, "on") && !strcmp(value, "off"))
puts("ATE_UNSUPPORT");
set_radio(act, 0, 0);
if(get_radio(0, 0)){
if(act)
puts("success=on");
else
puts("ATE_ERROR_INCORRECT_PARAMETER");
} else{
if(!act)
puts("success=off");
else
puts("ATE_ERROR_INCORRECT_PARAMETER");
}
return 0;
}
#if defined(RTCONFIG_HAS_5G)
else if (!strcmp(command, "Set_WiFiStatus_5G")) {
int act = !strcmp(value, "on");
if(!strcmp(value, "on") && !strcmp(value, "off"))
puts("ATE_UNSUPPORT");
set_radio(act, 1, 0);
if(get_radio(1, 0)){
if(act)
puts("success=on");
else
puts("ATE_ERROR_INCORRECT_PARAMETER");
} else{
if(!act)
puts("success=off");
else
puts("ATE_ERROR_INCORRECT_PARAMETER");
}
return 0;
}
#endif /* RTCONFIG_HAS_5G */
else if (!strcmp(command, "Get_ATEVersion")) {
puts(nvram_safe_get("Ate_version"));
return 0;
}
else if (!strcmp(command, "Get_XSetting")) {
puts(nvram_safe_get("x_Setting"));
return 0;
}
else if (!strcmp(command, "Get_WaitTime")) {
puts(nvram_safe_get("wait_time"));
return 0;
}
else if (!strcmp(command, "Get_ExtendNo")) {
puts(nvram_safe_get("extendno"));
return 0;
}
#ifdef RTCONFIG_RALINK
else if (!strcmp(command, "Get_DevFlags")) {
if( Get_Device_Flags() < 0)
{
puts("ATE_ERROR");
return EINVAL;
}
return 0;
}
#endif
#ifdef RTCONFIG_QCA
/*
else if (!strcmp(command, "Set_ART2")) {
// temp solution
system("killall rstats");
system("killall udhcpc");
system("killall wanduck");
system("killall networkmap");
system("killall -9 hostapd");
system("ifconfig ath0 down");
system("ifconfig ath1 down");
system("killall -9 hostapd");
system("brctl delif br0 ath0");
system("brctl delif br0 ath1");
system("wlanconfig ath0 destroy");
system("wlanconfig ath1 destroy");
system("ifconfig wifi0 down");
system("ifconfig wifi1 down");
modprobe_r("umac");
modprobe_r("ath_dfs");
modprobe_r("ath_dev");
modprobe_r("ath_rate_atheros");
modprobe_r("ath_spectral");
modprobe_r("ath_hal");
modprobe_r("adf");
modprobe_r("asf");
modprobe("art");
system("nart.out -port 2390 -console &");
system("nart.out -port 2391 -console &");
return 0;
}
*/
else if (!strncmp(command, "Get_EEPROM_", 11)) {
unsigned char buffer[2560];
unsigned short len;
int lret;
char *pt;
len=sizeof(buffer);
pt = (char*) command + 11;
if (!strcmp(pt, "2G"))
lret=getEEPROM(&buffer[0], &len, pt);
else if (!strcmp(pt, "5G"))
lret=getEEPROM(&buffer[0], &len, pt);
else if (!strcmp(pt, "CAL_2G"))
lret=getEEPROM(&buffer[0], &len, pt);
else if (!strcmp(pt, "CAL_5G"))
lret=getEEPROM(&buffer[0], &len, pt);
else {
puts("ATE_UNSUPPORT");
return EINVAL;
}
if ( !lret )
hexdump(&buffer[0], len);
return 0;
}
else if (!strcmp(command, "Get_CalCompare")) {
unsigned char buffer[2560], buffer2[2560];
unsigned short len, len2;
int lret=0, cret=0;
len=sizeof(buffer);
len2=sizeof(buffer2);
lret+=getEEPROM(&buffer[0], &len, "2G");
lret+=getEEPROM(&buffer2[0], &len2, "CAL_2G");
if (lret)
return EINVAL;
if ((len!=len2) || (memcmp(&buffer[0],&buffer2[0],len)!=0)) {
puts("2G EEPROM different!");
cret++;
}
len=sizeof(buffer);
len2=sizeof(buffer2);
lret+=getEEPROM(&buffer[0], &len, "5G");
lret+=getEEPROM(&buffer2[0], &len2, "CAL_5G");
if (lret)
return EINVAL;
if ((len!=len2) || (memcmp(&buffer[0],&buffer2[0],len)!=0)) {
puts("5G EEPROM different!");
cret++;
}
if (!cret)
puts("1");
else
puts("0");
return 0;
}
#ifdef RTCONFIG_ATEUSB3_FORCE
else if (!strcmp(command, "Set_ForceUSB3")) {
if (setForceU3(value) < 0)
{
puts("ATE_ERROR_INCORRECT_PARAMETER");
return EINVAL;
}
getForceU3();
return 0;
}
else if (!strcmp(command, "Get_ForceUSB3")) {
getForceU3();
return 0;
}
#endif
#endif /* RTCONFIG_QCA */
#ifdef RT4GAC55U
else if(!strcmp(command, "Get_GobiSimCard")) {
char line[128];
if (!Gobi_SimCardReady(Gobi_SimCard(line, sizeof(line))))
{
puts("FAIL");
return EINVAL;
}
puts("PASS");
}
else if(!strcmp(command, "Get_GobiIMEI")) {
char line[128];
const char *IMEI = Gobi_IMEI(line, sizeof(line));
if (IMEI == NULL)
{
puts("FAIL");
return EINVAL;
}
puts(IMEI);
}
else if(!strcmp(command, "Get_GobiConnectISP")) {
char line[128];
const char *ISP = Gobi_ConnectISP(line, sizeof(line));
if (ISP == NULL)
{
puts("FAIL");
return EINVAL;
}
puts(ISP);
}
else if(!strcmp(command, "Get_GobiConnectStatus")) {
const char *status = Gobi_ConnectStatus_Str(Gobi_ConnectStatus_Int());
if (status == NULL)
{
puts("FAIL");
return EINVAL;
}
puts(status);
}
else if(!strcmp(command, "Get_GobiSignal_Percent")) {
int percent = Gobi_SignalQuality_Percent(Gobi_SignalQuality_Int());
if (percent < 0)
{
puts("FAIL");
return EINVAL;
}
printf("%d\n", percent);
}
else if(!strcmp(command, "Get_GobiSignal_dbm")) {
int dbm = Gobi_SignalLevel_Int();
if (dbm >= 0)
{
puts("FAIL");
return EINVAL;
}
printf("%d dBm\n", dbm);
}
else if(!strcmp(command, "Get_GobiVersion")) {
char line[128];
if (Gobi_Version(line, sizeof(line)) == NULL)
{
puts("FAIL");
return EINVAL;
}
printf("%s\n", line);
}
#endif /* RT4GAC55U */
else
{
puts("ATE_UNSUPPORT");
return EINVAL;
}
return 0;
}
int AT_Pre_Process (char *buf_cmd)
{
#if 0
if(!strcmp(buf_cmd, SLEEPMODE)){
LOGD(TAG "SLEEP_MODE");
pret = setSleepMode(fd_atcmd);
if(!strcmp(pret, STR_OK))
write_chars(fd_uart, "OK\r",3);
else
write_chars(fd_uart, "ERROR\r",6);
}
else if(!strcmp(buf_cmd, EMER_CALL)){
LOGD(TAG "EMERCALL");
pret = dial112(fd_atcmd);
if(!strcmp(pret, STR_OK))
write_chars(fd_uart, "OK\r",3);
else
write_chars(fd_uart, "ERROR\r",6);
}
else if(!strcmp(buf_cmd, GET_SN)) {
LOGD(TAG "GET_SN");
pret = getSN(buf_ret, sizeof(buf_ret), fd_atcmd);
if(!strcmp(pret, STR_OK))
write_chars(fd_uart, buf_ret, sizeof(buf_ret));
else
write_chars(fd_uart, "ERROR\r",6);
}
else if(strstr(buf_cmd, SET_SN) || !strcmp(buf_cmd, ATH)) {
LOGD(TAG "%s\n", buf_cmd);
// Add '\r\n' tp command buf.
buf_cmd[len] = '\r';
buf_cmd[len+1] = '\n';
buf_cmd[len+2] = '\0';
pret = at_command_set(buf_cmd, fd_atcmd);
if(!strcmp(pret, STR_OK))
write_chars(fd_uart, "OK\r",3);
else
write_chars(fd_uart, "ERROR\r",6);
}
else if(!strcmp(buf_cmd, AT) || !strcmp(buf_cmd, ATE0)) {
// AT and ATE0 are commands for test command between
// ATE tool and target. Just return "OK\r" when receive.
LOGD(TAG "%s\n", buf_cmd);
write_chars(fd_uart, "OK\r",3);
}
else{
LOGD(TAG "Unsupported command\n");
write_chars(fd_uart, "ERROR\r",6);
}
#endif
#ifdef MTK_DT_SUPPORT
if(!strcmp(buf_cmd, "AT+SWITCH"))
{
LOGD(TAG "AT+SWITCH");
if(g_mdFlag==1)
g_mdFlag=2;
else if(g_mdFlag==2)
g_mdFlag=1;
else
LOGD(TAG "Unsupported MD Flag\n");
}
#endif
return 0;
}
int ClusterHop(SNarray snA, Charge one, int * totalX){
printf("Hopping to cluster\n");
//flag is 0 if charge moves and 1 if charge stays put
int flag = 0;
//initially, the flag is set as 0 - can hop, 1 is can not hop
//flag is used to determine if charges can hop to sites outside
//of the cluster.
int flag1 = 0;
//flag2 accounts for availability within the cluster.
int flag2 = 0;
int rv;
int ID, NewID;
long double sum=0.0;
double pvalHigh;
double pval;
int i, j, k;
int i1, j1, k1;
double position2;
double position;
double time;
long double sum2=0.0;
SiteNode sn;
ID=getIndex(snA, getCx(one), getCy(one), getCz(one));
NewID=ID;
//Check to see if there are sites adjacent to the cluster that are
//open
rv = OccAllNeiCluster(snA, getCx(one), getCy(one), getCz(one));
if (rv==1){
//there is no possibility for hopping outside the cluster as all the neighbouring sites
//around the first charge position are all occuppied and the cluster
//does not sit next to an electrode
printf("Hopping outside Cluster Not permitted\n");
flag1 = 1;
}
rv = OccAllCluster( snA, getCx(one), getCy(one), getCz(one));
if(rv==1) {
//This means hopping within the cluster is not permitted
printf("Hopping Within Cluster Not permitted\n");
flag2 = 1;
//But hopping outside may be allowed;
if(flag1!=1){
getNeighClusterPvalHigh( snA, getCx(one), getCy(one), getCz(one), &pvalHigh, &sum);
//pval=pvalHigh*2;
sn = getSN(snA, getCx(one), getCy(one), getCz(one));
setp(sn, 0, 0.0, 4);
//Don't add to sum because hopping within cluster is not allowed
//Can't stay where it is. hopping within the cluster is not allowed
//so pval for the cluster is 0.0
}
//what happens if can't hop on or off?
}else{
double pvalLow;
//Hopping within the cluster is allowed must account for this in the sum
getClusterPvalLow( snA, getCx(one), getCy(one), getCz(one), &pvalLow, &sum2);
assert(pvalLow>0.000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
if (flag1!=1){
//Grabbing the fastest hop rate off the cluster
getNeighClusterPvalHigh( snA, getCx(one), getCy(one), getCz(one), &pvalHigh, &sum);
assert(pvalHigh>0.000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
sn = getSN(snA, getCx(one), getCy(one), getCz(one));
time=getTimeCluster( (ClusterLL) getList(sn));
assert(time<1/pvalHigh);
//if(pvalLow<pvalHigh*2){
// pval=pvalLow;
setp(sn, 0, , 4);
//}else{
// pval=pvalHigh*2;
// setp(sn, 0, pval, 4);
//}
}else {
assert(pvalHigh>0.000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
sn = getSN(snA, getCx(one), getCy(one), getCz(one));
time=getTimeCluster( (ClusterLL) getList(sn));
assert(time<1/pvalHigh);
//if(pvalLow<pvalHigh*2){
// pval=pvalLow;
setp(sn, 0, , 4);
//}else{
// pval=pvalHigh*2;
// setp(sn, 0, pval, 4);
//}
}else {
pval=pvalLow;
sn = getSN(snA, getCx(one), getCy(one), getCz(one));
setp(sn, 0, pval, 4);
}
printf("Value of sum Before %Lg\n",sum);
sum+=(long double) pval;
printf("Value of sum After %Lg\n",sum);
printf("Value of pval %g\n",pval);
printf("pvalLow %g pvalHigh %g\n",pvalLow, pvalHigh);
assert(pval>0.000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
}
if(flag1==0 && flag2==0){
//There is a possibility for hopping to at least one of the neighbouring
//site off the cluster. There is also the possibility that a site within
//the cluster is occupied. This loop determines in which direction the charge
//will jump to by randomly choosing a number between 0 and 1
