int main(int argc, char *argv[])
{
int numread;
double shift;
float indata[WORKLEN], outdata[WORKLEN + 1], overlap = 0.0;
char *infilenm = NULL, *outfilenm = NULL;
FILE *infile = NULL, *outfile = NULL, *textout = NULL;
/* Get the filename of the datafile and open it */
textout = (argc == 3) ? stderr : stdout;
if (argc == 3 || argc == 4) {
shift = strtod(argv[1], (char **) NULL);
if (shift <= -1.0 || shift >= 1.0) {
fprintf(textout, "\nbins_to_shift must be between -1.0 and 1.0.");
fprintf(textout, " Exiting.\n\n");
exit(-1);
}
infilenm = (char *) malloc(strlen(argv[2]) + 1);
strcpy(infilenm, argv[2]);
fprintf(textout, "\nShifting data from \"%s\" by %f bin.\n\n",
infilenm, shift);
if (NULL == (infile = fopen(infilenm, "rb"))) {
fprintf(textout, "\nCan't open \"%s\". Exiting.\n\n", infilenm);
exit(-1);
}
/* Open an output file if needed, else STDOUT */
if (argc == 4) {
outfilenm = (char *) malloc(strlen(argv[3]) + 1);
strcpy(outfilenm, argv[3]);
fprintf(textout, "Shifted data will be placed in \"%s\".\n\n", outfilenm);
if (NULL == (outfile = fopen(outfilenm, "wb"))) {
fprintf(textout, "\nCan't open \"%s\". Exiting.\n\n", outfilenm);
exit(-1);
}
} else {
outfile = stdout;
}
} else {
printf("\nUsage: shiftdata bins_to_shift infile [outfile]\n\n");
printf(" This routine is used to shift a file of single\n");
printf(" precision floating point data to the left or right\n");
printf(" by up to 1 bin. This allows you to patch two time\n");
printf(" series together with the correct phase, assuming\n");
printf(" that the data point durations are the same.\n");
printf(" The arguments are:\n");
printf(" bins_to_shift (double): The amount to shift the\n");
printf(" data. Negative shifts left, positive shifts\n");
printf(" right. For example, if I have the time series\n");
printf(" {1.0, 2,0, 1.0} and I give a bins_to_shift of\n");
printf(" -0.3, my new time series would look like\n");
printf(" {0.3, 1.3, 1.7, 0.7}. Notice that my time\n");
printf(" series increased in length by one and that I\n");
printf(" added some noise due to the fact that I am\n");
printf(" performing a type of two-bin average.\n");
printf(" infile (string): The data file to shift.\n");
printf(" outfile (string): An optional output file. The\n");
printf(" default behavior sends the raw output to STDOUT\n\n");
exit(0);
}
/* Read the data in WORKLEN sized chunks */
do {
numread = fread(indata, sizeof(float), WORKLEN, infile);
fshift(indata, outdata, numread, shift, overlap);
overlap = outdata[numread];
fwrite(outdata, sizeof(float), (unsigned long) numread, outfile);
} while (numread == WORKLEN);
/* Write the last data point if we didn't shift at all */
if (fabs(shift) > 1.0e-7)
fwrite(&overlap, sizeof(float), 1, outfile);
/* Cleanup */
free(infilenm);
fclose(infile);
if (argc == 4) {
fclose(outfile);
free(outfilenm);
}
exit(0);
}
int main()
{
int rc; // Return code from filesystem functions
File f1; // Demo file handle
static char buf[1024]; // General-purpose buffer.
if (!LX_2_USE) {
printf("The specified device (LX# %d) does not exist. Change LX_2_USE.\n",
(int)LX_2_USE);
exit(1);
}
else
printf("Using device LX# %d...\n", (int)LX_2_USE);
/*
* Step 1: initialize the filesystem. A real application must
* decide whether to format a new flash device, or just start
* up an existing filesystem. Formatting should not normally
* be needed unless, say, a user commands it. A factory-fresh
* flash device will usually be all erased so there is no need
* to format. Likewise, a flash with completely random data
* will be recognised as such and automatically formatted.
*/
rc = fs_init(0,0);
if (rc) {
printf("Could not initialize filesystem, error number %d\n", errno);
exit(2);
}
/*
* Step 2: format the filesystem if requested. Note that formatting
* must be done _after_ the call to fs_init().
*
* This demo initially asks whether the flash should be formatted
* via the stdio connection.
*/
printf("Do you want to:\n");
printf(" <enter> re-use existing filesystem -or-\n");
printf(" F <enter> format the filesystem logical extent?\n");
gets(buf);
if (toupper(buf[0]) == 'F') {
rc = lx_format(LX_2_USE, 0);
if (rc) {
printf("Format failed, error code %d\n", errno);
exit(3);
}
}
/*
* Step 3: open a file for writing if it already exists, or
* create it if it does not. Note that creation automatically
* opens the file for writing if it does not exist. If it
* does exist, then EEXIST will be returned in errno.
*/
printf("Capacity of LX# %d is approximately %ld\n",
(int)LX_2_USE, fs_get_lx_size(LX_2_USE, 0, 0));
fs_set_lx(LX_2_USE, LX_2_USE);
rc = fcreate(&f1, MY_FILE_NAME);
if (rc && errno == EEXIST) {
printf("File %d exists: shall I delete it? (y/n)\n", (int)MY_FILE_NAME);
gets(buf);
if (toupper(buf[0]) == 'Y') {
fdelete(MY_FILE_NAME);
rc = fcreate(&f1, MY_FILE_NAME);
}
else
rc = fopen_wr(&f1, MY_FILE_NAME);
}
if (rc) {
printf("Couldn't create/open file %d: errno = %d\n", (int)MY_FILE_NAME, errno);
exit(3);
}
do_it_again:
/*
* Seek to the end of the file then print the current length.
*/
fseek(&f1, 0, SEEK_END);
printf("File length is %ld\n", ftell(&f1));
/*
* Add some data to the end.
*/
strcpy(buf, "Test pattern ________");
rc = fwrite(&f1, buf, strlen(buf));
if (rc < strlen(buf)) {
printf("Append operation failed, error code %d\n", errno);
// but we keep going...
}
printf("After append operation...\n");
print_file(&f1);
/*
* Seek backwards and overwrite something.
*/
fseek(&f1, -7, SEEK_END);
sprintf(buf, "%ld", ftell(&f1));
rc = fwrite(&f1, buf, strlen(buf));
if (rc < strlen(buf)) {
printf("Overwrite operation failed, error code %d\n", errno);
// but we keep going...
}
printf("After overwrite operation...\n");
print_file(&f1);
/*
* Delete some data from the start.
*/
rc = fshift(&f1, DELETE_AMOUNT, buf);
if (rc == 0) {
printf("Shift operation failed, error code %d\n", errno);
// but we keep going...
}
printf("After shifting out %d chars...\n", rc);
print_file(&f1);
buf[rc] = 0;
printf("...and the deleted data was '%s'\n", buf);
/*
* Another round, anyone?
*/
printf("Are you having too much fun? (y/n)\n");
gets(buf);
if (toupper(buf[0]) == 'Y')
goto do_it_again;
return 0;
}
