static void
fswrite(Req *r)
{
char e[ERRMAX];
uint32_t path;
path = r->fid->qid.path;
switch(TYPE(path)){
default:
snprint(e, sizeof e, "bug in execnet path=%lx", path);
respond(r, e);
break;
case Qctl:
ctlwrite(r, client[NUM(path)]);
break;
case Qdata:
datawrite(r, client[NUM(path)]);
break;
}
}
void fputtr_internal(FILE *fp, segy *tp, cwp_Bool fixed_length)
{
/* search linked list for possible alternative */
if(fp != lastfp) searchlist(fp);
if (infoptr == ((struct outsegyinfo *) NULL)) {
/* initialize new segy output stream */
/* allocate new segy output information table */
*oldinfoptr = (struct outsegyinfo *)
malloc(sizeof(struct outsegyinfo));
infoptr = *oldinfoptr;
infoptr->nextinfo = (struct outsegyinfo *) NULL;
/* save FILE * ptr */
infoptr->outfp = fp;
infoptr->itr = 0;
switch (infoptr->ftype = filestat(fileno(fp))) {
case DIRECTORY:
suerr("%s: segy output can't be a directory", __FILE__);
case TTY:
suerr("%s: segy output can't be tty", __FILE__);
default:
/* the rest are ok */
break;
}
/* Sanity check the segy header */
infoptr->nsfirst = tp->ns;
if (infoptr->nsfirst > SU_NFLTS)
suerr("%s: unable to handle %d > %d samples per trace",
__FILE__, infoptr->nsfirst, SU_NFLTS);
switch(tp->trid) {
case CHARPACK:
infoptr->bytesper = sizeof(char); break;
case SHORTPACK:
infoptr->bytesper = 2*sizeof(char); break;
default:
infoptr->bytesper = sizeof(float); break;
}
/*--------------------------------------------------------------------*\
Write out a line header if it has been set as the default or has
requested on the caommandline. Commandline takes precedence over
the default in all cases.
Reginald H. Beardsley [email protected]
\*--------------------------------------------------------------------*/
/* commented out 15.05.09 WWS
getparint( "lheader" ,&out_line_hdr );
if( out_line_hdr ){
if( in_line_hdr ){
(void) efwrite(&(su_text_hdr[0]), 1 ,3200
,infoptr->outfp);
}else{
memset( su_text_hdr ,0 ,sizeof(su_text_hdr) );
sprintf( hdr_str ,"%-80s"
,"C 1 CLIENT CWP/SU default text header " );
strncat( su_text_hdr ,hdr_str ,80 );
for( i=1; i<40; i++ ){
sprintf( hdr_str ,"%-80s" ,"C" );
strncat( su_text_hdr ,hdr_str ,80 );
}
(void) efwrite(&(su_text_hdr[0]), 1 ,3200
,infoptr->outfp);
}
memset( &su_binary_hdr ,0 ,sizeof(su_binary_hdr) );
su_binary_hdr.format = 1;
su_binary_hdr.hns = tp->ns;
su_binary_hdr.hdt = tp->dt;
(void) efwrite(&su_binary_hdr, 1
,sizeof(su_binary_hdr), infoptr->outfp);
}
*/
}
if (tp->ns != infoptr->nsfirst && fixed_length)
suerr("%s: on trace #%ld, number of samples in header (%d) "
"differs from number for first trace (%d)",
__FILE__, (infoptr->itr)+1, tp->ns, infoptr->nsfirst);
(void) efwrite(tp, 1,HDRBYTES, infoptr->outfp);
datawrite(tp, infoptr, fixed_length);
++infoptr->itr;
lastfp = infoptr->outfp;
}
void fputtr_internal(FILE *fp, segy *tp, cwp_Bool fixed_length)
{
unsigned int databytes; /* bytes from nsfirst */
int nwritten; /* bytes seen by fwrite calls */
/* search linked list for possible alternative */
if(fp != lastfp) searchlist(fp);
if (infoptr == ((struct outsegyinfo *) NULL)) {
/* initialize new segy output stream */
/* allocate new segy output information table */
*oldinfoptr = (struct outsegyinfo *)
malloc(sizeof(struct outsegyinfo));
infoptr = *oldinfoptr;
infoptr->nextinfo = (struct outsegyinfo *) NULL;
/* save FILE * ptr */
infoptr->outfp = fp;
infoptr->itr = 0;
/* allocate XDR struct and associate FILE * ptr */
infoptr->segy_xdr = (XDR *) malloc(sizeof(XDR));
switch (infoptr->ftype = filestat(fileno(fp))) {
case DIRECTORY:
suerr("%s: segy output can't be a directory", __FILE__);
case TTY:
suerr("%s: segy output can't be tty", __FILE__);
break;
default: /* the rest are ok */
break;
}
xdrstdio_create(infoptr->segy_xdr,fp,XDR_ENCODE);
/* Sanity check the segy header */
infoptr->nsfirst = tp->ns;
if (infoptr->nsfirst > SU_NFLTS)
suerr("%s: unable to handle %d > %d samples per trace",
__FILE__, infoptr->nsfirst, SU_NFLTS);
switch(tp->trid) {
case CHARPACK:
infoptr->bytesper = sizeof(char); break;
case SHORTPACK:
infoptr->bytesper = 2*sizeof(char); break;
default:
infoptr->bytesper = BYTES_PER_XDR_UNIT; break;
}
}
databytes = infoptr->bytesper * (fixed_length?infoptr->nsfirst:tp->ns);
if(FALSE == xdrhdrsub(infoptr->segy_xdr,tp))
suerr("%s: unable to write header on trace #%ld",
__FILE__, (infoptr->itr)+1);
nwritten = datawrite(infoptr, tp, fixed_length);
if (nwritten != databytes)
suerr("%s: on trace #%ld, tried to write %d bytes, "
"wrote %d bytes",
__FILE__, (infoptr->itr)+1, databytes, nwritten);
++infoptr->itr;
lastfp = infoptr->outfp;
}
int main(int argc, char* argv[])
{
const char *comment = "Created with Bin2Var v1.10";
FILE *fp;
char *buf, str[256], *c;
int i, n, ext, n2;
unsigned short chk;
printf("Bin2Var v1.20 by David Phillips <*****@*****.**>\n\n");
if (argc != 3)
die(0);
buf = strrchr(argv[2], '.');
if (!buf)
die("Output file must have an extension!\n");
if (!stricmp(buf, ".82p"))
ext = E_82P;
else if (!stricmp(buf, ".83p"))
ext = E_83P;
else if (!stricmp(buf, ".8xp"))
ext = E_8XP;
else if (!stricmp(buf, ".85s"))
ext = E_85S;
else if (!stricmp(buf, ".86p"))
ext = E_86P;
else if (!stricmp(buf, ".86s"))
ext = E_86S;
else
die("Extension \'%s\' is not supported!\n", buf);
genname(argv[2], str);
fp = fopen(argv[1], "rb");
if (!fp)
die("Failed to open input file: %s\n", argv[1]);
n = fsize(fp);
buf = (char *)malloc(n);
fread(buf, n, 1, fp);
if (ferror(fp))
die("Error reading input file: %s\n", argv[1]);
fclose(fp);
fp = fopen(argv[2], "wb");
if (!fp)
die("Failed to open output file: %s\n", argv[2]);
chk = 0;
if (ext == E_82P)
fwrite("**TI82**\x1a\x0a\x00", 11, 1, fp);
else if (ext == E_83P)
fwrite("**TI83**\x1a\x0a\x00", 11, 1, fp);
else if (ext == E_8XP)
fwrite("**TI83F*\x1a\x0a\x00", 11, 1, fp);
else if (ext == E_85S)
fwrite("**TI85**\x1a\x0c\x00", 11, 1, fp);
else if ((ext == E_86P) || (ext == E_86S))
fwrite("**TI86**\x1a\x0a\x00", 11, 1, fp);
writecomment(fp, comment);
if ((ext == E_82P) )
i = n + 17;
else if (ext == E_83P)
i = (n * 2) + 26;
else if (ext == E_8XP)
i = (n * 2) + 20;
else if (ext == E_85S)
i = n + 10 + strlen(str);
else
i = n + 18;
fwrite(&i, 2, 1, fp);
if ((ext == E_82P) || (ext == E_83P) || (ext == E_8XP))
cfwrite("\x0b\0x00", 2, fp, &chk);
else if (ext == E_85S)
{
i = 4 + strlen(str);
cfwrite(&i, 1, fp, &chk);
cfwrite("\0x00", 1, fp, &chk);
}
else
cfwrite("\x0c\0x00", 2, fp, &chk);
if(ext == E_8XP)
i = (n * 2) + 5;
else if(ext == E_83P)
i = (n * 2) + 11;
else
i = n + 2;
cfwrite(&i, 2, fp, &chk);
if ((ext == E_82P) || (ext == E_83P) || (ext == E_8XP))
cfwrite("\x06", 1, fp, &chk);
else if (ext == E_86P)
cfwrite("\x12", 1, fp, &chk);
else if ((ext == E_85S) || (ext == E_86S))
cfwrite("\x0c", 1, fp, &chk);
i = strlen(str);
if ((ext == E_85S) || (ext == E_86P) || (ext == E_86S))
cfwrite(&i, 1, fp, &chk);
cfwrite(str, i, fp, &chk);
memset(str, 0, 8);
if (ext != E_85S)
cfwrite(str, 8 - i, fp, &chk);
if (ext == E_8XP)
{
i = (n * 2) + 5;
n2 = (n * 2) + 3;
}
else if (ext == E_83P)
{
i = (n * 2) + 11;
n2 = (n * 2) + 9;
}
else
{
i = n + 2;
n2 = n;
}
cfwrite(&i, 2, fp, &chk);
cfwrite(&n2, 2, fp, &chk);
if(ext == E_8XP)
{
cfwrite("\xBB", 1, fp, &chk);
cfwrite("\x6C", 1, fp, &chk);
cfwrite("\x3F", 1, fp, &chk);
}
if((ext == E_83P) || (ext == E_8XP))
datawrite(buf, n, fp, &chk);
else
cfwrite(buf, n, fp, &chk);
if(ext == E_83P)
{
cfwrite("\x3F", 1, fp, &chk);
cfwrite("\xD4", 1, fp, &chk);
cfwrite("\x3F", 1, fp, &chk);
cfwrite("0000", 4, fp, &chk);
cfwrite("\x3F", 1, fp, &chk);
cfwrite("\xD4", 1, fp, &chk);
}
fwrite(&chk, 2, 1, fp);
if (ferror(fp))
die("Failed writing output file: %s\n", argv[2]);
fclose(fp);
free(buf);
printf("'%s' successfully converted to '%s'\n", argv[1], argv[2]);
return 0;
}
int main(int argc, char *argv[])
{
int n1, n2, i3, n3, n12, ip, np, n12p, ncycle, niter, order;
bool inv, verb, decomp, twhole;
char *type;
float *pp, *qq, ***dd, ***mm, eps, perc, scale;
sf_file in, out, dip, mask;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
dip = sf_input("dips");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n12 = n1*n2;
if (!sf_histint(dip,"n3",&np)) np=1;
n12p = n12*np;
scale = 1./np;
pp = sf_floatalloc(n12);
qq = sf_floatalloc(n12p);
dd = sf_floatalloc3(n1,n2,np);
if (!sf_getbool("inv",&inv)) inv=false;
/* if y, do inverse transform */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
if (!sf_getbool("twhole",&twhole)) twhole=true;
/* threshold flag, if y, whole model, otherwise, each component */
if (!sf_getbool("decomp",&decomp)) decomp=false;
/* do decomposition */
if (!sf_getint("ncycle",&ncycle)) ncycle=0;
/* number of iterations */
if (!sf_getint("niter",&niter)) niter=1;
/* number of Bregman iterations */
if (!sf_getfloat("perc",&perc)) perc=50.0;
/* percentage for sharpening */
if (NULL != sf_getstring("mask")) { /* (optional) data mask file */
mask = sf_input("mask");
mm = sf_floatalloc3(n1,n2,np);
} else {
mask = NULL;
mm = NULL;
}
if (inv) {
n3 = sf_leftsize(in,3);
if (!decomp) sf_unshiftdim(in, out, 3);
} else {
n3 = sf_leftsize(in,2);
sf_putint(out,"n3",np);
(void) sf_shiftdim(in, out, 3);
}
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
if (NULL == (type=sf_getstring("type"))) type="linear";
/* wavelet type (haar,linear,biorthogonal), default is linear */
diplet_init(n1,n2,decomp? 1: np, dd,mm,true,eps,order,type[0]);
for (i3=0; i3 < n3; i3++) {
sf_floatread(dd[0][0],n12p,dip);
if (NULL != mask) sf_floatread(mm[0][0],n12p,mask);
if (inv) {
sf_floatread(qq,n12p,in);
if (decomp) {
for (ip=0; ip < np; ip++) {
seislet_set(dd[ip]);
seislet_lop(false,false, n12, n12,qq+ip*n12, pp);
datawrite(n12,1.,pp,out);
}
} else {
diplet_lop(false,false, n12p, n12,qq, pp);
datawrite(n12,scale,pp,out);
}
} else {
sf_floatread(pp,n12,in);
sf_sharpinv(diplet_lop,
scale,niter,ncycle,perc,verb,n12p,n12,qq,pp,twhole);
sf_floatwrite(qq,n12p,out);
}
}
exit(0);
}
/* Hauptprogramm des Controllers **
** Dieses Programm wird beim Starten des Controllers aufgerufen und **
** abgearbeitet. Die Endlosschleife ist der zyklische Teil des Programms */
int main(void)
{
init(); //Aufruf der init Funktion
while(1) //zyklischer Teil des Programms
{
if(controller == 0 && dataint)
{
receive = dataread(1);
switch(receive)
{
case 1: //falls die Klemme 1 angesprochen werden soll
{
setBit(DDRC, Klemme1);
setBit(PORTC, Klemme1); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 2: //falls die Klemme 2 angesprochen werden soll
{
setBit(DDRC, Klemme2);
setBit(PORTC, Klemme2); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 3: //falls die Klemme 3 angesprochen werden soll
{
setBit(DDRC, Klemme3);
setBit(PORTC, Klemme3); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 4: //falls die Klemme 4 angesprochen werden soll
{
setBit(DDRC, Klemme4);
setBit(PORTC, Klemme4); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 5: //falls die Klemme 5 angesprochen werden soll
{
setBit(DDRC, Klemme5);
setBit(PORTC, Klemme5); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 6: //falls die Klemme 6 angesprochen werden soll
{
setBit(DDRC, Klemme6);
setBit(PORTC, Klemme6); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 7: //falls die Klemme 7 angesprochen werden soll
{
setBit(DDRB, Klemme7);
setBit(PORTB, Klemme7); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 8: //falls die Klemme 8 angesprochen werden soll
{
setBit(DDRD, Klemme8);
setBit(PORTD, Klemme8); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 9: //falls die Klemme 9 angesprochen werden soll
{
setBit(DDRB, Klemme9);
setBit(PORTB, Klemme9); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 10: //falls die Klemme 10 angesprochen werden soll
{
setBit(DDRD, Klemme10);
setBit(PORTD, Klemme10); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 11: //falls die Klemme 11 angesprochen werden soll
{
setBit(DDRB, Klemme11);
setBit(PORTB, Klemme11); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 12: //falls die Klemme 12 angesprochen werden soll
{
setBit(DDRD, Klemme12);
setBit(PORTD, Klemme12); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 13: //falls die Klemme 13 angesprochen werden soll
{
setBit(DDRB, Klemme13);
setBit(PORTB, Klemme13); //setzen der Klemme
datawrite(Datenrichtig, Sthaupt);
break;
}
case 31: //falls ein Platinentest durchgeführt werden soll
{
_delay_ms(100);
datawrite(Platinentest, Sthaupt);
break;
}
default:
{
datawrite(Datennichtrichtig, Sthaupt);
break;
}
}
dataint = 0;
controller = -1;
receive = 0;
datareadinit();
}
else if(controller == 1 && dataint)
{
receive = dataread(1);
switch(receive)
{
case 0:
{
break;
}
}
dataint = 0;
controller = -1;
receive = 0;
datareadinit();
}
}
}
