Recreational Computing

Programming for Fun

If you'd like to do some recreational computing, but don't want to spend a lot of time learning a big language that you will forget if you don't use it every day, try HTML and JavaScript. These two languages are very easy to learn, and you can use them together to produce some pretty cool applications. Additionally, both languages are free, and programs are written in any text editor. You don't need to buy any books because there are many free tutorials and reference libraries online. Using only these free resources, I learned enough to create this website and write the JavaScript applications below. You can see the code that produced them by viewing the page source.

Some JavaScript Examples

These are calculators I use for running, cycling, and in my job developing new medical products.

Accelerated Aging	Cycling Power	Daniels' Running Formula	Dilution Calculator
Mixing Calculator	Pressure Decay Wizard	Random Event Simulator	Road Grade Calculator
Running Pace Calculator	Specific Gravity	Syringe Pressure	Tapered Pins & Holes
Temperature Converter	Thermal Expansion	Tubing Fitment Wizard	Units Conversion
Vacuum in Vials

My Programming Background

While in college (about 1977) I learned how to program in FORTRAN. Each instruction had to be entered on a separate punch card, so the final program ended up being a stack that had to be fed into a noisy card reader. If someone had walked up to me while I was waiting in line at the card reader with my "deck" of cards and told me that I would soon have my own tabletop computer, I would not have believed it. Yet, by 1980 I did have my own computer, a Timex Sinclair ZX80. I taught myself BASIC and wrote some simple utilities and games. As I upgraded to a Commodore Vic 20, a Commodore 64, then a PC which I built myself, I gave my old computers to my little brother, who eventually majored in Computer Science when he went to college.

With the help of an electronics engineer, I made an interface to my shortwave radio and wrote a program in BASIC that translated Morse Code from the radio into text on the screen. Soon after that I taught myself C (Borland's Turbo C) and started writing physical simulations (e.g.,gas pressure regulator), astronomical simulations (e.g.,comet orbits and planets orbiting double stars), and explored graphics and fractals. I wanted to write Windows applications, so I tried to move to Visual C++ a couple of times, but it is too complex to use only occasionally. So I taught myself Java, which is quite a bit easier.

In 2006 I took "Advanced Topics in Java" at Saddleback College, and for one assignment we had to create a simple Craps game. My algorithm to draw the dots on a die used only 3 statements. The instructor's version took 37 statements! He was impressed enough to post my code on the class website. If you do not see a pair of dice, download the latest Java plug-in, or just scroll down to look at lines 70, 71 and 72.

Below are a few Applets and C source files. All programs and code on this page were written by me.

A few Java Applets

Color Pallet	Cycling Wattage	Drum Machine	Metronome
Musical Note Flashcards	Quadratic Equation Solver	Road Grade Calculator	Running Pace Calculator
Tapered Pin Calculator	Temperature Converter	.	.

A little C Source Code

Solar Orbit

/* ---------------------------------------------------------------------------- SUN AND PLANET TFF 1/26/90 --------------------------------------------------------------------------- */ #include < stdlib.h > #include < conio.h > #include < graphics.h > #include < math.h > #define PI 3.14159 /* pi */ #define G 6.67E-11 /* gravitational constant */ #define MS 1.987E+30 /* mass of the sun */ #define AU 1.5E+11 /* astronomical unit */ float k; /* constant = G * M */ float r; /* planet's distance from sun */ float v; /* linear velocity of planet */ float a; /* angular position of planet */ float b; /* angle of planet's initial trajectory */ float dt; /* time interval between iterations */ float x,y; /* position coordinates for planet */ float vx,vy; /* velocity components for planet */ process_input() { textmode(C80); clrscr(); printf("\n SUN AND PLANET ORBITAL SIMULATION\n"); printf("\n Tom Fangrow, Corona, CA 1/26/91"); printf("\n\n\nDATA FOR ONE PLANET"); /*********************************/ printf("\nInitial distance from sun (au) "); scanf("%f",&r); /* input distance */ r*=AU; /* convert to meters */ printf("Initial velocity of planet (km/sec) "); scanf("%f",&v); /* input velocity */ v*=1000; /* convert to meters */ printf("Initial angular position (degrees) "); scanf("%f",&a); /* input position */ a*=PI/180.0; /* convert to radians */ printf("Angle of initial trajectory (deg) "); scanf("%f",&b); /* input angle */ b*=PI/180.0; /* convert to radians */ printf("\nIteration time interval (days) "); scanf("%f",&dt); /* input time increment */ dt*=60.0*60.0*24.0; /* convert to seconds */ /* ------------------------- INITIAL CONDITIONS ------------------------- */ k=G*MS; x=r*cos(a); /* initial x position of planet */ y=-r*sin(a); /* initial y position of planet */ vx=v*cos(b); /* x component of planet's velocity */ vy=-v*sin(b); /* y component of planet's velocity */ } process_orbit() { float rs; /* square of radius */ float c; /* actual acceleration */ float ax; /* x component of acceleration */ float ay; /* y component of acceleration */ float scale; /* screen scaling factor */ int px; /* x screen coordinates */ int py; /* y screen coordinates */ int cx, cy; /* coordinates of screen center */ int gdriver=DETECT, gmode; /* use highest resolution available */ int n=0; /* loop counter */ char str1[6]; /* string to hold n */ void *mask; /* string to hide old n */ initgraph(&gdriver, &gmode, ""); cx=getmaxx()/2; /* x resolution */ cy=getmaxy()/2; /* y resolution */ putpixel(cx,cy,YELLOW); /* mark the sun */ scale = .5*cx/r; /* scale screen to seperations */ mask=malloc(imagesize(0,0,48,8)); getimage(0,0,48,8,mask); /* ----------------------------- MAIN LOOP ----------------------------- */ while(!kbhit()) { /* plot the planet's path until a key is pressed */ rs=x*x+y*y; /* square of planet's distance from sun */ r=sqrt(rs); /* planet's distance from sun */ c=-k/rs; /* acceleration of planet toward sun */ ax=c*x/r; ay=c*y/r; vx+=ax*dt; /* velocity and displacement of planet */ vy+=ay*dt; x+=vx*dt; y+=vy*dt; px=cx+(int)(x*scale); /* calculate screen coordinates */ py=cy+(int)(y*scale); putpixel(px,py,GREEN); /* display the planet */ sprintf(str1,"%u",n++); /* number of iterations */ putimage(0,0,mask,COPY_PUT); outtextxy(0,0,str1); } } main() { process_input(); process_orbit(); restorecrtmode(); }

Mandelbrot Set Generator

/* MANDEL.C - Mandelbrot set generator Translated from my BASICA program July 21, 1990 Revised to work in any graphics mode Feb 2, 1991 Added routine to save image to disk April 2, 1991 */ #include < stdio.h > #include < graphics.h > #define TEST 200 FILE *fopen(), *fp; save() { int x, y, current, color, count=0; current=getpixel(0,0); chdir("c:\\data"); fp=fopen("mandel.vga", "wb"); for(y=0;y < getmaxy();y++) { for(x=0;x < getmaxx();x++) { color=getpixel(x,y); if((color == current) && (count<255)) count++; else { fputc(current, fp); fputc(count, fp); current = color; count=0; } } } fclose(fp); chdir("c:\\tc"); } main() { int n, /* counter */ ox, /* location of origin on real axis */ oy, /* location of origin on imaginary axis */ xasp, /* x aspect ratio */ yasp; /* y aspect ratio */ int gdriver = DETECT, gmode; /* detects highest resolution available */ float i, /* imaginary coordinate */ r, /* real coordinate */ ci, /* imaginary part of constant */ cr, /* real part of constant */ zi, /* dummy variable */ zr, /* dummy variable */ ti, /* imaginary part of total */ tr, /* real part of total */ stepx, /* distance between points */ stepy, /* distance between points */ scalex, /* inverse of stepx */ scaley, /* inverse of stepy */ aspratio; /* aspect ratio of screen */ initgraph( &gdriver, &gmode, ""); /* go to graphics screen */ ox = getmaxx() / 2; /* x value of screen center */ oy = getmaxy() / 2; /* y value of screen center */ getaspectratio(&xasp,&yasp); /* detect aspect values */ aspratio=(float)(xasp)/(float)(yasp); /* calculate aspect ratio */ stepx = 4.0*aspratio/getmaxy(); /* x iteration step size */ stepy = 4.0/getmaxy(); /* y iteration step size */ scalex = 1 / stepx; /* x screen scaling value */ scaley = 1 / stepy; /* y screen scaling value */ /* ---------------------------- MAIN ROUTINE -------------------------- */ for( i = 2.0; i > 0.0; i -= stepy) { for( r = -2.0; r < = 2.0; r += stepx) { cr = r; ci = i; zr = 0; zi = 0; tr = 0; ti = 0; n = 0; while( n < TEST && ( ti*ti + tr*tr ) < 4.0 ) { ti = 2.0 * ( zr * zi ) + ci; tr = zr * zr - zi * zi + cr; zr = tr; zi = ti; n++; } if( n == TEST ) { putpixel(ox+scalex*r,oy+scaley*i,0); putpixel(ox+scalex*r,oy-scaley*i,0); } else { putpixel(ox+scalex*r,oy+scaley*i, 1 + ( n & 1 ) ); putpixel(ox+scalex*r,oy-scaley*i, 1 + ( n & 1 ) ); } } if(kbhit()) if(getch()==27) break; } save(); do{} while(getch()!=27); restorecrtmode(); }

Planet and Double Star

/* ---------------------------------------------------------------------------- DOUBLE STAR AND PLANET TFF 1/24/91 --------------------------------------------------------------------------- */ #include < stdlib.h > #include < conio.h > #include < graphics.h > #include < math.h > #define PI 3.14159 /* pi */ #define G 6.67E-11 /* gravitational constant */ #define MS 1.987E+30 /* mass of the sun */ #define AU 1.5E+11 /* astronomical unit */ float m1, m2; /* masses of stars in solar masses */ float k1, k2; /* constant = G * M */ float s; /* seperation of stars in AU */ float s1, s2; /* distance of stars from barycenter */ float v1, v2; /* linear velocities of stars */ float r; /* planet's distance from barycenter */ float v; /* linear velocity of planet */ float a; /* angular position of planet */ float b; /* angle of planet's initial trajectory */ float dt; /* time interval between iterations */ float x1, x2, x3, y1, y2, y3; /* position coordinates for 3 bodies */ float vx1, vx2, vx3, vy1, vy2, vy3; /* velocity components for 3 bodies */ process_input() { textmode(C80); clrscr(); printf("\n DOUBLE STAR AND PLANET ORBITAL SIMULATION\n"); printf("\n Tom Fangrow, Corona, CA 1/24/91"); printf("\n\n\nDATA FOR TWO STARS"); /*********************************/ printf("\nMass of large star (solar masses) "); scanf("%f",&m1); /* input m1 */ m1*=MS; /* convert to kilograms */ k1=G*m1; /* calculate constant */ printf("Mass of small star (solar masses) "); scanf("%f",&m2); /* input m2 */ m2*=MS; /* convert to kilograms */ k2=G*m2; /* calculate constant */ printf("Seperation of stars (ast units) "); scanf("%f",&s); /* input seperation */ s*=AU; /* convert to meters */ s2=s*(m1/(m1+m2)); /* distance of small star from barycenter */ s1=s-s2; /* distance of large star from barycenter */ printf("Velocity of large star (km/sec) "); scanf("%f",&v1); /* input v1 */ v1*=1000; /* convert to meters */ v2=v1*m1/m2; /* velocity of small star */ printf("\nDATA FOR ONE PLANET"); /*********************************/ printf("\nInitial distance from barycenter (au) "); scanf("%f",&r); /* input distance */ r*=AU; /* convert to meters */ printf("Initial velocity of planet (km/sec) "); scanf("%f",&v); /* input velocity */ v*=1000; /* convert to meters */ printf("Initial angular position (degrees) "); scanf("%f",&a); /* input position */ a*=PI/180.0; /* convert to radians */ printf("Angle of initial trajectory (deg) "); scanf("%f",&b); /* input angle */ b*=PI/180.0; /* convert to radians */ printf("\nIteration time interval (days) "); scanf("%f",&dt); /* input time increment */ dt*=60.0*60.0*24.0; /* convert to seconds */ /* ------------------------- INITIAL CONDITIONS ------------------------- */ x1=-s1; /* large star starts on left side of barycenter */ x2=s2; /* small right */ x3=r*cos(a); /* initial x position of planet */ y1=0; y2=0; y3=-r*sin(a); /* initial y position of planet */ vx1=0; vx2=0; vx3=v*cos(b); /* x component of planet's velocity */ vy1=v1; /* large star starts moving down */ vy2=-v2; /* small star starts moving up */ vy3=-v*sin(b); /* y component of planet's velocity */ } process_orbit() { float x12, x31, x32; /* x component of seperations */ float y12, y31, y32; /* y component of seperations */ float rs12, rs31, rs32; /* squares of seperations */ float r12, r31, r32; /* actual seperations */ float c; /* actual acceleration */ float ax1, ax2, ax3; /* x component of acceleration */ float ay1, ay2, ay3; /* y component of acceleration */ float scale; /* screen scaling factor */ int px1=0, px2=0, px3; /* x screen coordinates */ int py1=0, py2=0, py3; /* y screen coordinates */ int cx, cy; /* coordinates of screen center */ int gdriver=DETECT, gmode; /* use highest resolution available */ initgraph(&gdriver, &gmode, ""); cx=getmaxx()/2; /* x resolution */ cy=getmaxy()/2; /* y resolution */ scale = .5*cx/((r < s )? s:r); /* scale screen to seperations */ /* ----------------------------- MAIN LOOP ----------------------------- */ while(!kbhit()) { /* plot the three bodies until a key is pressed */ x12=x1-x2; /* distance between star 1 and 2 */ y12=y1-y2; rs12=x12*x12+y12*y12; r12=sqrt(rs12); x31=x3-x1; /* distance between planet and star 1 */ y31=y3-y1; rs31=x31*x31+y31*y31; r31=sqrt(rs31); x32=x3-x2; /* distance between planet and star 2 */ y32=y3-y2; rs32=x32*x32+y32*y32; r32=sqrt(rs32); c=-k2/rs12; /* acceleration of star 1 */ ax1=c*x12/r12; ay1=c*y12/r12; c=-k1/rs12; /* acceleration of star 2 */ ax2=-c*x12/r12; ay2=-c*y12/r12; c=-k2/rs32; /* acceleration of planet toward star 2 */ ax3=c*x32/r32; ay3=c*y32/r32; c=-k1/rs31; /* add acceleration toward star 1 */ ax3+=c*x31/r31; ay3+=c*y31/r31; vx1+=ax1*dt; /* velocity and displacement of large star */ vy1+=ay1*dt; x1+=vx1*dt; y1+=vy1*dt; vx2+=ax2*dt; /* velocity and displacement of small star */ vy2+=ay2*dt; x2+=vx2*dt; y2+=vy2*dt; vx3+=ax3*dt; /* velocity and displacement of planet */ vy3+=ay3*dt; x3+=vx3*dt; y3+=vy3*dt; putpixel(px1,py1,0); /* turn off stars at old position */ putpixel(px2,py2,0); px1=cx+(int)(x1*scale); /* calculate screen coordinates */ px2=cx+(int)(x2*scale); px3=cx+(int)(x3*scale); py1=cy+(int)(y1*scale); py2=cy+(int)(y2*scale); py3=cy+(int)(y3*scale); putpixel(px1,py1,WHITE); /* display large star */ putpixel(px2,py2,WHITE); /* display small star */ putpixel(px3,py3,GREEN); /* display the planet */ putpixel(cx,cy,YELLOW); /* mark the barycenter */ } } main() { process_input(); process_orbit(); restorecrtmode(); }

Fractal Trees

/* branch2 1/22/92 */ /* This version has automatic scaling */ #include < graphics.h > #include < stdio.h > #include < conio.h > #include < stdlib.h > #include < math.h > int t,n; float r,a; getdata() { printf("\n\n\n\n\n Branch length (%% of trunk length): "); scanf("%f",&r); r/=100; printf("\n Number of branchings (1 to 10): "); scanf("%d",&n); if(n < 1) n=1; if(n > 10) n=10; printf("\n Angle between branches (degrees): "); scanf("%f",&a); a/=2; a*=3.1416/180; } scale() { int i, maxy; float h=0; maxy=.9*getmaxy(); for(i=0; i < n; i++) { /* total height of tree for */ if(i & 1) /* angles <= 180 is: */ h+=pow(r,(double)(i+1)); /* t+rtcos(a)+rrt+rrrtcos(a)... */ else /* =t(1+rcos(a)+rr+rrrcos(a)... */ h+=cos(a)*pow(r,(double)(i+1)); /* so maxy=t(...) and t=maxy/() */ } t=maxy/(1+h); if(t > maxy) t=maxy; } plotdata() { float *e; int maxx, maxy; int i=1,j=1,k=1, u, v, w, s=0; float c1,c2,xt,yt,xh,yh; maxx=getmaxx(); maxy=getmaxy(); e=calloc(1 << (n+2),sizeof(float)); e[1]=maxx/2; e[2]=maxy-1; e[3]=maxx/2; e[4]=e[2]-t; c1=r*cos(a); c2=r*sin(a); for (u=1;u < =1 << (n-1);u++) { for (v=1;v < =2;v++) { for (w=1;w < =2;w++) { if (s) { xt=e[j]-e[i]; yt=e[j+1]-e[i+1]; xh=e[j]+xt*c1; yh=e[j+1]+yt*c1; e[k]=xh+yt*c2; e[k+1]=yh-xt*c2; e[k+2]=xh-yt*c2; e[k+3]=yh+xt*c2; s=0; } line ((int)(e[j]),(int)(e[j+1]),(int)(e[k]),(int)(e[k+1])); k+=2; } j+=2; s=1; } i+=2; } free(e); /* de-allocate memory */ } main() { int driv=DETECT, mode; char c; initgraph(&driv, &mode, ""); do { restorecrtmode(); getdata(); setgraphmode(mode); scale(); plotdata(); outtextxy(0,10,"Press any key to continue or 'q' to quit."); c=getch(); } while (c != 'q' && c != 'Q'); restorecrtmode(); }

Morse Code Reader

/* MORSE DECODER - Program to translate Morse code into English */ /* Translated (sort of) from my BASIC program 4/4/91 TFF */ /* Converted to mouse button input 11/06/94 TFF */ #include < time.h > #include < stdlib.h > #define ON 1 /* left mouse button pressed */ #define OFF 0 /* not pressed */ clock_t start, end; load_array(char a[]) { strcpy(a," ETINAMSDRGUKWOHBLZFCP VX Q YJ 56 7 8 / 94 3 " "2 10 : ? ' ' - . ( ,"); } wait(int condition) { int b, x, y; do { get_position(&b, &x, &y); /* keep checking mouse button */ } while(b&1 != condition); /* until desired condition met */ } gettime() { return((end=clock())-start); } main() { int beep, x=6, c=0, d=0, l=0, status, xm, ym; char k[115]; load_array(k); init_mouse(); do { start=clock(); do { /* wait for beep, but */ get_position(&status, &xm, &ym); /* no longer than the */ } while(((status&1) == OFF) && (gettime() < x)); /* time between chars */ if((status&1) == ON) { /* beep, so must be middle of character */ start=clock(); sound(880); wait(OFF); /* wait for beep to end */ nosound(); if((beep=gettime()) > x) { /* if beep longer than x */ d=1; /* then its a dash */ x=beep*2/3; /* adjust timing with every dash */ } else { /* else beep is a dot */ d=0; x=beep*2; /* adjust timing with every dot */ } c+=d*(1 << l); /* c is the value of the lth bit */ l++; /* increment length of character */ } else { /* time ran out; must be end of character */ if(l > 6) /* if character too long, error! */ cputs(" "); /* so print a blank space */ putch(k[c-1+(1 << l)]); /* print calculated character */ c=0; l=0; } } while(!kbhit()); }

Solar System

/* PCORBITS - Solar System Simulation - Tom Fangrow 6/18/91 */ #include < math.h > #include < conio.h > #include < stdlib.h > #include < graphics.h > #define PI 3.14159 #define BACK BLACK #define SUN YELLOW float au[9]={ .387, /* mercury */ /* distance */ .723, /* venus */ /* from sun */ 1.000, /* earth */ /* in AU */ 1.524, /* mars */ 5.203, /* jupiter */ 9.539, /* saturn */ 19.191, /* uranus */ 30.061, /* neptune */ 39.529 }; /* pluto */ float yr[9]={ .24085, /* mercury */ /* revolution */ .61521, /* venus */ /* period in */ 1.00004, /* earth */ /* years */ 1.88089, /* mars */ 11.86223, /* jupiter */ 29.45772, /* saturn */ 84.01320, /* uranus */ 164.79375, /* neptune */ 248.4302 }; /* pluto */ int co[9]={LIGHTGRAY, WHITE, LIGHTCYAN, LIGHTRED, /* display colors */ YELLOW, YELLOW, CYAN, CYAN, LIGHTGRAY}; float pa[9]={222.6, 174.3, 100.2, 258.8, /* phase angles */ 259.8, 280.7, 141.3, 216.9, 181.6}; char mo[12][4]={"Jan", "Feb", "Mar", "Apr", "May", "Jun", /* months */ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; float arg[9], t, date=1000.0, theta, inc, del=5000.0, scale=20.0; int px[9], py[9], sunx=240, suny=240, z, gdriver=DETECT, gmode; void *mask; convert() { int i; for(i=0; i < 9; i++) { /* for each planet */ arg[i]=-2*PI/yr[i]; /* change period to frequency */ pa[i]*=PI/180; /* change degrees to radians */ } } start_screen() { char *str="PCORBITS"; int cx, cy, tx, ty; cx=getmaxx()/2; cy=getmaxy()/2; setfillstyle(SOLID_FILL, SUN); /* draw a sun by using a */ setcolor(SUN); /* circle floodfilled with */ circle(cx, cy, 10); /* the color SUN */ floodfill(cx, cy, SUN); inc=-.02; setfillstyle(SOLID_FILL, BACK); settextjustify(CENTER_TEXT, CENTER_TEXT); setcolor(CYAN); settextstyle(TRIPLEX_FONT, HORIZ_DIR, USER_CHAR_SIZE); setusercharsize(1, 1, 1, 1); outtextxy(cx, 40, "PCORBITS"); setusercharsize(2, 3, 2, 3); outtextxy(cx, 80, "A Simulation of our Solar System."); outtextxy(cx, 420, "Strike any key to continue."); setcolor(WHITE); setusercharsize(1, 2, 1, 2); settextstyle(DEFAULT_FONT, HORIZ_DIR, USER_CHAR_SIZE); do { for(theta=0; theta < 2*PI; theta+=inc) { tx=cx+100*cos(theta); ty=cy+100*sin(theta); outtextxy(tx, ty, str); delay(500); bar(tx-31, ty-5, tx+30, ty+5); if(kbhit()) break; } }while(!kbhit()); } get_year() { char s[7]; restorecrtmode(); textbackground(BLUE); textcolor(YELLOW); gotoxy(28, 1); cputs("INTERESTING DATES TO TRY\n"); puts(""); puts("Transits of Mercury:"); puts("Nov 7, 1677, Nov 9, 1690, Nov 7, 1697, May 5, 1707, Nov 6, 1710"); puts("Nov 9, 1723, Nov 10, 1736, May 2, 1740, Nov 4, 1743, May 5, 1753"); puts("Nov 6, 1756, Nov 9, 1769, Nov 2, 1776, Nov 12, 1782, May 3, 1786"); puts("Nov 5, 1789, May 7, 1799, Nov 8, 1802, Nov 11, 1813, Nov 4, 1822"); puts("May 5, 1832, Nov 7, 1835, May 8, 1845, Nov 9, 1848, Nov 11, 1861"); puts("Nov 4, 1868, May 6, 1878, Nov 7, 1881, May 9, 1891, Nov 10, 1894"); puts("Nov 14, 1907, Nov 7, 1914, May 7, 1924, Nov 9, 1927, Nov 11, 1940"); puts("Nov 14, 1953, May 5, 1957, Nov 7, 1960, May 8, 1970, Nov 9, 1973"); puts("Nov 12, 1986, Nov 5, 1993, Nov 15, 1999, May 6, 2003"); puts(""); puts("Transits of Venus:"); puts("Jun 2, 1518, Jun 1, 1526, Dec 7, 1631, Dec 4, 1639, Jun 6, 1761"); puts("Jun 3, 1769, Dec 9, 1874, Dec 6, 1882, Jun 8, 2004"); textbackground(BLACK); textcolor(YELLOW+BLINK); gotoxy(20, 20); cputs("Enter the year (-32000 to +32000): "); gets(s); z=atoi(s); return(z-1960); } command_screen() { cleardevice(); setfillstyle(SOLID_FILL, DARKGRAY); bar(480, 1, 638, 478); rectangle(0, 0, 639, 479); line(479, 0, 479, 479); setfillstyle(SOLID_FILL, BACK); setcolor(LIGHTCYAN); settextjustify(LEFT_TEXT, CENTER_TEXT); outtextxy(510, 40, "D = NEW DATE"); outtextxy(510, 90, "I = ZOOM IN"); outtextxy(510, 140, "O = ZOOM OUT"); outtextxy(510, 190, "F = FASTER"); outtextxy(510, 240, "S = SLOWER"); outtextxy(510, 290, "R = REVERSE"); outtextxy(510, 300, " DIRECTION"); outtextxy(510, 340, "H = HORIZON AT"); outtextxy(510, 350, " SUNRISE/SET"); outtextxy(510, 390, "G = GO/STOP"); outtextxy(510, 440, "Q = QUIT"); setviewport(1, 1, 478, 478, 1); } orbits() { int i; while(!kbhit()) { for(i=0; i < 9; i++) { /* for 9 planets */ putpixel(px[i], py[i], BACK); putpixel(1+px[i], py[i], BACK); /* erase old */ px[i]=sunx+au[i]*scale*cos(arg[i]*t-pa[i]); py[i]=suny+au[i]*scale*sin(arg[i]*t-pa[i]); /* calculate new */ putpixel(px[i], py[i], co[i]); putpixel(1+px[i], py[i], co[i]); /* plot new */ } putpixel(sunx, suny, SUN); /* draw sun */ putpixel(sunx+1, suny, SUN); t+=inc; /* increment time */ show_date(); /* display date */ delay((int)(del)); /* pause */ } } show_date() { long p; int week, month, year; char str1[7]; putimage(5, 5, mask, COPY_PUT); date+=inc; p=(long)(48*date); /* 48 periods per year */ week=p%4; /* every period, count to 4 */ sprintf(str1, "WEEK %d", week+1); outtextxy(4, 30, str1); month=(p/4)%12; /* every 4th period, count to 12 */ outtextxy(15, 20, mo[month]); year=z-1000+p/48; /* every 48th period, count by 1 */ sprintf(str1, "%d", year); outtextxy(5, 10, str1); } horizon() { int endx, endy; endx=50*(px[2]-sunx); /* calculate */ endy=50*(py[2]-suny); /* endpoints */ setcolor(LIGHTBLUE); setlinestyle(USERBIT_LINE, 0x1111, 1); /* custom line */ line(sunx-endx, suny-endy, sunx+endx, suny+endy); getch(); /* wait for char */ setcolor(BACK); /* erase line */ line(sunx-endx, suny-endy, sunx+endx, suny+endy); setcolor(LIGHTCYAN); /* restore color */ } zoom_in() { if(scale < 220) { /* if earth still in viewport */ scale*=1.02; /* increase scale by 2 percent */ inc*=.98; /* decrease increment angle */ } /* for smoother movement */ } zoom_out() { if(scale>1) { /* if not at smallest scale */ scale*=.98; /* decrease scale by 2 percent */ inc*=1.02; /* increase increment angle */ } /* for faster movement */ } new_date() { t=get_year(); date=1000.0; setgraphmode(gmode); command_screen(); } main() { int quit=0; char key; initgraph(&gdriver, &gmode, ""); mask=malloc(imagesize(0, 0, 40, 27)); getimage(0, 0, 46, 27, mask); convert(); /* period to freq, deg to rad */ start_screen(); t=getch(); /* get rid of character */ t=get_year(); setgraphmode(gmode); command_screen(); inc=.005; do { orbits(); if(kbhit()) { key=toupper(getch()); switch(key) { case 'D': new_date(); break; case 'I': zoom_in(); break; case 'O': zoom_out(); break; case 'F': if(del>1) del*=0.9; break; case 'S': if(del<30000) del*=1.1; break; case 'R': inc=-inc; break; case 'G': getch(); break; case 'H': horizon(); break; case 'Q': quit=1; break; default : break; } } }while(!quit); restorecrtmode(); }

Gas Pressure Regulator

/* PISTREG.C - Simulation of piston-type pressure regulator. */ /* No pressure relief mechanism, friction forces, */ /* or inlet filter restrictions are included! */ /* Default configuration is LSPI model 735 or 106 */ /* without constant flow. Adapted from ALDUK.D */ /* program in BASIC. Tom Fangrow - 10/3/93 */ #include < math.h > #include < conio.h > #define ATPRESS 1.0 /* atmospheric pressure in bars */ #define PI 3.14 #define K 1.4 /* ratio of specific heats for air */ #define D1 2/(K+1) #define D2 (K+1)/(K-1) #define D3 pow(D1,D2/2) #define D4 2/(K-1) #define D5 2/K #define D6 (K-1)/K #define C1 33000.0 /* lumped constants for flow calculation */ #define C2 1000000.0 /* conversion from kg mass to dynes */ #define DT .0001 /* iteration time interval in seconds */ float inpress =1000.0, /* inlet pressure in psig */ outpress=ATPRESS, /* outlet pressure */ conpress=ATPRESS; /* control pressure */ float outvol=10.0, /* outlet volume in cubic cm */ convol=0.6; /* control volume in cubic cm */ float seatdi =.046, /* seat diameter in inches */ lgpistdi =.98, /* large diameter of piston in inches */ smpistdi =.278, /* small diameter of piston in inches */ pistnozdi=.073, /* nozzle diameter of piston (2 holes) */ outnozdi =.032; /* outlet nozzle diameter in inches */ float seatnoz, /* seat nozzle area */ pistnoz, /* piston nozzle area */ lgpistarea, /* area of top of piston */ smpistarea, /* area of bottom of piston */ outnoz; /* outlet nozzle area */ float floseat, /* flow through main seat */ flopist, /* flow through piston */ floout; /* flow through outlet */ float fspring=28.6, /* load of pressure spring in pounds */ rspring=113.0, /* rate of spring in pounds/inch */ fopen, /* force tending to open seat in kg */ fclose, /* force tending to close seat in kg */ fnet; /* net force on piston */ float mpiston=6.1, /* mass in grams of piston */ mspring=9.9; /* mass in grams of pressure spring */ float apiston, /* acceleration of piston */ vpiston=0.0, /* velocity of piston in cm/sec */ maxtravel=0.1, /* maximum travel of piston in cm */ xpiston; /* position of piston in cm */ float time=0.0; /* elapsed time of simulation */ float con[13]={1000.0, 10.0, 0.6, .046, 0.98, 0.278, 0.073, 0.032, 28.6, 113.0, 6.1, 9.9, 0.1}; /***************************** CONVERSIONS ******************************/ float in2cm(float x) { return(x*2.54); } float di2ar(float x) { return(PI*x*x/4); } float lb2kg(float x) { return(x*.45); } float psi2bar(float x) { x+=14.5; /* convert to absolute */ return(x/14.5); /* convert to bar */ } float convrate(float x) { return(x*.45/2.54); /* lb/in to kg/cm conversion */ } constants() /* convert and update constants */ { inpress=psi2bar(con[0]); outvol=con[1]; convol=con[2]; seatdi=in2cm(con[3]); /* convert seatdi to cm because */ seatnoz=di2ar(seatdi); /* it is used in main routine */ lgpistdi=con[4]; lgpistarea=di2ar(in2cm(lgpistdi)); smpistdi=con[5]; smpistarea=di2ar(in2cm(smpistdi)); pistnozdi=con[6]; pistnoz=di2ar(in2cm(pistnozdi)); outnozdi=con[7]; outnoz=di2ar(in2cm(outnozdi)); fspring=lb2kg(con[8]); rspring=convrate(con[9]); mpiston =con[10]; mspring =con[11]; maxtravel=con[12]; } viewcon() { int c; do { clrscr(); puts("\n\n CONSTANT DESCRIPTION STANDARD CURRENT\n"); printf(" 1 inlet pressure in psig 1000.0 %.0f\n", (inpress-1)*14.5); printf(" 2 volume of outlet space in cc 10.0 %.1f\n", outvol); printf(" 3 minimum control volume in cc 0.6 %.2f\n", convol); printf(" 4 diameter of seat in inches 0.046 %.3f\n", seatdi/2.54); printf(" 5 large dia of piston in inches 0.98 %.3f\n", lgpistdi); printf(" 6 small dia of piston in inches 0.278 %.3f\n", smpistdi); printf(" 7 flow dia of piston (2 holes) 0.073 %.3f\n", pistnozdi); printf(" 8 diameter of outlet in inches 0.032 %.3f\n", outnozdi); printf(" 9 spring force in pounds 28.6 %.1f\n", fspring/.45); printf(" 10 spring rate in pounds/inch 113.0 %.1f\n", rspring*2.54/.45); printf(" 11 mass of piston in grams 6.1 %.1f\n", mpiston); printf(" 12 mass of spring in grams 9.9 %.1f\n", mspring); printf(" 13 maximum travel of piston in cm 0.1 %.1f\n", maxtravel); puts("\n Press 1 to continue or 2 to make changes.\n"); c=getch(); if(c == '2') changecon(); }while(c=='2'); } changecon() { int num=0; do { printf(" Enter the number of the constant you want to change: "); scanf("%d", &num); } while(num < 1 || num>13); printf(" Enter the new value of constant number %d: ", num); scanf("%f", &con[num-1]); constants(); /* update constants */ } display() { printf(" %.4f %.4f %.1f %.1f %.1f\n", time, /* time in seconds */ xpiston/2.54, /* piston position in inches */ floseat*60/1000, /* flow into the regulator */ (outpress-ATPRESS)*14.5, /* outlet pressure of regulator */ floout*60/1000); /* flow out of regulator in lpm */ } /*************************** CALCULATE FLOW *****************************/ float flow(float pu, float pd, float a) { float q, ratio, dud; if((ratio=pd/pu) >= .53) { dud=(1-pow(ratio,D6))*D4; /* sub-sonic flow */ dud*=pow(ratio,D5); q=pu*a*C1*sqrt(dud); } else q=pu*a*C1*D3; /* sonic flow */ return(q); } /***************************** MAIN ROUTINE *****************************/ main() { int c, quit=0; float area, volume; textcolor(YELLOW); textbackground(BLUE); clrscr(); printf("\n\n\n\n PISTNREG - Tom Fangrow - 10/4/93\n\n"); printf("\n This program is a simulation of a piston style pressure"); printf("\n regulator. There is assumed to be one spring, no friction"); printf("\n and no safety relief mechanism. The flow into and out of"); printf("\n the regulator, as well as the outlet pressure, is displayed"); printf("\n for every .1 millisecond of operation. Press any key to"); printf("\n freeze the screen. Default parameters are for LSPI model"); printf("\n 735, but all parameters can easily be modified.\n\n"); printf("\n Press any key to begin the piston regulator simulation.\n"); getch(); constants(); /* put constants in right units */ xpiston=maxtravel; /* start with piston fully open */ /* ----------------------------- FLOWS ------------------------------ */ do { if(xpiston < = seatdi/4.0) /* when piston is close to seat */ area=PI*seatdi*xpiston; /* it restricts the flow area */ else area=seatnoz; if(inpress >= outpress) floseat=flow(inpress, outpress, area); /* flow through seat */ else floseat=-flow(outpress, inpress, area); if(outpress >= conpress) flopist=flow(outpress, conpress, pistnoz); /* flow through piston */ else flopist=-flow(conpress, outpress, pistnoz); if(outpress >= ATPRESS) floout=flow(outpress, ATPRESS, outnoz); /* flow out */ else floout=-flow(ATPRESS, outpress, outnoz); /* flow in */ /* ----------------------------- PRESSURES -------------------------------- */ outpress+=(floseat-flopist-floout)*DT/outvol; /* outlet pressure */ volume=convol+lgpistarea*(maxtravel-xpiston); /* dynamic volume */ conpress+=flopist*DT/volume; /* control pressure */ /* ------------------------------- FORCES --------------------------------- */ fopen=fspring-rspring*xpiston /* force up in kg mass */ +smpistarea*(outpress-ATPRESS); /* (bar=kg mass/sq. cm) */ if(xpiston < =seatdi/4) fopen+=seatnoz*inpress; /* more force up if seat nearly closed */ fclose=lgpistarea*(conpress-ATPRESS); /* force down in kg mass */ fnet=(fopen-fclose)*C2; /* net force in dynes */ /* ------------------------------- MOTION --------------------------------- */ apiston=fnet/(mpiston+mspring/2); /* acceleration in cm/sec/sec */ vpiston+=apiston*DT; /* velocity of piston in cm/sec */ xpiston+=vpiston*DT; /* position of piston in cm */ if(xpiston >= maxtravel) { xpiston=maxtravel; /* piston against cover */ vpiston=0.0; /* piston is stopped */ } if(xpiston < = 0.0) { xpiston=0.0; /* piston against seat */ vpiston=0.0; /* piston is stopped */ } /* ------------------------------------------------------------------------ */ display(); /* display current data */ time+=DT; /* increment time */ if(kbhit()) { /* if a key is pressed */ getch(); /* get rid of character */ puts("\n time piston position inflow pressure flow out"); puts(" (SEC) (INCHES) (LPM) (PSIG) (LPM)"); puts(" Press 1 to continue, 2 to view constants, or 3 to quit."); c=getch(); switch(c) { case '1':break; case '2':viewcon();break; case '3':quit=1;break; default :break; /* any key continues */ } } }while(!quit); textcolor(LIGHTGRAY); /* restore screen */ textbackground(BLACK); clrscr(); }

---

Click here to return to Tom Fangrow's Home Page