/**************************** Main ****************************************/
void main(void)
{
byte tasten_wert;
int gespeichert;
if ( !initcom() ) exit(1);
printf("\nROBY V1.01\n");
printf("Positionen mit Tasten anfahren und speichern.\n");
printf("Beenden mit der RUN-Taste.\n\n");
do {
tasten_wert = zeige_tasten();
switch ( tasten_wert ) {
case T_KEINE : gespeichert = FALSE; halte_an(); break;
case T_AUF : drehe_auf(); break;
case T_AB : drehe_ab(); break;
case T_LINKS : drehe_links(); break;
case T_RECHTS : drehe_rechts(); break;
case T_EIN : magnet_ein(); break;
case T_AUS : magnet_aus(); break;
case T_SPEICHERN : if ( !gespeichert ) {
gespeichert = TRUE;
speichere();
}
}
}
while ( tasten_wert != T_RUN );
printf("\aRUN gedr�ckt...\n");
while ( !kbhit() ) fahre_ab(znum);
printf("Gute Arbeit geleistet, lieber ROBY!\n");
}
/**************************** Main ****************************************/
void main(void)
{
initcom();
printf("\nFAPER2 V1.0\n");
do {
lab_aktual();
printf("1. Wert: %d 2. Wert: %d\n", ewert[0], ewert[1]);
delay(1000);
} while ( !kbhit() );
}
/**************************** Main ****************************************/
void main(void)
{
int nb = 0;
initcom();
ginit();
gwindow(0,1000,0,255);
printf("\nFAPERG V1.0\n");
do {
lab_aktual();
if ( nb == 0 ) gpos(nb,ewert[0]);
else gdraw(nb,ewert[0]);
delay(10);
nb++;
} while ( !kbhit() );
gend();
}
/**************************** Main ****************************************/
void main(void)
{
int i;
unsigned char wert;
initcom();
ginit();
gwindow(0,4000,0,255);
printf("\nSPEICHKO V1.0\n");
for ( i = 1; i <= 4000; i++ ) {
wert = rxcharw();
if ( i == 1) gpos(i,wert);
else gdraw(i,wert);
}
txchar(CTRL_C);
printf("Dr�cke Taste..."); getch();
gend();
}
/**************************** Main ****************************************/
void main(void)
{
unsigned char zaehlertief, zaehlerhoch, data[256];
long periode = 1000000L; /* Zeitintervall zwischen Messungen */
int i, start = TRUE;
initcom();
ginit();
gwindow(0,255,0,255);
t_start(); /* Installiere Timer-Software */
t_alarm_start(); /* Installiere Alarm-Uhr */
printf("\nPOISSON V1.0\n");
for ( i = 0; i <= 255; i++ ) data[i] = 0;
t_alarm_set(0,periode,T_ONCE);
do {
do ; while ( t_alarm_check(0) == 0 );
t_alarm_set(0,periode,T_ONCE);
txchar(SYNCHBYTE);
zaehlertief = rxcharw();
zaehlerhoch = rxcharw();
if ( start ) start = FALSE; /* Erster Wert unbrauchbar */
else data[zaehlertief]++;
gclear();
for ( i = 0; i <= 255; i++ ) {
if ( i == 0 ) gpos(i, data[i]);
else gdraw(i, data[i]);
}
} while ( !kbhit() );
t_stop(); /* Desinstalliere Timer */
printf("\nDr�cke Taste..."); getch(); getch();
gend();
}
int Restart_read_driver(char *dmpname, int mdmpflag, int memflag)
{
char *me = "Restart_read_driver";
char *kern, *rem, *infostr;
char msg[MAXLINE];
int i, error = 0, ierr;
int num, mycyc, iblk, gblk, namelen;
int mynblk;
int numBlocks, numDomains;
int *domainFiles;
DBfile *idbid;
RGST_AttributeElem_t *func;
if (memflag == 1) {
memclr() ;
}
comlock(dmp_nbaton);
if (mdmpflag) {
kern = strtok(dmpname,"-");
rem = strtok(NULL,"-");
mycyc = atoi(rem);
RestartCycle = mycyc;
strcpy(RestartKernel,kern);
rootfile_read(kern,mycyc);
} else {
namelen = strlen(dmpname);
if (namelen > 10) {
memset(msg,'\0',MAXLINE);
strncpy(RestartKernel,dmpname,namelen - 10);
RestartKernel[namelen - 9] = '\0';
i = strlen(dmpname) - 10;
strncpy(msg,&(dmpname[i]), 5);
RestartCycle = atoi(msg);
} else {
}
idbid = DBOpen (dmpname, DB_PDB, DB_READ);
if (idbid == NULL) {
error = 1 ;
sprintf(msg,"Can't open dump %s\n",dmpname);
ctlwarning(me,msg);
return(error) ;
}
infostr = DBGetVar (idbid, "_fileinfo");
namelen = strlen(codename);
if (strncmp (infostr, codename, namelen) != 0) {
sprintf(msg,"Restarting from a dump which is not %s. This is EVIL!\n",
codename);
ctlwarning(me,msg);
}
FREEMEM(infostr);
decomp_setdir(idbid);
ierr = DBReadVar(idbid,"NumBlocks",&numBlocks);
ierr += DBReadVar(idbid,"NumDomains",&numDomains);
if (ierr != 0) ctlerror(me,gv_errmsg_DBReadVar);
decomp_new(numBlocks, numDomains);
decomp_read(idbid, msg, 0, 0);
if (DBSetDir(idbid, "/") != 0) ctlerror(me,gv_errmsg_DBSetDir);
error += Restart_read_global(idbid);
dmpattr_set();
domainFiles = MALLOT(int, gnblk);
for (gblk = 0; gblk < gnblk; gblk++) {
domainFiles[gblk] = gmap[gblk].lblk;
}
calculate_mappings();
mynblk = 0;
for (gblk = 0; gblk < gnblk; gblk++) {
if (gmap[gblk].proc != myid) continue;
iblk = gmap[gblk].lblk;
Restart_read_domain(idbid, domainFiles[gblk], iblk);
mynblk++;
}
nblk = mynblk;
DBClose(idbid);
FREEMEM(domainFiles);
}
dmpattr_unset();
comunlock(dmp_nbaton);
ifparallel = 0;
nblk = gnblk;
initcom(NULL,0);
sprintf(msg,"dump '%s' read",dmpname);
ctlmsg(msg);
printtc() ;
func = rgst_list_attr(A_OBJECT, "Function_Gen");
while (func != NULL) {
Command_t *cp = (Command_t *) func->rgst_obj->obj;
(*(cp->proc))();
func = func->next;
}
blknum = 0 ;
genmd = -1;
error += qbnd(FULL_STEP,COM_RECV);
error += qbnd(FULL_STEP,COM_SEND);
error += qbnd(FULL_STEP,COM_WAIT_RECV);
TimeStepControl_initialize() ;
for ( iblk = 0 ; iblk < nblk ; iblk++ ) {
updateblk( &domains[iblk], 0, 0.0 ) ;
}
;
error += qbnd(FULL_STEP,COM_WAIT_SEND);
editor(FULL_STEP);
genmd = 0;
hash_optimize_all();
return(0);
}
int gen( void )
{
char *me = "gen";
char msg[MAXLINE];
int i,ir,error,iblk ;
int ibc, gblk, lblk ;
int len ;
int *zdx_in ;
RGST_AttributeElem_t *func ;
error = 0 ;
if ( (ifcom) && (!ifparallel) ) {
bndry_init() ;
}
for ( ir = 1 ; ir <= nreg ; ir++ ) {
neosgroup = MAX( neosgroup, reg[ir].numGroups ) ;
}
if ( neosgroup == 1 ) {
neosgroup = 0 ;
}
if ( ifvsame ) {
vsameorg() ;
}
regen_reset() ;
genmd = 1 ;
if ( !ifparallel ) {
initcom( NULL, 0 ) ;
}
if (ifcom) {
bndry_setmomflx() ;
bndry_zdxneighbor() ;
}
sewbndry() ;
if ( ifparallel ) {
initcombufs() ;
}
; if ( nspec > 0 ) {
species_init() ;
} else {
ifdynspec = 0 ;
ProblemArray_del("specfrac", NULL) ;
}
sanityck() ;
swapcoords() ;
func = rgst_list_attr(A_OBJECT, "Function_Gen") ;
while ( func != NULL ) {
Command_t *cp = (Command_t *) func->rgst_obj->obj ;
(*(cp->proc))() ;
func = func->next ;
}
for ( iblk = 0 ; iblk < nblk ; iblk++ ) {
error += blkgen( &domains[iblk] ) ;
}
if ( ifcom ) {
comverify() ;
}
eos_init(1) ;
if ( ifconvert == 0 ) {
for ( iblk = 0 ; iblk < nblk ; iblk++ ) {
getematblk( 1, &domains[iblk] ) ;
}
}
TimeStepControl_initialize() ;
error += update( 0.0, 0 ) ;
if ( ndeltat < deltat ) {
deltat = ndeltat ;
}
deltatSubcycle = deltat ;
error += editor( FULL_STEP ) ;
genmd = 0 ;
hash_optimize_all();
return(error) ;
}
int rdsilogrid( void )
{
char *me = "rdsilogrid";
char msg[MAXLINE];
char op[MAXLINE];
char name[MAXLINE];
int i;
int gblk;
int nlocaldom;
int error;
int *localdom;
DBfile *idbid;
Extents_t ext;
geta(op);
if (genmd != 1) {
sprintf(msg, "Attempting to read silo mesh before memory has been allocated.\n\t\tAre you in merge phase?\n\t\t Did you forget the -sew on the command line?");
ctlerror(me,msg);
}
comlock(dmp_nbaton);
idbid = DBOpen (op, DB_PDB, DB_READ);
if (idbid == NULL) {
sprintf(msg,"Cannot open silo file %s.\n",op);
ctlerror(me,msg);
}
decomp_setdir(idbid);
decomp_read(idbid, name, 0, 0);
error = DBSetDir(idbid,"/");
DBShowErrors(DB_NONE, NULL);
error = DBSetDir(idbid,"/Global/Nodelists");
if (error != 0) error = DBSetDir(idbid,"Nodelists");
if (error == 0) {
NodeList_rdsilo(idbid,0);
}
DBShowErrors(DB_TOP, NULL);
error = DBSetDir(idbid,"/");
nlocaldom = 0;
localdom = MALLOT(int,gnblk);
for (gblk = 0; gblk < gnblk; gblk++) {
if (gmap[gblk].lblk >= 0) {
localdom[nlocaldom++] = gblk;
}
}
calculate_mappings();
for (i = 0; i < nlocaldom; i++) {
gblk = localdom[i];
if (gmap[gblk].proc == myid) {
sprintf(op,"/%s%i",name,i);
error = DBSetDir(idbid,op);
TRSEXT(domains[nblk],gmap[gblk],gmap[gblk]);
if (ndims == 2) {
domains[nblk].kmin = 0;
domains[nblk].kmax = 0;
domains[nblk].type = QUAD2D;
} else {
domains[nblk].type = HEX3D;
}
domains[nblk].sclnamix = sclnamix;
initblk(nblk,&domains[nblk]);
domains[nblk].gblk = gblk;
domain_hash_tbl_rgst(&(domains[nblk]));
CPYEXT(ext,domains[nblk]);
rdsilomesh(idbid, "hydro_mesh", domains[nblk].x, domains[nblk].y,
domains[nblk].z, domains[nblk].node, ext, domains[nblk].jp,
domains[nblk].kp);
nblk++;
error = DBSetDir(idbid,"/");
}
}
FREEMEM(localdom);
DBClose(idbid);
comunlock(dmp_nbaton);
if (ifparallel) {
bndry_init();
initcom( NULL, 0);
varcom_bufinit();
}
return(0);
}
int blockin0( int type ) {
char *me = "blockin0";
char op[10],msg[MAXLINE];
int cflag;
int imax, jmax, kmax;
int gblk;
if (nblk >= nblkx-1) {
sprintf(msg,"number of blocks exceeds nblkx = %d",nblkx);
ctlwarning(me,msg);
return(1);
}
if ((type == QUAD2D) && (ndims == 3)) {
sprintf(msg,"You are specifying a 2D mesh in a 3D problem.\n\t\tYou might want to use hex instead of the quad command.");
ctlerror(me,msg);
}
if ((type == HEX3D) && (ndims == 2)) {
sprintf(msg,"You are specifying a 3D mesh in a 2D problem.\n\t\tYou might want to use quad instead of the hex command.\n\t\tOr you might want to set ndims to 3.");
ctlerror(me,msg);
}
if (type == QUAD2D) {
imax = geti(&cflag) + NPNL - 1;
jmax = geti(&cflag) + NPNL - 1;
domains[nblk].type = QUAD2D ;
domains[nblk].imin = NPNL ;
domains[nblk].jmin = NPNL ;
domains[nblk].kmin = 0 ;
domains[nblk].imax = imax;
domains[nblk].jmax = jmax;
domains[nblk].kmax = 0 ;
} else if (type == HEX3D) {
imax = geti(&cflag) + NPNL - 1;
jmax = geti(&cflag) + NPNL - 1;
kmax = geti(&cflag) + NPNL - 1;
domains[nblk].type = HEX3D ;
domains[nblk].imin = NPNL ;
domains[nblk].jmin = NPNL ;
domains[nblk].kmin = NPNL ;
domains[nblk].imax = imax;
domains[nblk].jmax = jmax;
domains[nblk].kmax = kmax;
} else {
sprintf(msg,"unknown block type '%s'",op);
ctlwarning(me,msg);
return(1);
}
if (ifparallel) {
if (unblk > 1) {
sprintf(msg,"You may not use parallel mesh generation on multi-block problems.");
ctlerror(me,msg);
}
blknum = unblk ;
domains[nblk].jp = domains[nblk].imax - domains[nblk].imin +
1 + NPNL + NPNR;
domains[nblk].kp = 0;
if (ndims == 3) {
domains[nblk].kp = domains[nblk].jp * (domains[nblk].jmax -
domains[nblk].jmin + 1 + NPNL + NPNR);
}
setumap( &domains[nblk] ) ;
peekc(op);
if (strcmp(op,"blkdiv")) {
if (nblkx <= num_procs) {
sprintf(msg,"Number of domains (%i) exceeds nblkx (%i). Please increase nblkx.",num_procs,nblkx);
ctlerror(me,msg);
}
blkdivin(1);
} else {
geta(op);
blkdivin(0);
}
if (nblkx <= num_procs) {
sprintf(msg,"Number of domains (%i) exceeds nblkx (%i). Please increase nblkx.",num_procs,nblkx);
ctlerror(me,msg);
}
calculate_mappings();
for (gblk = 0; gblk < gnblk; gblk++) {
if (gmap[gblk].proc == myid) {
domains[nblk].type = type ;
domains[nblk].sclnamix = sclnamix ;
TRSEXT(domains[nblk],gmap[gblk],gmap[gblk]);
if (ndims == 2) {
domains[nblk].kmin = 0;
domains[nblk].kmax = 0;
}
initblk(nblk,&domains[nblk]);
domains[nblk].gblk = gblk;
domain_hash_tbl_rgst(&(domains[nblk]));
nblk++;
}
}
if (ifparallel) {
bndry_init();
initcom( NULL, 0);
varcom_bufinit();
}
} else {
peekc(op);
if (!strcmp(op,"blkdiv")) {
sprintf(msg,"blkdiv command may only appear after quad or hex during parallel \n\t\tgeneration.");
ctlerror(me,msg);
}
domains[nblk].sclnamix = sclnamix ;
initblk( nblk, &domains[nblk] ) ;
setumap( &domains[nblk] ) ;
blknum = nblk ;
nblk++ ;
}
return(0) ;
}
