The other menu page takes only coordinates. It is sweet and simple, and much to my surprise, it's preferred by the folks who give me feedback. Because I have no way of telling which one is more important to you, the last page you use will be the first page next time you come back to this menu.

|PT A| expects a point number.
|PT B| expects a point number.
|BEARI| toggles bearing display ON/OFF.
|PT-| decrements point number and solves.
|PT+| increments point number and solves.
|SOLVE| solves for direction and distance from point A to B.

|CRD A| expects a coordinate.
|CRD B| expects a coordinate.
|BEARI| toggles bearing display ON/OFF.
|SOLVE| solves for direction and distance from coordinate A to B.

Traverse
This program calculates coordinates given a direction and a distance. In all the editions except the Small edition, you have three modes to work in. In the Small edition, you only have Azimuth mode. Basically, you enter the coordinate you're at with |@POIN|. Then you enter your direction and distance with either |HD2TL| or |SIDE|. |HD2TL| "HeaD to TaiL" will calculate the resulting coordinate and make it the new "@POINT." |SIDE| will only calculate the resulting coordinate. See EXAMPLE ON USING COORDINATE FILES.

|SEG| is also in all three modes, and what it does is let you choose which baseline segment you want your shot to be related to. When you press it, it'll say something like "Segement is Linear." Which means that when you key in an direction and distance with |HD2TL| or |SIDE|, the station and offset for the resulting coordinate will be displayed. Don't worry, the coordinate will still be on the stack or stored depending on you're settings. Give it a try, press

[NXT]

|SEG|

[NXT]

10.23 [ENTER]
100 |SIDE|

Forget what segment you had chosen? Press |VIEW| to remember.

Finished with locating points to a baseline, use |SEG| to change it to "NONE." Just press it until the it says "Segment is NONE"

azimuth mode:
This mode works in azimuth (0-360 degrees.) It's very useful. For computational purposes, it will take improper azimuths, but when the azimuth is displayed, it'll be displayed from zero to up to, but less than 360 degrees.

|>VIEW| view current settings.
|@POIN| expects a coordinate and makes it the point to calculate from.
|Z&S->| expects a z-angle in level 2 and a slope dist. in level 1, returns HD and VD.
|INV2| expects a coord. and returns the azimuth and dist. from @POINT to coordinate.
|HD2TL| expects azimuth in level 2 and distance in level 1. Moves result to @POINT.
|SIDE| expects azimuth in level 2 and distance in level 1.

|>VIEW| view current settings.
|SEG| used to choose baseline segment to locate points to.
|AVG| takes you to the Observation Averaging program menu.
|INV2| expects a coord., returns the azimuth and dist. from @POINT to coordinate.
|TARG| expects a distance and stores it as the target distance.
|@DIST| expects a distance and tells you to come or go.

There are several useful functions on this menu. In azimuth mode on the second page, you have |TARG| and |@DIST|. These two functions work together. |TARG| takes a target distance and stores it. Then when you enter a distance with |@DIST|, it tells you how much to "COME" or "GO" from the instrument to the target distance. So if you entered

100.25 |TARG|
75.34 |@DIST|

98.35 |@DIST|

Now, keep in mind, I'm not advocating using this instead of a data-collector, just sometimes for a few quick ones, it's much easier than setting up the DC.

angle-right mode:
This mode is useful for times when you didn't set a correct backsight azimuth, or you just wanted to work with angles. What it needs to know, is what your backsight azimuth is and what you determine to be your plate angle at the backsight. If you move forward with |HD2TL|, then your forward azimuth is carried forward (unless you've entered a 0 distance) for you.

|>VIEW| view current settings.
|@POIN| expects a coordinate and makes it the point to calculate from.
|Z&S->| expects a zenith angle in level 2 and a slope distance in level 1 and returns HD and VD.
|INV2| expects a coordinate and returns the direction and distance from @POINT to coordinate.
|HD2TL| expects angle in level 2 and distance in level 1. Moves result to @POINT.
|SIDE| expects angle in level 2 and distance in level 1.

|>VIEW| view current settings.
|SEG| used to choose baseline segment to locate points relative to.
|AVG| takes you to the Observation Averaging program menu.
|BS PT| expects a coord. then calculates and stores the BS azimuth.
|BS AZ| expects a backsight azimuth.
|BS <| expects an angle, the actual plate angle to the backsight.

bearing mode:
This is useful for working plans and maps in four quadrant bearings. Depending on how the bearing entry style is set, you would enter side shots and head to tail with the same technique as the Traverse with Closure program in bearing mode. When your bearing entry style is set to Original, it'd be 3:bearing angle 2:quadrant number 1:distance. When you set the entry style to Composite, it's 2:bearing 1:distance, where bearing is a composite of the quadrant number and bearing angle.

|>VIEW| view current settings.
|@POIN| expects a coordinate and makes it the point to calculate from.
|Z&S->| expects a zenith angle in level 2 and a slope distance in level 1 and returns HD and VD.
|INV2| expects a coordinate and returns the direction and distance from @POINT to coordinate.
|HD2TL| expects bearing angle in level 2 and distance in level 1. Moves result to @POINT.
|SIDE| expects bearing angle in level 2 and distance in level 1.

|>VIEW| view current settings.
|SEG| used to choose baseline segment to locate points to.
|AVG| takes you to the Observation Averaging program menu.
|INV2| expects a coordinate and returns the direction and distance from @POINT to coordinate.

Traverse W/Closure
This is a traverse with compass rule adjusment program. It breaks many of the rules adhered to in the rest of the program pack. First of all, it requires a coordinate file to work. Next, it doesn't leave coordinates on the stack for use elsewhere, instead it stores to the coordinate file. And, when you edit the traverse file and change something, it doesn't prompt you for overwriting the existing coordinates, it just does it.

This program has changed from previous versions in that now you need to create a file to be used, just like you do with coordinates and Gradester, but this is a good thing, you can save a traverse for later review or revision. On the second menu page, you use the |FILER| to create and delete traverse files. It's the same filer as the one for coordinate files and Gradester files, except now it is only working with traverse files. You may wish to read the section on COORDINATE FILES AND THE FILE SELECTOR. Anyway, once you've created a traverse file (or just made an old one active) and you have a coordinate file currently active, you're ready to begin.

Since, this program uses and requires a coordinate file, it works by point numbers. You need to have the starting coordinate stored before hand. Once you're ready to start, what you do is enter the point number of the start of the traverse with |START|. This not only makes this the start of the traverse, it clears out whatever you may have had in the traverse file. Then, you enter each leg (azimuth and distance) with |HD2TL|. Once you've entered each leg of the traverse, including the one you close with, you press |CLOSE|. At this point you can either close to the starting point, in which case you'd press |START|, or you can close to another point. If you want to close to a point and you haven't stored it yet, it's not too late. Go ahead and store it, you know how. And so to close to a point, just enter the point number of the point you're closing to with |PT#|.

Now once you've closed with either of those options, the calculator will do some processing and generate a report. It will give you the misclosure, precision, and other good things to know. In addition, it will show you the unadjusted coordinates along side the adjusted ones for you to review and perhaps write in your book with a different colored pencil. At this point, you have the option of replacing the unadjusted coordinates in the coordinate file with the adjusted ones, or just cancelling the report. Also, if you wish, there is a |PRINT| menu choice which will send the print to the infrared printer.

You can rerun the closure as many times as you wish. Maybe you made a mistake punching it in or something and you had to edit the traverse. Whatever the reason, you can keep rerunning the closure, even if you replaced the coordinates. You can even make a different coordinate file active and as long as all the points numbers are in the range of the coordinate file, it will accept it. This can be good if you want to run various scenarios, but it can also be dangerous in the case of accidental overwrites. Remember, if you edit the file and change something or pretend you changed something (edit a record with the same info), it WILL recalc and update the points in the file.

Note: Area is calculated using "coordinate method" not DMD. When coordinates with large value (far from zero) components are used, the area can be different from when using coordinates with small value (close to zero) components are used. The problem is with fixed digit representation of values.

The problem is two-fold. First, when you have coordinates with numbers in the hundred-thousands as opposed to ones in the thousands, the amount of represented digits after the decimal place are two less. This probably only becomes a noticable problem over a course with many legs or when the number of digits after the decimal place drops below something like four or five. The second and more substantial problem is one of representing the value when multiplying components. This can be a huge number and again with fixed digits of representation, one can lose precision (represention after the decimal place.) This can add up to a noticable amount. The DMD method is probably the best way to combat this, but implementation is difficult. So as a compromise, the algorithm has been adjusted so that the first coordinate is subtracted from each subsequent coordinate thus helping the second problem in many cases. This is not a panacea, but it helps.

To illustrate this point, follow the example below and write down the areas of the traverse. Then edit the traverse. Change the starting coordinate to something like 904166.20N, 906154.22E. The program will recalc the traverse, so it's easy. Then rerun the closure and note the areas. Now, edit the traverse again and change the starting coordinate to something like 9904166.20N,9906154.22E. Again, rerun the closure and take note of the areas. They should start to change slightly. I don't think cases arise where the coordinate components get so high, but if they do, be aware of the limitations of this program.

|>VIEW| view status. [/->] |>VIEW| will switch between azimuth and bearing mode.
|START| expects a pt.# to start your traverse from, and resets.
|LAST| recalls to the stack, the last azimuth and distance in current traverse.
|INV2| expects a point number to inverse to. Entering point number 0 inverses to the start of the traverse.
|CLOSE| generates misclosure report as well as adjusted coordinates.
|HD2TL| expects azimuth in level 2 and distance in level 1, add legs to traverse.

|>VIEW| view status. [/->] |>VIEW| will switch between azimuth and bearing mode.
|AVG| gets you to observation averaging menu.
|Z&S->| same as in Traverse program.
|EDIT| edits the current Traverse.
|FILER| interactive, it creates, chooses, and deletes traverses or directories.
|PLOT| plots current traverse to screen.

Indeed, this is such a queer program that an example is in order. So here we go.
Here is your traverse:

Start at point A 4166.20 N 6154.22 E
A to B 227-28-00 @ 483.52
B to C 8-27-30 @ 392.28
C to D 56-27-00 @ 886.04
D to E 206-16-30 @ 452.66
E to F 140-42-00 @ 279.33
F to A 279-39-30 @ 421.97

[/->] [PRG]

|NEW|
|DIR|
EXAMPLE2 [ENTER]

|USE|

|NEW|
|FILE|
MYPOINTS [ENTER]

1 [ENTER]
10 [ENTER]

|EXIT|

[CST]

|W/CL|

[NXT]
|FILER|

|NEW|
|FILE|
MYTRAV [ENTER]

|EXIT|

4166.2 [ENTER]
6154.22 [STO]

[NXT]

1 |START|

227.28 [ENTER]
483.52 |HD2TL|

8.273 [ENTER]
392.28 |HD2TL|

56.27 [ENTER]
886.04 |HD2TL|

206.163 [ENTER]
452.66 |HD2TL|

140.42 [ENTER]
279.33 |HD2TL|

279.393 [ENTER]
421.97 |HD2TL|

Assuming you did enter everything correctly, or even if you didn't, let's see how the thing closes. Press

|CLOSE|

|START|

|REPLA|

|YES|

You can also, print to the infrared printer, but for now just exit the report viewer.

|EXIT|

Note: When you run a closure, it doesn't change the coordinate file unless you do a replace.

Observation Averaging
This is an unusual program. It averages obersevation readings. That's it, a simple average. So what's so unusual about that? Perhaps nothing, or perhaps that it's simple. It's merely an average, and it takes into account a 360 degree plate reading. Well actually, that's 0 <= reading < 360. So, averages that hover around the 0 region are no problem. Such a simple problem, but think about how you'd program it. It's only simple when you know the answer.

Please test this against numbers you already know so as to be sure it does what you want it to do and not something similar. In fact, please test all these programs against known values and let me know of blunders anywhere.

You have a choice of two modes, direct readings only, or direct and reverse readings. You switch between the two with [/->] |>VIEW|.

What you do is this. Once you get to the menu and have decided whether you want to use, direct only or direct and reverse observations, you should set your tolerance if you haven't already done so. |>VIEW| will reveal what things are currently set at. The tolerance is the acceptable range of variation. Unlike a plus or minus value most folks would use, this program goes by the range of the highest and lowest values. This may be wrong, but my reasoning is that the first reading may not be the center-most value. Anyway, this value is taken in d.mmss so a value of 0.001 will allow a range of 10 seconds in readings.

Next what you would do is press |RESET| to clear out any other readings that might be in there. Afterall, like most of the other programs, your work here is not volatile.

Now, just enter your readings for one point with |OBS|. An average is displayed with each observation. Even if the values go above and below 0-00-00 it's okay. I know some will avoid setting zero for this very reason, but it's okay with this program.

Once you've entered to your satisfaction, you can press |->STK| to push the average onto the stack for possible use elsewhere.

|>VIEW| view your settings and current average.
|BACK| returns you to back to the program it was called from.
|TOL| expects a tolerance in d.mmss, someting like .001
|RESET| resets values to get ready for new average.
|->STK| pushes average onto stack.
|OBS| expects a plate angle to average.

Example:
Say you had traverse notes like these

OBS          BS             FS    
dir        0-00-10      177-02-03
rev      180-00-05      357-02-10
dir        0-00-08      177-02-07
rev      180-00-07      357-02-08

First, if it's not set to Dir & Rev, then change the setting with [/->] |>VIEW|. Now, let's enter the tolerance as 20 seconds.

0.002 |TOL|

|RESET|

0.001 |OBS|
180.0005 |OBS|
0.0008 |OBS|
180.0007 |OBS|

|->STK|

|RESET|

177.0203 |OBS|
357.021 |OBS|
177.0207 |OBS|
357.0208 |OBS|

Linear Baseline
This program solves for horizontal coordinates relative to a baseline that is a straight line. Please read the section on HORIZONTAL ALIGNMENTS for more details on using it.

|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|O/S| expects an offset, the offset to be solved for, use a negative value for left.
|STA| expects a station, the station to be solved for.
|SOLVE| solves for coordinate.

|VIEW| view variables.
|P O L| expects the coordinate for the Point On Line.
|@STA| expects the station at the point on line.
|AZI^| expects the azimuth of the line pointing upstation.
|O/S?| expects a coordinate, solves for the station and offset of the coordinate.

Radial Baseline
This program solves for horizontal coordinates relative to a baseline that is an arc. Please read the section on HORIZONTAL ALIGNMENTS for more details on using it.

This program gives you the choice of variables used to define your baseline. In one case, you provide radius point and radial azimuth. In the other case, you provide the Point On Curve and the tangential azimuth pointing forward. To switch between the two modes, press [/->]|>VIEW|.

|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|O/S| expects an offset (to be solved for), use negative for left.
|STA| expects a station, the station to be solved for.
|SOLVE| solves for coordinate.

|>VIEW| view variables.
|RD PT| expects the coordinate for the Radius Point.
|RD/RO| expects the Radius/Rotation, use negative for left-hand curves.
|POC.S| expects the station at the Point On Curve.
|AZPOC| expects the radial azimuth to the point on curve.
|O/S?| expects a coordinate, solves for the station and offset of the coordinate.

or

|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|O/S| expects an offset (to be solved for), use a negative value for left.
|STA| expects a station, the station to be solved for.
|SOLVE| solves for coordinate.

|>VIEW| view variables.
|P O C| expects the coordinate for the Point On Curve.
|RD/RO| expects the Radius/Rotation, use negative for left-hand curve.
|POC.S| expects the station at the point on curve.
|AZFW| expect the azimuth forward (tangential azimuth upstation.)
|O/S?| expects a coordinate, solves for the station and offset of the coordinate.

Spiral-IN Baseline
This program solves for horizontal coordinates relative to a baseline that is spiral TS to SC.

Operation and concept is the similar to the Radial Baseline and Linear Baseline programs. One small difference is that there wasn't enough room for both |STA+| and |STA-| at the same time, so you have to use [/->] to switch between the two choices. See THINGS TO KNOW.

|>VIEW| view variables.
| TS | expects the coordinate for the TS.
|TS ST| expects the station for the TS.
|TS AZ| expects the tangential azimuth (upstation) at the TS.
|LENG| expects the length of the spiral.
|RD/RO| or expects a radius or spiral angle respectively (negative for LH.)

Spiral-OUT Baseline
This program solves for horizontal coordinates relative to a baseline that is spiral CS to ST. Operation is the same as for Spiral-IN Baseline.

|>VIEW| view variables.
| CS | expects the CS coordinate.
|CS ST| expects the CS station.
|CS AZ| expects the tangential azimuth (upstation) at the CS.
|LENG| expects the length of spiral.
|RD/RO| or expects a radius or spiral angle respectively (negative for LH.)

Arc/Arc Intersect
This program solves for the intersection points of two arcs. Once you've entered your variables, press |SOLVE| and a screen will appear to verify what you've entered and allow you to choose which solution you want. |LEFT| will give you the intersection on the left of the line from radius point 1 to radius point 2. |RIGHT| will give you the intersection to the left. And |BOTH| will give you both.

|R.PT1| expects the coordinate of the radius point of the first arc.
|RAD 1| expects the radius of the first arc.
|R.PT2| expects the coordinate of the radius point of the second arc.
|RAD 2| expects the radius of the second arc.
|INTER| returns you to the intersection menu.
|SOLVE| solves for intersection.

Arc/Line Intersect
This program solves for the intersection points of a line and a curve. Once you've entered your variables, press |SOLVE| and a screen will appear to verify what you've entered and allow you to choose which solution you want. |NEAR| will give you the solution nearest the P O L, |FAR| will give you the farthest from the P O L, and |BOTH| will give you both solutions.

|RD PT| expects the coordinate of the radius point.
|RADIU| expects the radius.
|P O L| expects the coordinate of the Point On Line.
|AZI| expects the azimuth of the line.
|INTER| returns you to the intersection menu.
|SOLVE| solves for intersection.

With all editions except the Small edition, you have the option of entering bearings instead of azimuth. Use the [/->] |>AZI| to switch to it and [/->] |>BR| to switch it back.

Line/Line Intersect
This program solves for the intersection point of two lines. Each line is defined by the direction of the line and a coordinate on that line. Once you've entered your variables, press |SOLVE| and a screen will appear to verify what you've entered. If all's well, just press |MORE| to continue with the answer. The coordinate is left on the stack.

|POL 1| expects the coordinate for the point on line 1.
|AZ 1| expects the azimuth of line 1.
|POL 2| expects the coordinate for the point on line 2
|AZ 2| expects the azimuth of line 2.
|INTER| returns you to the intersection menu.
|SOLVE| solves for intersection.

With all editions except the Small edition, you have the option of entering bearings instead of azimuth. Use the [/->] |>AZ 1| to switch to it and [/->] |>BR 1| to switch it back.

Coordinate Conversion
When working with rectangular coordinate systems, I think they're called cartesian, this program converts coordinates in one system to coordinates in others. About 1993 or so, I was told we were going to be changing over to metric, so I wrote this program. We haven't started yet. I don't think it's going to happen, but I keep the program just in case. Sometimes I use it to do a poor man's resection.

What you do is enter the coordinates for the same two points in both systems. If you have a scaling factor, you can enter it. If not, the program will figure one out for you, just enter 0(zero) as your scaling factor. Then you can convert coordinates either direction. Converting a block of points in a coordinate can be done using |BLOC|. |BLOC| will prompt you. It only converts OLD to NEW, and it doesn't convert unused points in the block.

Now on the scaling factor. If the unit in the old system were the foot and the unit in the new system were a yard then the scaling factor would be 3. Setting the scaling factor to 0 will let the program figure out the scale itself. When automatically figuring the scale, the program NO longer forces a scale close to 1 to be 1. So, if you have a scale, better put it in.

|VIEW| views settings.
|BLOC| converts a block of coordinates (OLD to NEW), prompts you for Pt.#s.
|N->O| expects a coordinate from NEW system and converts to OLD.
|O->N| expects a coordinate from OLD system and converts to NEW.

|VIEW| views settings.
|OLD1| expects coordinate of point 1 in OLD system.
|NEW1| expects coordinate of point 1 in NEW system.
|OLD2| expects coordinate of point 2 in OLD system.
|NEW2| expects coordinate of point 2 in NEW system.
|SCALE| expects scaling factor, use 0 if unknown.

End Area
This program calculates an area from coordinates using the coordinate method. What you do is enter the starting coordinate, be it North/East or Offset/Elevation, with |START|. Then you enter each subsequent point as you work your way around the perimeter with |NEXT|. When you enter the same coordinate you started with, the area is revealed. If you've stored them to a coordinate file in sequence, you have |BLOC| recall and enter them for you. You will be prompted for point numbers. |BLOC| is mindless and just recalls the point number and runs them through, then after reaching the last one, it recalls the first point to close out the perimeter. Useful for end areas.

|START| expects the coordinate of your starting point.
|NEXT| expects a coordinate and is used to enter each subsequent point along the perimeter.
|BLOC| will prompt you for point numbers.
|ST#| expects a point number.
|CHNK| "CHUNK" expects "from" point number in level 2, "to" point number in level 1.
|NXT#| expects a point number.

Now for example, to figure the area of the figure shown above, you'd key in something like

0 [ENTER]
0 |START|

1 [ENTER]
2 |NXT|

6 [ENTER]
5 |NXT|

0 [ENTER]
0 |NXT|

Don't forget, you can use a coordinate file to make this easier. Sometimes, it's easier to store the data in a coordinate file and fix your mistakes there than to flawlessly key it in.

Okay, now say you have stored your coordinates or offset/elevation as coordinates in a coordinate file, and you stored them in order as you go around the perimeter. Well, if you set yourself up like this, as you might very well do with an end-area, you can use |BLOC|. Say you stored them as points 3 thru 13, you'd key in

|BLOC|
3 [ENTER]
13 [ENTER]

Newly added to the End Area program are the |ST#| and |NXT#| and |CHNK| softkeys. It has come to my attention that it would be very useful to work this program using point numbers for stored coordinates as well as using coordinates on the stack. What these new softkeys do is take a point number and recall that point and then enter the coordinate to the End Area program. You use |ST#| and |NXT#| just as you would |START| and |NEXT|, except you use point numbers instead of coordinates. It is an entry aid. Actually, all it does is eliminate the need to press [PRG] in the process. So, you could mix using the keys that expect a coordinate and the ones that expect a point number. |CHNK| "CHUNK" takes two numbers from the stack, a "from" point number and a "to" point number and is another entry aid that will recall and enter a sequence of points as "next" points.

Now, say you had stored your coordinates, but they aren't entirely in order. Say your sequence is 2,13,12,11,10,9,8,3,2. You could key in

2 |ST#|
13 [ENTER] 8 |CHNK|
3 |NXT#|
2 |NXT#|

Triangle Solutions
This program solves for those five popular triangle programs. Choose the scenario that suits your needs. Enter the three knowns and press |SOLVE|. The answers are displayed. If you need the values, pressing |->STK| will push them on the stack. |TRIAN| gets you back to the Triangle Solution menu.

Curve Data
This program solves for various aspects of a curve given the delta of the curve and the radius. Just enter the delta with and the radius with |RADIU|, then press one or more of the |SOLVE| buttons. You may have noticed that there are three |SOLVE| buttons. This is because each solves for different aspects of the curve. Not every aspect is of interest, so you can just solve for the solutions you want.

Fit a Curve
Designing a curve, or reverse engineering a curve, this program lets you figure out what a curve might be. Once at the Fit a Curve menu, you are presented with a choice of three variables you might want to hold constant while you play with a second one. The first three variables are |CHORD|, |RADIU|, and . What you do is enter one of the three variables. Then your menu will change to one with choices for your second variable. You can try out one or more second variables, over and over until you've discovered your curve. |NEW| on the second variable menu brings you back to the first variable menu.

Deflection Angles
This program calculates deflection angles and chords for a non-coordinate method of laying out curves. Generally, before the age of computers, this was a great way to layout curves because you didn't have to recalculate for each setup. The bad part is you need to set up on the curve itself. The short chords ( between stations staked ) are provided, as well as the distance from the instrument. On the 48 it's displayed as "Dist(gun)" because there's a lack of room on the screen.

Even in modern times, this routine can be useful for times when you do have key points in place and coordinates would be impractical. Might be good for a fence or something like that. However, I have not personally used this method in several years, and I am a little hazy on how things should be. Please test it thoroughly, make sure it works out properly.

There are several variations on how people do this, so I'll explain how it's done in this program. Some instruments measure left and right angles, some only measure to the right. If you are okay with going both directions, then left hand curves are no problem. If you can or are only comfortable turning to the right, then this program has a twist to make it easier for you.

If you have a left hand curve, and you set the program RD/RO to a negative number, then it will generate the angles like this. The angle for the PT will be 0 degrees, the angle for the PC will be the full deflection. This is supposed to be easier on the human setting the angles than if you set 0 degrees at the PC and have those large "three-hundred something" numbers coming out.

If you set the radius to a positive number, then the PC will be 0 degrees and the PT is the delta/2. I know this sounds just like turning to the left, but the angles are for an instrument turning to the right.

Now regardless of whether you have a left hand curve or a right hand curve, you may need to move up on a staked station and backsight the previous setup. Well, some folks flip the telescope, sight the previous point with the angle for that point. If you do this, no further calcs are needed. However, some people don't like to flip and some instruments piggyback the EDM and don't like to be flipped. Whatever. If you can't or won't flip the telescope, you just add 180 degrees to the angle for that point, right? Okay, if you change the setup station in the program, it will add the 180 to your back stations. If you are setup at the PT, it will not add the 180 for the backstations, because you are only looking back, not forwards and back.

The |BS T| "backsight tangent" button suggests a backsight angle for you when you are setup at the PC or PT.

|BS T| suggests a BS when SET@ is the PC or PT station.
|ARC->| expects an arc length and returns the chord.
|INCR| expects the increment to advance or retard station by.
|STA-| retards station and solves.
|STA+| advances staion and solves.
|STA->| expects a station and solves.

|VIEW| views setup.
expects an angle for the delta of the curve.
|RD/RO| expects the radius of the curve, negative for LH.
|PC ST| expects the PC station of the curve.
|SET@| expects the station to setup on.
|STA->| expects a station and solves.

Example:
Say you had the PC and PT already in place. Your curve delta is 35 degrees 10 minutes, your radius is 800, and it turns to the left. Let's make the PC station 0+00, and we're going setup there first. First let's put that info in the calculator. Get to the menu where you enter your variables. Key in

35.1
800 [+/-] |RD/RO|
0 [ENTER]
[ENTER] |PC ST|
|SET@|

|VIEW|

[NXT]
|BS T|

100 |STA->|

123 |STA->|

[NXT]
500 |SET@|
[NXT]
0 |STA->|

Curve Points
This program solves for the break points of a curve as well as the curve data. There are two options to this. The PI is known, solves for the PC, radius point, and PT. The PC is known, solves for the radius point and the PT. You switch by pressing [/->] |>PC| and [/->] |>PI|. You can tell the difference by what's on the menu, and when you press |SOLVE|, you get a chance to verify what you entered. You can also tell from that screen.

In addition to the PI or PC, the azimuth going into the curve, the azimuth going out of the curve, and the radius need to known. Once you enter these things, press |SOLVE| and what you've entered is diplayed for verification. If it's okay, press |MORE| and it will continue on and display the curve data so you can check it against your plans or map. If that's okay, press |MORE| and it will produce the coordinates of the break points.

|AZ IN| expects the azimuth going into the curve.
|AZOUT| expects the azimuth going out of the curve.
|>PC| or |>PI| expect a coordinate for the PC or PI.
|RADIU| expects the radius of the curve.
|SOLVE| solves for the break points and curve data.

Spiral Points
This program is very similar to the Curve Points program. Instead of solving for only the break points of a simple curve, it solves for the break points of the spirals and simple curve if there is one. It assumes you are solving for symmetrical spiral-curve-spiral or spiral-spiral scenarios. You can start from the PI or TS, and you have a choice of using a radius or spiral angle as variables.

You use it the same way as you use the Curve Points program. When you press |SOLVE|, you get a screen verifying you entered things correctly. Then, when you press |MORE|, it continues on and gives you spiral information so you can check it against what is shown on your plans. Then pressing |MORE| will continue on and provide you your solutions. The azimuths shown after the CS, SC, and SS coordinates are the tangential azimuths upstation.

|AZ IN| expects the azimuth going into the curve.
|AZOUT| expects the azimuth going out of the curve.
|>TS| or |>PI| expect a coordinate for the TS or PI.
|LENG| expects the length of the spiral.
or |>RAD| expects the spiral angle or the radius respectively.
|SOLVE| solves for the break points and curve data.

Radius Calculator
This program calculates a radius given a degree of curve or spiral angle and length. |DC->| takes your degree of curve (100' arc) and converts it to a radius in feet. |DCC->| takes your degree of curve (100' chord) and converts it to a radius in feet. takes a spiral angle and length of spiral and converts it to a radius. The answers are left on the stack.

|DCC->| expects the degree of curve in d.mmss format (100' chord.)
|DC->| expects the degree of curve in d.mmss format (100' arc.)
expects the spiral angle and the length of the spiral.

Utilities
This has those little utility programs in it. You can change the system settings, do a file transfer, print out points, or even enlarge your coordinate file here.

|VIEW| view settings.
|PRTPT| prompts you for point range to print to infrared printer.
|PROT| toggles overwite protection ON/OFF. With overwrite protection ON, you will be prompted before a used point is overwritten.
|STORE| toggles you between auto-store and manual-store. Auto-store will store coordinates to file as they are generated.
|TFR| brings you to File Transfer menu.
|BOOST| prompts you for how many points to enlarge file by.

|VIEW| view settings.
|FILER| same as [/->] [PRG], coordinate file selector.
|ELEV| expects an elevation and/or prompts you, changes the default elevation for storing points.
|ABOUT| credits, series number.

|VIEW| view settings.
|QUAD| toggles you between quadrant styles, HP 1,2,3,4 or Corners 9,3,1,7.
|N/S| toggles you between North oriented and South oriented azimuth.
|STA| toggles you between English:0+00.00 and Metric:0+000.000 station format.
|N&E| toggles N,E and E,N entry/display coordinate format.
|BEAR| toggles between Original and Composite bearing entry format.

File Transfer
This program helps you back up your files to a computer or just share them with another HP-48. It uses the built in kermit commands, but helps out by using the file selector to pick the files to send. Set both sides to the same port, baud and type. Then on the receiving side press |RECV|, and on the sending side press |SEND|. When you press |SEND| the file selector will start up and once you highlight the file you wish to send, press |USE| or [ENTER] to send the file.

|VIEW| view settings.
|PORT| toggles between IR and WIRE port.
|BAUD| changes the baud choices.
|TYPE| changes the type of files to send and receive.
|RECV| initiate receive, waits for file.
|SEND| initiates appropriate file selector to choose file and send.

What the EXPort portion does is take a coordinate file in your hp-48 and translate it to an ASCII format on the fly as it transmits it using my interpretation of the KERMIT file transfer protocol. The IMPort portion does the reverse. It receives a coordinate file in ASCII format and translates it on the fly as it gets it. Unfortunately, I am not an expert programmer nor an authority on Kermit, so as a result, the program runs somewhat slower than commercial software of this type. BUT, it works! And I have some thoughts on how to speed things up, but those things need to be done in assembler, so that's for another day.

Note: Import runs too slowly from slot 2. It may not even maintain a connection. Import should be run from slot 1 until the routine is improved.

What would you use this for? Well, you can use it to send coordinates to a PC or something, so you can review it in plain text. On the reverse side, you can create a coordinate file with some other software and send it to the calculator. You could also use the IMPort to add to your coordinate file. But most notably, you can exchange coordinate files with some commercial HP-48 surveying software directly via the IR port. This cross-platform ability might be most useful in the field when you want everyone on the same page.

To use COORD IMP/EXP is almost like when sending and receiving other file types except for a few details. When you want to send a file and you press |SEND|, the file selector will start up. Then when you choose a file, it will stop and ask if you want to send the whole file or just a block of it. If you choose |BLOC|, you will be prompted for the point number range you want to send. The portion of the file will be sent upon entering a valid range.

Don't forget, if you plan to export your coordinate files, you may have to adhere to a naming convention of the software you are exporting to. For example, the software I would export to, requires that you name your coordinate file with up to eight characters and with the extension .CR5, where CR are capital letters. Changing the file name can be a difficult task, I use FILER48 for this. It's also great for backing-up and restoring files on RAM cards. It's freely available on www.hpcalc.org.

If for some reason you wish to cancel while importing a coordinate file. Let me warn you, if you hit the [ON] key while it's enlarging the file, conceivably you might lose the entire file. I have not been able to make this happen during testing (and I've tried,) however, it might be safer to cancel on the sending side then press [ON] while the 48 is waiting for a packet.

IMPORTANT: The IMP/EXP ASCII format, both import and export, depends on how the N&E settings are set. If they are set to display North East, then the format will be like:

PT#,Northing,Easting,Elevation,description<cr><lf>
PT#,Northing,Easting,Elevation,description<cr><lf>
PT#,Northing,Easting,Elevation,description<cr><lf>

Now, if you have it set to East North, then the format will be like:

PT#,Easting,Northing,Elevation,description<cr><lf>
PT#,Easting,Northing,Elevation,description<cr><lf>
PT#,Easting,Northing,Elevation,description<cr><lf>

If this notation is too mysterious for you, you could create a coordinate file and export it using something like Hyperterminal(included with Windows,) then look at it with something like Notepad(also included with Windows.) It should then make sense.

You may have noticed a description field. Well this software doesn't use a description field in the coordinate file, but to remain compatable with other software, one is required for importing. You aren't required to put a description in, but the comma seperator is required. Each line can be up to about 200 or so characters and must end with a carriage return line feed. No headers, trailers, or extra carriage return line feeds are accepted.

These conditions will cause receiving a file to end:

• A low-battery condition
• A non-coordinate file of same name already exists
• A lack of free memory
• A non-conforming record is encountered
• The filename is not a legal HP-48 variable name
• The filename is in my list of reserved names
• Receiving a point below the lowest point in the file, see COORDINATE FILES AND THE FILE SELECTOR

To use the IMPORT/EXPORT feature, communication settings must be set to:

• 8 data bits
• parity NONE

And while it probably will work anyway, you should also set the flow control to NONE.

So why all the trouble of creating my own Kermit routine? I guess creating a temporary file and sending it with the built-in Kermit might work except for the lack of space in the HP-48 and the header the built-in Kermit would send. I guess I could send a stream to the serial port like some commercial software does for printing, but that would probably fill the buffer and require flow control and it lacks checking on the receiving end. Don't forget, you'll need some software on the receiving end to capture that stream, and that's not always available. Kermit has a stop and wait process, so it's unlikely it'll overflow the buffer. It checks each packet it receives, and has bad packets resent. Kermit is ubiquitous, so there is likely a free one for the system you use. And best of all, it allows this Low-Budget program to exchange coordinates directly with commercial software that has also adopted this strategy.

To begin, start up the filer with |FILER| on the Gradester menu. If you're in the desired directory, create a file. You may want to see the section on COORDINATE FILES AND THE FILE SELECTOR. Once you create the file and you verify it's the active file, quit the filer with |EXIT|.

Next, you need to add some elements to the file, so you press |EDIT|. When the editor starts up, you press |ADD| to add an element. You choose which type of element you want to enter, then enter the variables that describe the element. Next, you'll enter the range the element is to be used over. The FROM station must be less than the TO station. When you add, it inserts the element right after the one you're looking at. Continue to enter as many elements as you need.

When you're finished entering elements, quit the editor with |EXIT|. A file checker is provided, it's highly recommended you run the checker by pressing |CHEC|. If you find errors, hit |EDIT| and fix them. Once you've got everything correct, you use it just like you would the other two vertical alignment programs. Please note that |CHEC| only checks for continuity. It checks that there is zero gap in station and that there is no gap in elevation more than 0.0001. It does not check for tangents that match curves. So, it is good to check the PIVCs of the curves carefully for mistakes.

The elements you enter have all the characteristics of the programs they are based on. For example, when you use the SLG program, sta 1 does not need to be lower than sta2, nor are you confined to solving between those stations. And when you use the VC program, for stations outside of the curve, elevations are returned as though on the tangent. Well anyway, that's how you are allowed to use each element in the gradester file. Another thing to be aware of, is that when you toggle on break points, the break points are determined by the range of use stations. This may be important for a grade setter. On the other hand, the more elements you have, the more memory it consumes, and potentially more things to search through when looking for a station. So depending on your needs, you can stategically plan what elements you use.

A side note here. If you place elements out of sequence, or use bad ranges, there is a possiblity it may start searching endlessly. The previous version of this only searched in one direction, avoiding the problem, but this one will go up or down in hopes of speeding things up. So again, I must re-emphisize to use |CHEC| once you've completed entering your elements.

|FILER| interactive, it creates, chooses, and deletes directories or Gradester files.
|EDIT| edits currently selected grade file.
|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|STA->| expects a station and solve for elevation.

|VIEW| view current conditions.
|BRKS| toggles break points ON/OFF.
|PRINT| prints to IR printer a range of stations.
|CHEC| checks currently selected grade file for continuity (+/-.0001 elev.)

Superelevation
Used for figuring along segments of a superelevation diagram. They usually can be broken down into sections of zero slope, vertical curve, slope, vertical curve, zero slope. You enter the PI stations, the elevations of the zero slopes and the lengths of the vertical curves. Note that STA 1 doesn't have to be lower than STA 2.

|VIEW| views variables.
|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|STA->| expects a station and solve for elevation.

|STA 1| expects a station.
|ELV 1| expects an "elevation" actually the %superelevation.
|LEN 1| expects the length of vertical curve 1. 0 is allowed (linear transition.)
|STA 2| expects a station.
|ELV 2| expect an "elevation" actually the %superelevation.
|LEN 2| expects the length of vertical curve 2. 0 is allowed (linear transition.)

Straight Line Grade
This program solves for elevations along a straight line grade. You define the line with two stations and the elevations at both stations. Note that station 1 does not need to be lower than station 2. The solution elevation is left on the stack with the station tagged to it to help you remember. Treat it as an ordinary number.

|VIEW| views variables.
|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|STA->| expects a station and solves for elevation.

|VIEW| views variables.
|STA 1| expects a station.
|EL 1| expects the elevation at station 1.
|STA 2| expects a station.
|EL 2| expects the elevation at station 2.
|STA->| expects a station and solves for elevation.

Vertical Curve
This program solves for elevations along a vertical curve as well as the "turning point." For stations outside of the curve, the elevation is calculated as though on the tangent section. The solution elevation is left on the stack with the station tagged to it to help you remember. Treat it as an ordinary number.

|VIEW| views variables.
|SAG| calculates sag or crest point and grade-in, grade-out, and length.
|INCR| expects an increment to change station by.
|STA-| retards by increment and solves.
|STA+| advances by increment and solves.
|STA->| expects a station and solve for elevation.

|BVCST| expects BVC station.
|BVCEL| expects BVC elevation.
|PI ST| expects PI station.
|PI EL| expects PI elevation.
|EVCST| expects EVC station.
|EVCEL| expects EVC elevation.

Leveling
Leveling is just meant as an aid in reducing your level notes. You can pick up at whatever point you want to. You can enter an elevation and then a backsight rod reading to give you a new HI or you can just enter a HI. |FS| (foresight) will subtract the value entered from the HI and store it as the new value for elevation. That's all there is to it.

Option 1
The first option has the softkeys |3WBS| and |3WFS| stand for "3-Wire BackSight" and "3-Wire ForeSight." You use these keys just like you would |BS| and |FS|, except you use readings from the two stadia lines as well as the center instead of just the center. It takes three values from the stack and does a three wire comparison if the value exceeds the tolerance specified, then it is flagged out with a beep and a star. In level 3 should be the upper wire reading, in level 2 should be the center wire reading, and the lower wire reading should be in level 1 before pressing these softkeys. Works with inverted rod.

Keys:
|3WBS| expects Upper in level 3, Center in level 2, Lower in level 1.
|BS| expects a BackSight rod reading and calculates HI from current elevation.
|HI| expects a Height of Instrument.
|FS| expects a ForeSight rod reading and calculates a new elevation from current HI.
|3WFS| expects Upper in level 3, Center in level 2, Lower in level 1.
|ELEV| expects an Elevation.

|>VIEW| view settings. [/->] |>VIEW| switches options.
|+/-| enters the tolerance to be flagged if exceeded.(something like 0.01)
|RND| decimal points to round to (for 3-wire and c/f.)

Option 2
The second option has the softkeys |PT#EL| and |TARG|. |PT#L| is used for recalling an elevation to the stack from your coordinate file. This is useful if you have your control points stored with elevations. |TARG| is used for entering a target elevation. With this option, when you enter a rod reading with |FS|, it calculates the cut or fill to the target elevation, which is useful for writing your C/F in your field book. |RND| on the second menu page will round the target elevation and the rod elevation to whatever decimal places you specified. This rounding takes place before the cut and fill is figured out. Please note, that the display is still going to display at whatever decimal places the calculator was set for.

Keys:
|PT#EL| expects a point number and recalls the elevation of that point.
|BS| expects a Back Sight rod reading and calculates HI from current elevation.
|HI| expects a Height of instrument.
|FS| expects a Fore Sight rod reading and calculates a new elevation from current HI and C/F.
|TARG| expects an elevation to calculate a cut or fill value to.
|ELEV| expects an Elevation.

|>VIEW| view settings. [/->] |>VIEW| switches options.
|RND| decimal points to round to (for 3-wire and c/f.)

Example:
Say you had level notes like these

STA       BS         HI       FS        ELEV 
1         5.43      30.82               25.39
2                             3.98      26.84
3                             4.22      26.60
4                             2.90      27.92
5         8.19      34.45     4.56      22.26
6         5.67      31.57     8.55      25.90
1                             6.18      25.39

You could use this program to reduce the notes. First, set your display to the appropriate decimal places since this program displays using what your calculator is set to. In this case, 2 decimal places would be appropriate.

2 [EEX]

25.39 |ELEV|

5.43 |BS|

3.98 |FS|
4.22 |FS|
2.90 |FS|
4.56 |FS|

8.19 |BS|

8.55 |FS|
5.67 |BS|
6.18 |FS|

EDM note reduction
This was an add-on program in previous versions, but at an overhead of only about 3600 bytes I just included it and left it as a hidden program. What this program does is reduce EDM notes 3-dimensionally. Again there is no correction for curvature or refraction, and of course there is no provision for descriptions.

While one could use this for reducing topo notes, commercial software does this much better. A data-collector is better yet. I use it for checking raw file processing, and I know someone who checks edm leveling with it.

If you change the settings to AUTO-Store, it will automatically store 3-dimensionally to file. If not, the results are left on the stack with the point in level 2 and elevation in level 1. So, you could just press [STO] and it will still store it 3-dimensionally.

To get to this program submenu, at the main menu press [/->] |TRAV|. Since this actually goes beyond the scope of what the program pack is intended for, it's not openly included on the main menu. If you would like to add it to your own CST variable or assign it to a key, the library function name is EDMMENU.

What you do is enter all the variables and press |SOLVE|. You have four modes to choose from and you move through them with [/->] |>VIEW|.

LOT Corners, area
I did want to name this program "Parcel" something or other, but "LOT" is just so much shorter and fits all on one softkey, so that's why I went with it. Perhaps one day I'll change that. What this program does is to calculate the coordinates of the corners of a lot or parcel as you traverse your way around the perimeter. It also lets you include arcs as needed, in which case the radius point will be calculated too. In addition to calculating the coordinates, it also calculates the area using the DMD method as opposed to the coordinate method. There are three forms of output available for this program. You can store the coordinates to the currently active coordinate file, you can print it to the IR printer, or you can have it create a variable called OUT.TXT which you can send to your PC and print out (it's basically a coordinate file with descriptions.)

So here's how it goes. You create or select a file just like you do with GRADESTER or the Traverse W/Closure program. Next, you enter your starting point with |START|. This works just like its Traverse W/Closure counterpart except you enter a coordinate instead of a point number. When you enter a coordinate with |START|, you clear out whatever perimeter information you may have entered in this file previously. Next you enter each "LEG" as you traverse around the perimeter. Pressing |ENTR| will run a program to let you enter each leg. Just |CANC| when finished entering your legs. Please note that the prior leg's values will remain in the boxes because sometimes you want to repeat a direction or distance or maybe even the radius. If you made some entry mistakes, you can fix them with the editor. When you think all's well, you can evaluate the file with |EVAL|. |EVAL| will process the file and then prompt you for an initial point number. This is the number you want to begin numbering your coordinates at. If you enter an empty line, it will just cancel the processing, if you enter a point number, then it will generate a report you can page through.

At this point |OUTPU| will be one of the softkeys. Pressing it will let you choose how or if you want to produce output. If you choose |STORE|, it will try to store the points to the currently active coordinate file. Here's how it operates:

• If your initial point is before the beginning or more than ten points past the end of the coordinate file, it will not proceed.
• If there is not enough memory, it will not proceed.
• If there are already coordinates stored in that range and all else is okay, it will just overwrite them.
• The coordinate file will be enlarged if needed.

Now, for any of this to work, I need to explain to you what I am calling a "LEG." I couldn't come up with a better name, so I just call it a "leg." In this case, a leg is a line segment defined by a distance and a direction and an arc on the end of it which is defined by the direction and radius. The direction defines the ingoing tangent of the arc, and the outgoing tangent is defined from the next leg in the circuit. If it's the last leg, then it picks it up from the first leg. You can have a leg that has a direction, a non-zero distance, and zero for radius which would make it just a straight line segment. You can have a leg that has a leg with a direction, zero distance, and a non-zero radius. This would be good as the start of an arc which doesn't come off of a straight part or doesn't follow the straight part. You could have leg with a direction, a zero distance, and zero radius. This would be good for ending an arc that doesn't follow the next tangent section. Anyway, this scheme seems to work so far. The 48 is limited, so checks are limited. There is no checking for crossing lines, extraneous legs (zero distance and radius and no purpose), or other bogus information.

This program determines which way you are going around the perimeter by the change in directions. SO, if you have crossing lines or too many extraneous legs, you could get a bogus answer. Just to let you know.

|>VIEW| views status. [/->] |>VIEW| toggles bearing and azimuth modes.
|START| expects a coordinate. It clears out current entries and stores starting point.
|FILER| creates, deletes, selects files and directories.
|EVAL| processes the LOT file and allows you to produce output if desired.
|EDIT| interactive file editor.
|ENTR| activates program to enter each leg. Just fill in the boxes and press |OK|. |CANC| when done.

Personal note: This program is an experimental one. Originally started as a prototype for a PC program requested by several people, the one person who has been my guru on cadastral computer stuff has since retired. Regretfully, this was not completed in time for a review by him for integrity. Unable to reverse time (and I REALLY wish I could) I can only tender this program to the rest of the world for review.

Based on feedback, I will decide if to further polish this program or make this the only offering of it. It took a lot longer to do than I normally take to do one, even one of this complexity. It wasn't especially difficult, just tedious. There were many setbacks which made me think it wasn't meant to be. The setbacks were not programming related, but every time I started working on it, something would pull me from it, a bad omen to say the least. So, if you happen along this program during the year 2003 and you have an opinion (feedback) on it, good or bad, please feel free to email me with it. Thank you!

Examples:
Let's do the pretend-lot in this illustration.

|FILER|

|NEW|
|FILE|
LOT1 [ENTER]
|EXIT|

1000 [ENTER]
1000 |START|

|ENTR|

90 [ENTER]    (direction of ingoing tangent to curve)
0 [ENTER]     (no straight part)
25 [ENTER]    (radius = 25)
|OK|          (stores leg, continue to next leg)

0 [ENTER]     (direction of straight part)
75 [ENTER]    (distance of straight part)
0 [ENTER]     (no radius)
|OK|          (stores leg, continue to next leg)

270 [ENTER]   (direction of straight part)
200 [ENTER]   (distance of straight part)
|OK|          (stores leg, continue to next leg)

180 [ENTER]   (direction of straight part and ingoing tangent)
75 [ENTER]    (distance of straight part)
25 [ENTER]    (radius = 25)
|OK|          (stores leg, continue to next leg)

90 [ENTER]    (direction of straight part)
150 [ENTER]   (distance of straight part)
0 [ENTER]     (no radius)
|OK|          (stores leg, continue to next leg)

|CANC|        (end entry)

|EVAL|

1 [ENTER]

|EXIT|

1000 [ENTER]
1000 |START|  (clear out prior perimeter, enter start point)

|ENTR|        (start up entry program)

270 [ENTER]   (direction of straight part and ingoing tangent to curve)
150 [ENTER]   (distance of straight part)
25 [ENTER]    (radius = 25)
|OK|          (stores leg, continue to next leg)

0 [ENTER]     (direction of straight part)
75 [ENTER]    (distance of straight part)
0 [ENTER]     (no radius)
|OK|          (stores leg, continue to next leg)

90 [ENTER]    (direction of straight part)
200 [ENTER]   (distance of straight part)
|OK|          (stores leg, continue to next leg)

180 [ENTER]   (direction of straight section and ingoing tangent)
75 [ENTER]    (distance of straight part)
25 [ENTER]    (radius = 25)
|OK|          (stores leg, continue to next leg)

|CANC|        (end entry)

2000 [ENTER]
2000 |START|       (clear out prior perimeter, enter start point)

|ENTR|             (start up entry program)

338.4347 [ENTER]   (direction of straight part)
100 [ENTER]        (distance of straight part)
0 [ENTER]          (no radius)
|OK|               (stores leg, continue to next leg)

248.4347 [ENTER]   (338.4347 - 90 direction of ingoing tangent to curve)
0 [ENTER]          (no straight part)
500 [ENTER]        (radius = 500)
|OK|               (stores leg, continue to next leg)

291.3353 [ENTER]   (201.3353 + 90 direction of outgoing tangent to curve)
0 [ENTER]          (no straight part)
0 [ENTER]          (no radius)
|OK|               (stores leg, continue to next leg)

201.3353 [ENTER]   (direction of straight section and ingoing tangent)
100 [ENTER]        (distance of straight part)
|OK|               (stores leg, continue to next leg)

111.3353 [ENTER]   (201.3353 - 90 direction of ingoing tangent to curve)
0 [ENTER]          (no straight part)
600 [ENTER]        (radius = 600)
|OK|               (stores leg, continue to next leg)

428.4347 [ENTER]   (338.4347 + 90 direction of outgoing tangent to curve)
0 [ENTER]          (no straight part)
0 [ENTER]          (no radius)
|OK|               (stores leg, continue to next leg)

|CANC|             (end entry)

Back to doing math while entering your legs, when you are at the entry screen, you can press [NXT] and the menu keys change to of which |CALC| will let you use the calculator functions including the ones assigned to the keys like HMS+ and HMS-. Just press |OK| when you are finished and the result is entered in the box. You just have to play around with it to figure out how it works.

• LET'S YOU USE THE CALCULATOR AS A CALCULATOR FOR MOST THINGS!!!!!!
• ANSWERS ARE OFTEN LEFT ON STACK FOR USE IN OTHER PROGRAMS, THE SCRATCH PAD!
• ANSWERS OFTEN HAVE USEFUL TAGS TO REMIND YOU OF THIER VALUE
• USE OF A COORDINATE FILE IS OPTIONAL
• ABLE TO CHANGE "FILES", NOT STUCK USING ONE "FILE"
• WORKS IN ANY NORMAL DIRECTORY
• USES "FILES" ONLY IN CURRENT DIRECTORY TO FACILITATE ORGANIZING WORK BY PROJECTS
• GRAPHICAL FILE AND DIRECTORY SELECTION!!!
• UNAFFECTED BY FLAG SETTINGS (EXCEPT USER FLAG 2)
• RUNS OUT OF ANY PORT SO YOU HAVE MORE USEABLE RAM FOR OTHER THINGS
• COORDINATE FILE FORMAT IS VERY SIMILAR TO TDS' COGO CARD'S FORMAT, hmmmmm!!!!!
• NORTH AND SOUTH AZIMUTH MODES
• CHOICE OF BEARING ENTRY STYLES
• COORDINATE, TRAVERSE, GRADE AND LOT FILES ARE SAVEABLE
• PARAMETERS ARE NON-VOLATILE, AVOIDS NEEDLESS RE-ENTRY
• ABLE TO VIEW PARAMETERS/SETUP FOR VERIFICATION OR MEMORY AID
• VARIABLES KEPT IN HIDDEN DIRECTORY FOR PROTECTION AND CLEAN LOOK
• VERIFICATION SCREENS FOR SOLUTIONS
• OPTIONALLY PRINTS TO IR PRINTER FOR AUDIT TRAIL
• KEY ASSIGNMENTS ARE CAREFULLY CHOSEN TO FACILITATE MEMORIZATION AND FUNCTION
• INTUITIVE FILE EDITING
• TRAVERSE FILE RECALCULATES COORDINATES WITH EDITS
• LOT PROGRAM USES DMD METHOD FOR AREA
• ENTER PERIMETER CLOCKWISE OR COUNTERCLOCKWISE WITH LOT PROGRAM
• MAIN MENU REMAINS ON SAME PAGE AND IS GROUPED BY TYPES
• THOUGHTFULLY ORGANIZED MENUS
• REALLY COOL GRADE ROUTINES (CAN'T ALWAYS USE THE TOTAL-STATION FOR GRADES)
• ROUTINES ARE STRAIGHT FORWARD AND COMPLETELY INTEGRATED INTO A PACK
• ACCESS YOUR OWN ROUTINES WITH CST VARIABLE AND KEY ASSIGNMENTS
• DOES NOT ASPIRE TO DO ALL, USER IS ENCOURAGED TO INCLUDE OWN ROUTINES

This program removes libraries with the ROMIDs 1005 1006 1013 1014 1015. If you have a library you don't want to remove with one of these ROMIDs, then you should either modify the program before use, or manually remove the libraries.

1. Find the file included with this package named UNJ.

2. Transfer the file UNJ to the HOME directory of your HP-48.

3. Unlock any RAM cards that you loaded the program to that you wish to remove from.

4. Warm start your calculator by pressing [ON] + [C].

5. When your HP-48 comes back to life, press [VAR].

6. Press the key that corresponds to the file you just transferred, should be |UNJ|.

The program may not be able to remove the library file for some reason. Maybe the RAM card is write-protected or something like that. If so, correct the problem and perform steps 4 thru 6 again.

Please note that if you are removing the program to upgrade, this DOES delete the JSETTINGS variable which contains the program settings.

The UNJ program should be able to remove the library file from any of the RAM based survey programs I've distributed. However, if you are removing an early version, say versions prior to 3, or you've reassigned the keys, the key assignments may be different. This could cause a problem when using the current version of the survey package. I recommend you delete the key assignments if this is the case. All you would have to do is type in 0 DELKEYS into your HP-48. This will delete all the key assignments. By the way, that's a zero(0) not an O(oh.)

If you're not sure if you have an early version, you may be better off just doing the 0 DELKEYS or better yet, do the three finger salute and blank your RAM by pressing [A] [F] [ON] at the same time. This is because launching some of the routines without the proper variables on the stack could cause a memory reset, some of the early key assignments could possibly do this. Changing the key assignments is not so much of a problem unless library function numbers change, which they shouldn't.