static void rt2x00link_precalculate_signal(struct rt2x00_dev *rt2x00dev)
{
struct link *link = &rt2x00dev->link;
struct link_qual *qual = &rt2x00dev->link.qual;
link->rx_percentage =
PERCENTAGE(qual->rx_success, qual->rx_failed + qual->rx_success);
link->tx_percentage =
PERCENTAGE(qual->tx_success, qual->tx_failed + qual->tx_success);
}
int rt2x00link_calculate_signal(struct rt2x00_dev *rt2x00dev, int rssi)
{
struct link *link = &rt2x00dev->link;
int rssi_percentage = 0;
int signal;
/*
* We need a positive value for the RSSI.
*/
if (rssi < 0)
rssi += rt2x00dev->rssi_offset;
/*
* Calculate the different percentages,
* which will be used for the signal.
*/
rssi_percentage = PERCENTAGE(rssi, rt2x00dev->rssi_offset);
/*
* Add the individual percentages and use the WEIGHT
* defines to calculate the current link signal.
*/
signal = ((WEIGHT_RSSI * rssi_percentage) +
(WEIGHT_TX * link->tx_percentage) +
(WEIGHT_RX * link->rx_percentage)) / 100;
return max_t(int, signal, 100);
}
int main(int argc, const char * argv[])
{
srand((unsigned)time(NULL));
printf("Running Genetic Algorithm...\n");
printf("Target Genes: %s\n", kTargetGenes.c_str());
printf("Population Size: %d\n", kPopulationSize);
printf("Elitism: %s\n", (kElitismEnabled ? "true" : "false"));
printf("Elitism Percentage: %d%%\n", kElitismPercentage);
printf("Mutation Probability: %d%%\n", kMutationProbability);
printf("Crossover Probability: %d%%\n\n", kCrossoverProbability);
GAPopulation population = GAPopulation(kPopulationSize, kTargetGenes);
population.elitismEnabled = kElitismEnabled;
population.tournamentSize = kTournamentSize;
population.elitismPercentage = PERCENTAGE(kElitismPercentage);
population.mutationProbability = PERCENTAGE(kMutationProbability);
population.crossoverProbability = PERCENTAGE(kCrossoverProbability);
population.selectionType = GAPopulationSelectionType::GAPopulationSelectionTypeTournament;
population.crossoverType = GAPopulationCrossoverType::GAPopulationCrossoverTypeOnePoint;
population.evolve();
return 0;
}
int
progress(void *p, double dltotal, double dlnow, double ultotal, double ulnow)
{
double curtime = 0;
struct progress *prog;
CURL *curl;
prog = (struct progress *) p;
curl = prog->curl;
curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &curtime);
if ((curtime - prog->lastrun) >= MINPROGRESSTIME) {
prog->lastrun = curtime;
fprintf(stderr, "TOTALTIME: %f\r\n", curtime);
}
fprintf(stderr, "%.1f kiB / %.1f kiB [%.1f%%]\r",
dlnow / 1024, dltotal / 1024, PERCENTAGE(dlnow, dltotal));
fflush(stderr);
return 0;
}
int main (int argc,char *argv[])
{
const char *filename = NULL,*device = NULL;
int i,flags = FLAG_NONE;
ssize_t result;
size_t size,written;
struct mtd_info_user mtd;
struct erase_info_user erase;
struct stat filestat;
unsigned char src[BUFSIZE],dest[BUFSIZE];
/*********************
* parse cmd-line
*****************/
for (;;) {
int option_index = 0;
static const char *short_options = "hv";
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0},
};
int c = getopt_long(argc, argv, short_options,
long_options, &option_index);
if (c == EOF) {
break;
}
switch (c) {
case 'h':
flags |= FLAG_HELP;
DEBUG("Got FLAG_HELP\n");
break;
case 'v':
flags |= FLAG_VERBOSE;
DEBUG("Got FLAG_VERBOSE\n");
break;
default:
DEBUG("Unknown parameter: %s\n",argv[option_index]);
showusage(true);
}
}
if (optind+2 == argc) {
flags |= FLAG_FILENAME;
filename = argv[optind];
DEBUG("Got filename: %s\n",filename);
flags |= FLAG_DEVICE;
device = argv[optind+1];
DEBUG("Got device: %s\n",device);
}
if (flags & FLAG_HELP || device == NULL)
showusage(flags != FLAG_HELP);
atexit (cleanup);
/* get some info about the flash device */
dev_fd = safe_open (device,O_SYNC | O_RDWR);
if (ioctl (dev_fd,MEMGETINFO,&mtd) < 0)
{
DEBUG("ioctl(): %m\n");
log_printf (LOG_ERROR,"This doesn't seem to be a valid MTD flash device!\n");
exit (EXIT_FAILURE);
}
/* get some info about the file we want to copy */
fil_fd = safe_open (filename,O_RDONLY);
if (fstat (fil_fd,&filestat) < 0)
{
log_printf (LOG_ERROR,"While trying to get the file status of %s: %m\n",filename);
exit (EXIT_FAILURE);
}
/* does it fit into the device/partition? */
if (filestat.st_size > mtd.size)
{
log_printf (LOG_ERROR,"%s won't fit into %s!\n",filename,device);
exit (EXIT_FAILURE);
}
/*****************************************************
* erase enough blocks so that we can write the file *
*****************************************************/
#warning "Check for smaller erase regions"
erase.start = 0;
erase.length = (filestat.st_size + mtd.erasesize - 1) / mtd.erasesize;
erase.length *= mtd.erasesize;
if (flags & FLAG_VERBOSE)
{
/* if the user wants verbose output, erase 1 block at a time and show him/her what's going on */
int blocks = erase.length / mtd.erasesize;
erase.length = mtd.erasesize;
log_printf (LOG_NORMAL,"Erasing blocks: 0/%d (0%%)",blocks);
for (i = 1; i <= blocks; i++)
{
log_printf (LOG_NORMAL,"\rErasing blocks: %d/%d (%d%%)",i,blocks,PERCENTAGE (i,blocks));
if (ioctl (dev_fd,MEMERASE,&erase) < 0)
{
log_printf (LOG_NORMAL,"\n");
log_printf (LOG_ERROR,
"While erasing blocks 0x%.8x-0x%.8x on %s: %m\n",
(unsigned int) erase.start,(unsigned int) (erase.start + erase.length),device);
exit (EXIT_FAILURE);
}
erase.start += mtd.erasesize;
}
log_printf (LOG_NORMAL,"\rErasing blocks: %d/%d (100%%)\n",blocks,blocks);
}
else
{
/* if not, erase the whole chunk in one shot */
if (ioctl (dev_fd,MEMERASE,&erase) < 0)
{
log_printf (LOG_ERROR,
"While erasing blocks from 0x%.8x-0x%.8x on %s: %m\n",
(unsigned int) erase.start,(unsigned int) (erase.start + erase.length),device);
exit (EXIT_FAILURE);
}
}
DEBUG("Erased %u / %luk bytes\n",erase.length,filestat.st_size);
/**********************************
* write the entire file to flash *
**********************************/
if (flags & FLAG_VERBOSE) log_printf (LOG_NORMAL,"Writing data: 0k/%luk (0%%)",KB (filestat.st_size));
size = filestat.st_size;
i = BUFSIZE;
written = 0;
while (size)
{
if (size < BUFSIZE) i = size;
if (flags & FLAG_VERBOSE)
log_printf (LOG_NORMAL,"\rWriting data: %dk/%luk (%lu%%)",
KB (written + i),
KB (filestat.st_size),
PERCENTAGE (written + i,filestat.st_size));
/* read from filename */
safe_read (fil_fd,filename,src,i,flags & FLAG_VERBOSE);
/* write to device */
result = write (dev_fd,src,i);
if (i != result)
{
if (flags & FLAG_VERBOSE) log_printf (LOG_NORMAL,"\n");
if (result < 0)
{
log_printf (LOG_ERROR,
"While writing data to 0x%.8x-0x%.8x on %s: %m\n",
written,written + i,device);
exit (EXIT_FAILURE);
}
log_printf (LOG_ERROR,
"Short write count returned while writing to x%.8x-0x%.8x on %s: %d/%lu bytes written to flash\n",
written,written + i,device,written + result,filestat.st_size);
exit (EXIT_FAILURE);
}
written += i;
size -= i;
}
if (flags & FLAG_VERBOSE)
log_printf (LOG_NORMAL,
"\rWriting data: %luk/%luk (100%%)\n",
KB (filestat.st_size),
KB (filestat.st_size));
DEBUG("Wrote %d / %luk bytes\n",written,filestat.st_size);
/**********************************
* verify that flash == file data *
**********************************/
safe_rewind (fil_fd,filename);
safe_rewind (dev_fd,device);
size = filestat.st_size;
i = BUFSIZE;
written = 0;
if (flags & FLAG_VERBOSE) log_printf (LOG_NORMAL,"Verifying data: 0k/%luk (0%%)",KB (filestat.st_size));
while (size)
{
if (size < BUFSIZE) i = size;
if (flags & FLAG_VERBOSE)
log_printf (LOG_NORMAL,
"\rVerifying data: %dk/%luk (%lu%%)",
KB (written + i),
KB (filestat.st_size),
PERCENTAGE (written + i,filestat.st_size));
/* read from filename */
safe_read (fil_fd,filename,src,i,flags & FLAG_VERBOSE);
/* read from device */
safe_read (dev_fd,device,dest,i,flags & FLAG_VERBOSE);
/* compare buffers */
if (memcmp (src,dest,i))
{
log_printf (LOG_ERROR,
"File does not seem to match flash data. First mismatch at 0x%.8x-0x%.8x\n",
written,written + i);
exit (EXIT_FAILURE);
}
written += i;
size -= i;
}
if (flags & FLAG_VERBOSE)
log_printf (LOG_NORMAL,
"\rVerifying data: %luk/%luk (100%%)\n",
KB (filestat.st_size),
KB (filestat.st_size));
DEBUG("Verified %d / %luk bytes\n",written,filestat.st_size);
exit (EXIT_SUCCESS);
}
