Chameleon Terminal Emulator
Version 4.03
User's Guide
17 November 1984
(C)1984 John Howard Palevich
1. Introduction
1.1 Overview
Chameleon converts your Ataricomputer into a powerful
computerterminal. It emulates six terminals:"Glass TTY" (that is, a
video terminal with the same features as a printing terminal), Lear
Siegler's ADM-3A,Digital Equipment Corporation's VT-52,a non-standard
extension to the VT-52 called the VT-52XL, the IBM 3031 ASCII
terminal, and a Test terminal, useful for debugging. For every
terminal type besides Test, Chameleon supportstab,backspace, line
feed, form feed, and a visual bell signal. For the Glass TTY it
supports word-wrapping.
For the ADM-3A, the VT-52, and the VT-52XL, it also supports cursor
addressing and basic editing features. For the VT-52XL, it supports
character and line insert and delete, as well as reverse video. A
termcap entry is provided for use with unix operating systems.
Chameleon doesn't support the special graphics character set of the
VT-52 or some rarely used ADM-3A features.
Chameleon's major features are:
1. a 24-line, 40-, 80-, or
132-column character
display (displaying 40
columns at a time) with a
cursor lock feature for
automatic horizontal
scrolling
2. a buffer that saves up to
nine previous pages of text
3. continuous communications
at baud rates of 75 to 1200
baud and non-continuous
(requires flow control)
communication at rates of
1800 to 9600 baud
4. selectable parity
5. a BREAK signal
6. the full ASCII standard
character set
7. selectable duplex
8. the ability to copy text
from the screen and the
previous page buffer to a
file
9. the ability to transfer
files between the Atari and
most other computers, using
either flow controlled,
Modem, or Kermit protocols
10. using one of the supported
modems, the ability to
automaticly dial any of
sixteen stored phone
numbers, and to keep
dialing numbers until a
carrier tone is detected
11. a ram-resident disk utiltiy
program, allowing most of
the functions provided by
the DOS 2 menu
1.2 Required Accessories
- 48K RAM
- a disk drive
- at least one of the
following:
* Atari 850 Interface
Module, and a standard
RS-232C modem
* Atari 835 Modem
* Atari 1030 Modem
* Atari 1450 computer
(which contains a
modem)
1.3 Optional Accessories
- With the Atari 850, a Hayes
Smartmodem, or other Hayes
compatable modem
- Printer
1.4 Contacting the Author
Users wishing to contact the author about Chameleon way write to
him at:
John H. Palevich
175 Calvert Drive #F211
Cupertino, CA 95014
2. Getting Started
2.1 Attaching an RS-232C Device to the
Interface Module
If you are using an Atari 850, rather than one of the standard
Atari modems, you will have to attach your RS-232C device to the
Atari 850. Chameleon talks to Port 1 of the Atari 850. (This is the
default behavior -- you can use the R: Device menu line to make
Chameleon talk to any one of the four ports.) Only "Transmit
Data", "Receive Data", and "Ground" need to be connected. "Data
Terminal Ready" and "Request to Send" are set high (+12V = true) when
Chameleon starts. This is done as a convenience to devices requiring
these signals.
Chameleon ignores all other signals.
2.2 Loading Chameleon into Computer
Memory
To load Chameleon into computer
memory:
1. Remove all cartridges from
your Atari computer.
2. Make sure all equipment is
turned off.
3. Turn on all your
peripherals.
4. When the BUSY light goes
out on yur disk drive, open
the disk drive door and
insert the Chameleon
diskette with the label in
the lower right hand corner
nearest to you.
5. Turn on your computer and
TV screen and wait until
Chameleon's device menu
appears.
2.3 Chameleon's Device Menu
Chameleon can talk to a number of
Atari devices, but it has to know
which one it should use. The first
thing Chameleon will do is ask you
which device to use.
Below is an illustration of the
device menu, which is the first screen
you will see the first time you run an
un-modified copy of Chameleon 4.0. If
your copy of Chameleon has been
customized (by using command Z from
the utilities menu), Chameleon will
try to use the device you specified in
the Z command. If you have never used
the Z command, or if that device
doen't exist, you'll get this screen:
Chameleon Terminal Emulator
version 4.0
(c) 1984 John Howard Palevich
-------------------------------------
0 - no device (demonstration mode)
1 - Atari 850 with any modem
2 - Atari 850 with Hayes Smartmodem
(or compatible modem)
3 - Atari 835 modem
4 - Atari 1030 modem
5 - Atari 1450 internal modem
-------------------------------------
Which device to use (0-5)? _
-------------------------------------
Figure 2-1: Device Menu Screen
You should type in the number of the device you want to use (or 0
if you don't have any device, but still want to investigate
Chameleon). Then press the RETURN key. Chameleon will try to find
the specified device. If it can, you will shortly see the main menu
screen. Otherwise, you will be told that Chameleon failed to find
the device, and you will be asked for another device. If this
happens, make sure that your communications device is plugged in to
the wall, connected to your Atari, and turned on!
3. The Main Menu
3.1 The Main Menu Keys
After Chameleon finds a communications device, it presents you
with its main menu. This is the menu which lets you control
Chameleon's actions. It looks like this:
Chameleon (c)1984 John H. Palevich
-------------------------------------
->Terminal Glass TTY
Back S is CTRL-H
Left Margin 2
Line Length 80
Cursor Free
Scroll Smoothly
File Transfer Protocol None
File Name
File Type Text
Dialing Method Pulse
Modem Mode Originate
R: Device 1
Baud Rate 300
Parity None
Duplex Full
Flow Control ^S/^Q
-------------------------------------
OPTION -move cursor to next parameter
SELECT -change parameter's value
START -begin terminal emulation
D - dial a number U -utility menu
P - pick up phone H -hang up phone
S - save options R -restore options
CTRL-Q - quit Chameleon
Figure 3-1: Main Menu Screen
3.1.1 Selecting an item -- OPTION key
Each time you press the OPTION key, the arrow moves down one line
so that you can select the next item in the menu. You return to the
first menu item after reaching the last one. You can also reverse
the order by holding down the SHIFT key while pressing the OPTION
key, which causes the arrow to move to the previous menu item. With
this method, you return to the last menu item after reaching the
first one.
3.1.2 Selecting a value for an item
-- SELECT key
Each time you press the SELECT key, a new value displays for the
current menu item. Again, to reverse the order, hold down the SHIFT
key while pressing the SELECT key, which causes the previous value to
display.
3.1.3 Entering a file name
The "File Name" line of the menu displays the file currently
selected for file transfer operations. When you press the SELECT or
SHIFT-SELECT keys, a blinking cursor replaces the old file name.
Type in your new file name, using the BACK S key to correct any
errors. Press RETURN to remove the cursor.
If you always keep the "File Transfer Protocol" set to "None", then
you can safely ignore the "File Name" line.
3.1.4 Moving to terminal mode -- START
key
Press the START key to move from the main menu to the terminal
mode. See the chapter on terminal mode for details.
3.1.5 Dial a number -- D
If you have an Atari 835, 1030, 1450, or hayes Smartmodem
compatable modem, Chameleon can dial the other computer's number for
you. Type D from the main menu to go to the dial menu. See the
chapter on the dial menu for more information.
3.1.6 Utility menu -- U
Chameleon will let you perform many of the functions of the DOS-II
DUP program from within Chameleon. Type U from the main menu to go
to the utility menu. See the chapter on the utility menu for more
information.
3.1.7 Pick up the phone -- P
If you have an Atari 835, 1030, 1450, or Hayes Smartmodem
compatable modem, and you have manually dialed another computer,
typing P in the main menu will make Chameleon pick up the phone line
and attempt to establish communications with the other computer. If,
after thirty seconds, Chameleon hasn't established communication, it
will hang up the phone and return to the main menu. Type Q to quit
waiting for the other computer before the thirty seconds are up. If
Chameleon does establish communication, it will enter terminal mode.
3.1.8 Hang up the phone -- H
If you have an Atari 835, 1030, 1450, or Hayes Smartmodem
compatable modem, and you wish to terminate a phone connection with
another computer, type H in the main menu. Chameleon will hang up the
phone and return to the main menu. Hayes Smartmodem compatable
modems take up to ten seconds to do this. If you get impatient, you
may type Q to return to the main menu.
3.1.9 Save the main menu settings -- S
Chameleon can save the current menu item settings in a disk file
called LIZARD40.OPT. Current menu settings may be saved any time you
are in the main menu. Just insert a DOS-II formatted writable disk
in drive 1 and press the S key. Every menu item except the File Name
will be saved into the file D:LIZARD32.OPT.
3.1.10 Restore the main menu settings
-- R
Saved menu settings may be restored any time you are in the menu.
Just insert a DOS-II formatted disk containing the LIZARD40.OPT file
into drive 1 and press the R key. Chameleon will try to read the
saved options out of D:LIZARD40.OPT. If the file does not exist, or
cannot be read, then Chameleon uses its standard defaults. If the
file is read correctly, then menu items (except for the file name)
are set to the stored values.
Chameleon tries to read in the stored defaults when it is booted.
This makes it easy to customize Chameleon to your application.
3.1.11 Quit Chameleon -- CTRL-Q
Typeing CTRL-Q from the main menu will exit Chameleon and return
you to DOS. If you are using an 850 and DOS 2.0, you must
power-cycle your Atari before running Chameleon again. (Because
DUP.SYS writes over the R: drivers.)
3.2 Menu Items
3.2.1 Terminal
Use the first item to select the kind of terminal you want to
emulate. Your choices are:
Glass TTY This value simulates a
typical printing
terminal with tabs
every eight columns,
line feed, form feed,
backspace, carriage
return, and a visual
bell signal. In
addition, words typed
at the end of the line
are wrapped ont the
next line, making it
easier to read text
formatted for very
long lines. Glass TTY
is sophisticated
enough to be used with
many computer
installations.
However, it isn't
sufficient for time-
sharing computers
capable of sending
special characters for
cursor control,
character editing, and
so on. Select one of
the video terminal
values to communicate
with such computers.
VT-52 This value simulates
the DEC VT-52
terminal, except for
the keypad and the
special graphics
character set.
Chameleon doesn't
support the Enable
Graphics and Disable
Graphics commands.
Normal mode lowercase
characters print in
place of graphics.
While the alternate
keypad mode isn't
supported, you may
type sequences from
the following table to
emulate the keypad:
Key Normal Appl.
0 0 ESC ?p
1 1 ESC ?q
2 2 ESC ?r
3 3 ESC ?s
4 4 ESC ?t
5 5 ESC ?u
6 6 ESC ?v
7 7 ESC ?w
8 8 ESC ?x
9 9 ESC ?y
- minus ESC ?m
, comma ESC ?l
. period ESC ?n
ENTER RETURN ESC ?M
up ESC A ESC A
down ESC B ESC B
right ESC C ESC C
left ESC D ESC D
blue ESC P ESC P
red ESC Q ESC Q
grey ESC R ESC R
Table 3-1: VT-52 Alt. Keypad Mode
VT-52XL This terminal is just
like a VT-52, except
that four additional
escape sequences have
been defined to aid
editing. See the
chapter on character
and contol codes for
more details.
ADM-3A This value simulates a
Lear Siegler ADM-3A
terminal. It supports
Option A (24 lines)
and Option No. 1
(lowercase
characters). However,
it won't beep when the
cursor crosses the
72nd character
position.
IBM 3031 Chameleon will emulate
an IBM 3031 mainframe
terminal is this mode.
Basically, in 3031,
it's a Glass TTY with
half duplex, and the
Kermit protocol checks
this value to
determine if you are
talking to an IBM
mainframe.
Test Characters sent to the
screen while Chameleon
is in Test mode are
printed as is. None
of the control
characters (even CR)
are treated specially.
When the cursor
reaches the right
margin, it moves down
to the next line.
When the cursor
reaches the bottom of
the screen, it scrolls
the whole screen
upward one line.
thus, the last several
thousand characters
sent to Chameleon will
be visible on the
screen. This mode is
useful for debugging
new time-sharing
systems because it
lets you find all
padding characters
(like nulls and rub
outs) or other control
characters the other
system might be
sending you.
3.2.2 Back S is
This item controls which character is sent to the other computer
when you type the BACK S key. The choices are:
CTRL-H This choice sends an
ASCII BS (8) when you
type the BACK S key.
To get RUB you type
SHIFT-BACK S.
RUB OUT This choice sends an
ASCII RUB (127) when
you type the BACK S
key. To get BS you
type CTRL-H.
3.2.3 Left Margin
many TV sets overscan. making the left two character positions of
the screen un-readable. This item lets you select your left margin.
Your choices are:
0 This choice lets you
see a full forty
characters across.
1 This choice gives you
a one character
margin.
2 This choice gives you
a two character margin
(like BASIC).
3.2.4 Line Length
The line length of Chameleon can be
adjusted to suit your
preferences. The
choices are 40, 80,
and 132 characters
long.
3.2.5 Cursor
This item controls the behavior of the cursor. There are two ways
the cursor can behave:
Free The cursor is free to
travel off the screen.
On Screen The cursor is forced
to remain on the
screen at all times.
On Screen is useful
for editing text when
the line length is set
to 80 or 132.
3.2.6 Scroll
When Chameleon does a line feed at the bottom of the screen, it has
to move the text up one line, to make room for the new line. It can
move the text up in two different ways:
Smoothly which takes about an
eighth of a second,
but looks pretty.
Coarsly which takes almost no
time at all, but looks
ugly.
3.2.7 File Transfer Protocol
This item controls which type of file transfer Chameleon will do.
See the chapter on transfering files for more information. The
choices are:
None No file transfer is
selected
Snapshot Transfer characters
from the screen to an
Atari device
Send Transfer characters
from an Atari device
to another computer
Receive transfer characters
from the other
computer to an Atari
device
Modem Send Transfer files from an
Atari device to
another computer using
the MODEM2 protocol
Modem Receive Transfer files from
another computer to an
Atari device using the
MODEM2 protocol
Kermit Send Transfer files from an
Atari device to
another computer using
the Kermit protocol
Kermit Receive Transfer files from
another computer to an
Atari device using the
Kermit protocol
3.2.8 File Name
The file transfer modes need a file name. If you have "File
Transfer Protocol" set to "None", you needn't consider this line.
Pressing the SELECT or SHIFT-SELECT keys for this item causes a
blinking cursor to appear. Type in the name of the file you want to
use. use the BACK S key to correct typing mistakes. Type RETURN to
finish entering the file name. See the chapter on transfering files
for more information.
3.2.9 File Type
Use this type to tell Chameleon what kind of file you play to
transfer. Chameleon needs this information to decide waht to do with
end-of-line and tab characters. The choices are:
Text This choice tries to
map ASCII CR/LF to
ATASCII EOL, and ASCII
TAB to ATASCII TAB.
During sending, EOL is
converted to CR.
During receiving, CR
is converted to EOL
and LF is ignored.
Use this mode when
transfering text files
between your computer
and another brand of
computer.
Binary In this choice, all
characters are sent
and received as is.
Use this mode when
transfering text files
between your computer
and another Atari
computer, or when
transfering non-text
files between your
computer and any other
computer.
3.2.10 Dialing Method
If you have an Atari 1030, or Hayes Smartmodem compatable modem,
you can choose which dialing method to use when auto-dialing. The
other modems that Chameleon supports can only pulse dial.
Pulse use pulse dialing
(which is universal)
Tone use pone dialing
(which is faster)
3.2.11 Modem Mode
If your have an Atari 835, 1030, 1450, or Hayes Smartmodem
compatable modem, you can choose to set your modem's communication
mode. In any modem based communication, one of the modems must be
set in originate mode, and the other in answer mode.
Originate This mode is used to
communicate with most
time-sharing systems,
bulliten boards, etc..
Answer This mode is used to
communicate with
another computer which
has it's modem in
orginate mode.
3.2.12 R: Device
If you are not using an Atari 850 Interface Module, you may ignore
this item. If you are using an 850, this item selects which of the
four RS-232C ports Chameleon will use for communication. Most people
use only port number one, but the choices are 1, 2, 3, or 4.
3.2.13 Baud Rate
Use this item to select the baud (data transmission) rate. The
values are in bits per second. Consult the manual or authorities for
the system you're using for appropriate baud rates. Continuous
transmission choices are: 75, 110, 134.5, 150, 300, 600, or 1200
baud. Non- continuous transmission (i.e. you'll need flow control,
or you'll lose characters) is available at 1800, 2400, 4800, and 9600
baud.
3.2.14 Parity
Use this item to select the kind of parity check sent from
Chameleon to the other computer, and the kind of parity Chameleon
expects from the other system. Consult the manual or authorities for
the system you're using.
None There is no parity
bit; all eight bits of
the character are
considered to be data.
Odd Characters are sent
with odd parity.
Received parity is
ignored.
Even Characters are sent
with even parity.
Received parity is
ignored.
Off Characters are sent
with the parity bit
set to zero. Received
parity is ignored.
3.2.15 Duplex
Use this item to control where the characters you type are sent.
Full Keyboard characters go
to the other system.
Half keyboard characters go
to both the other
system and the screen.
Use this mode to talk
to systems requiring
half duplex.
3.2.16 Flow Control
This item selects the way in which Chameleon controls the flow of
data between itself and the other computer. The choices are:
None which means that the
other computr has no
means of flow control.
When None is selected,
the File Transfer
Protocol modes send
and receive, and baud
rates in excess of
1200 baud, will
probably lose
characters.
^S/^Q Which means that the
other computer will
stop sending when it
receives an ASCII
XOFF(^S, code 19) and
resume sending when it
receives an ASCII
XON(^Q, code 17).
When Chameleon is
Sending a file, it
will pause on a ^S/^Q
pair sent by the other
computer.
Echo Echo acts just like
None, except during
Sending, when
Chameleon waits for
the character sent to
the other computer to
come back (or "echo").
THis mode is designed
to allow sending text
to slow time sharing
systems that do not
support the ^S/^Q
protocol. If a
character doesn't echo
within one quarter of
a second, then the
sending continues
anyway.
Short Delay Acts just like None,
except during Sending,
Modem Sending, Kermit
Sending and Kermit
Receiving, when it
inserts a 1/60th of a
second delay between
each character sent to
the other computer.
This delay allows slow
computers enough time
to process each
character.
Medium Delay Acts just like Short
Delay, except the
delay is for 1/15th of
a second.
Long Delay Acts just like Short
Delay, except the
delay is for 1/4th of
a second. If the
other computer still
can't keep up, and
Echo mode doesn't work
either, then you might
as well type the
information in by
hand!
3.3 Example: Settings for
Communication with Compuserve
If you want to call ComuServe, or MicroNET through CompuServe, your
settings typically would be a follows:
Terminal Glass TTY
Back S is CTRL-H
Left Margin 2
Line Length 80
Cursor Free
Scroll Smoothly
File Transfer Protocol None
File Name
File Type Text
Dialing Method Pulse
Modem Mode Originate
R: Device 1
Baud Rate 300
Parity Even
Duplex Full
Flow Control ^S/^Q
Figure 3-2: Typical Main Menu
4. Dial Menu
Chameleon uses the dial menu to automaticly dial a computer's phone
number for you. You must have either an Atari 835, 1030, 1450, or
Hayes Smartmodem compatable modem for the dial menu to work. To get
to the dial menu, type D from the main menu. The dial menu looks
like this:
Computer Name (baud rate) # 555-1212
-------------------------------------- ->
-------------------------------------
-------------------------------------
OPTION - move cursor to next number
SELECT - enter new number
START - dial number
A - dial all numbers
S-save numbers R- restore numbers
ESC - go back to main menu
Figure 4-1: Dial Menu Screen
4.1 Dial Menu Keys
4.1.1 Selecting an item -- OPTION key Each time you press the
OPTION key, the arrow moves down one line so that you can select the
next phone number in the menu. You return to the first phone number
after reaching the last one. You can also reverse the order by
holding down the SHIFT key while pressing the OPTION key, which
causes the arrow to move to the previous phone number. With this
method, you return to the last phone number after reaching the first
one.
4.1.2 Entering a phone number
To enter a phone number, use OPTION to move the arrow to a blank
line (or a line containing a phone number you wish to replace) and
press SELECT. A blinking cursor appears. Type in your new phone
number, using the BACK S key to correct any errors. Press RETURN to
finish entering the phone number. A valid phone number has three
parts:
- Name
This is the name of the
computer. It is ignored by
Chameleon. It's what you
use to remember which number
calls what computer. The
name can contain any
printing characters except
for '#' and '('.
- (Baud)
This is the baud rate of the
other computer's modem. If
this part of the phone
number is missing, the baud
rate from the main menu is
used. The only two valid
baud rates for this are
"(300)" and "(1200)". If
your modem can't actually
communicate at 1200 baud,
Chameleon will use 300 baud
no matter what you say.
- #Digits
This is the actual number to
dial. It can consist of any
number of digits and the
characters " ()-,". Digits
are dialed in order. The
characters " ()-" are
ignored, and the ","
character causes Chameleon
to pause for three seconds
-- which is useful when
you're going through a
private telephone system.
Here are some imaginary but valid phone number entries. Note that
the last one simply picks up the phone and waits for a carrier.
Joe's BBS & Grill(1200)#9,18005551212
Molly's Sine City (300) # 555-1212
Annoy the Opertor # 0
Long Distance # 1 (617)253-1000
# 411
Table 4-1: Valid Phone Numbers
Here are some imaginary but invalid phone number entries, along
with the reasons they're invalid:
555-1212
-- need a '#' before the digits
A#1 BBS # 555-1212
-- can't have a '#' in the name
Touchie's # 555-1212 * 444
-- can't dial the '#' or '*' tones
(Secret Agent) # 555-0007
-- can't have a '(' in the name
Fogey (110) # 555-1212
-- can't choose a 110 baud rate
Table 4-2: Invalid Phone Numbers
After you enter a number, be sure to use the S command to save the
numbers to diskette! Any time you exit the dial menu, and changes
you may have made since the last S command will be lost!
4.1.3 Dialing a number -- START key
Press the START key to dial the phone number you've selected.
Check the status line (located between the list of phone numbers and
the instructions) to follow the progress of your call. Type a 'Q' to
quit dialing. If, after thirty seconds, Chameleon can't establish
communication with the other computer, it will return to the dial
menu. If Chameleon succeeds in establishing communications with the
other computer, it'll go to terminal mode. (See the terminal mode
chapter for details.)
4.1.4 Dialing a sequence of numbers - A key
It's a universal law: "A good computer's number is busy." If the
computer you're trying to reach is a popular one, it's likely that
the phone number will be busy when you call it. If you'd like, you
can have Chameleon dial a group of telephone numbers in sequence
until it finally establishes communication with another computer.
All you have to do is position the arrow next to the first number
you'd like to try and press the 'A' key. Chameleon will then try
each number in turn until it finds another computer. Blank lines are
skipped, so if you want it to try the same number over and over
again, blank out the other lines by pressing SELECT then RETURN for
each one. When it finds another computer, it will enter terminal
mode.
Since none of the modems Chameleon works with can detect a busy
signal, Chameleon must wait 30 seconds after dialing a phone number
before it gives up. Sorry 'bout that.
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Please be careful when you use the A command. If you accidentally
annoy a telephone user by repeatedly dialing their number, your phone
company will probably take away your telephone connection.
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
4.1.5 Save the phone numbers -- S
Chameleon can save the current phone numbers in a disk file called
D:LIZARD40.NUM. Just insert a DOS-II formatted writable disk in
drive 1 and press the S key.
4.1.6 Restore the phone numbers -- R
Saved phone numbers may be restored any time you are in the dial
menu. Just insert a DOS-II formatted disk containing the LIZARD40.NUM
file into drive 1 and press the R key. If the file does not exist, or
cannot be read, then Chameleon uses its standard defaults. If the
file is read correctly, then the phone numbers are set to the stored
values.
Chameleon tries to read in the stored defaults whenever it enters
the dial menu.
4.1.7 Return to the main menu -- ESC
Typing the ESC key will return you to the main menu without trying
to dial a phone number.
5. Utility Menu
Typing a U while in the main menu gets you the ram resident disk
utilities. This is a menu modeled upon the standard DOS 2.0 menu,
and it provides many of the more useful (and not coincidentally
easiest to implement) features of the DOS 2.0 menu. Here's what it
looks like:
Ram Resident Disk Utilities 2.0s
A. Disk Directory E. Rename File(s)
B. Go To Main Menu F. Lock File(s)
C. Copy File G. Unlock File(s)
D. Delete File(s) I. Format Diskette
Z. Set Default Communication Device
Select item or RETURN for menu _
Figure 5-1: Utility Menu Screen
If you have used the DOS 2.0 menu, you shouldn't have any trouble
with the utility menu. Some of the options are missing, and others,
like the C command, don't have the options that are available on the
DOS 2.0 menu. This menu is intended to allow you to do the most
important DOS functions while remaining within Chameleon. If you
find that the functions provided aren't enough, you'll have to quit
Chameleon, use the real DOS menu, and restart Chameleon.
All utility menus are selected by typing the letter of the utility
then the RETURN key. Most of the utilities will ask for an
additional line of input, which you should type in, ending with the
RETURN key. If you change your mind about executing a utility, type
the BREAK key rather than the RETURN key.
5.1 Disk Directory -- A
The A command is used to get a disk directory. If you want to see
all the files on disk 1, just type RETURN when you are asked for a
"Search spec". Otherwise, type in the search specification you want.
The directory will be shown on the screen.
5.2 Return to the main menu -- B
The B command returns you to Chameleon's main menu.
5.3 Copy a file -- C
The C command copies a single file. This command can be used (like
it's DOS 2.0 counterpart) to send a file to the screen or the
printer, as well as transfer a file from one diskette to another. It
cannot, however, append one file to another, nor can it copy multiple
files from one place to another.
5.4 Delete file(s) -- D
The D command deletes all files that match the "Delete file spec".
All the files will be deleted at once -- you will NOT be asked about
each one. (i.e. the /N option is always in effect.)
5.5 Rename file(s) -- E
The E command renames all files matching the search spec before the
comma to match the search spec after the comma. Remember that the
device specifier is included only for the spec before the comma.
5.6 Lock file(s) -- F
The F command locks all files matching the search spec. Locked
files cannot be deleted, renamed, or over-written. Locked files
appear with an asterisk before their names in a directory listing.
5.7 Unlock file(s) -- G
The G command unlocks all files matching the search spec. Unlocked
files are the ordinary kind that can be deleted, renamed, and
overwritten.
5.8 Format Diskette -- I
The I command asks you which drive you wish to format, makes sure
that you want to format it, then formats that drive. Be careful not
to format a diskette containing information that you wish to keep.
5.9 Set Default Communication Device -- Z
The Z command sets the default communication device by saving the
device number you select in the file D:LIZARD40.DEV.
When Chameleon is booted, it looks in the file D:LIZARD40.DEV for a
device number, and tries to boot that device first. If the default
device is connected and turned on, Chameleon will boot it and go to
the main menu automaticly. If the device doesn't respond, Chameleon
will tell you so and stay in device menu.
If you regularly use only one particular communications device,
setting a default communication device will save you some time and
effort.
6. Terminal Mode
Terminal mode is the mode you use to actually communicate with
another computer. It's a grey screen with (some of the time) a line
of inverse-video text at the top. When you first enter terminal
mode, the screen will look like this:
Terminal mode... (OPTION - quits)
-------------------------------------
[]
Figure 6-1: Terminal Mode Screen
The terminal mode consists of two parts, the status line (in
reverse video), and the terminal display, which is twenty four lines
of grey text. Located at the left margin of the top line of the
terminal display is a green box. This is the terminal display's
cursor.
6.0.1 Recalling the main menu --
OPTION key
When you're in terminal mode, you can recall the main menu by
pressing the OPTION key. The arrow will point to the last menu item
you selected. Characters sent to you while you're in the main menu
will be lost.
6.0.2 Vertical and horizontal
scrolling
Most time sharing system programs format text for 80 column wide
printing terminals. Since the Atari video screen is only 40
characters wide, and only 24 lines high, you can't see all the text
at one time.
Your Atari can, however, keep much more text in its memory than it
can show on the screen. Chameleon uses this ability to give you most
of the benefits of an 80 column screen as well as most of the
benefits of a printing terminal.
In essence, when you are in the terminal mode Chameleon shows you a
24 x 40 character window onto a much larger "virtual" screen. This
virtual screen is as wide as the Line Length item of the menu, which
is to say between 40 and 132 characters wide, and as long as it can
be and still fit in your Atari'S memory. The virtual screen is
always between 24 and 255 lines long, depending upon the amount of
memory your Atari has, the File Transfer Protocol, the Baud Rate, and
the Line Length.
You navigate around the virtual screen with aid of the START,
SELECT, and SHIFT keys. To try horizontal and vertical scrolling,
use the main menu to set the Terminal Type to Glass TTY, the Cursor
to Free, the Duplex to Half, the File Transfer Protocol to None and
Line Length to 80. Press START to enter the terminal mode.
6.0.2.1 Vertical Scrolling--SELECT key
If you type some text and then type the RETURN key repeatedly,
you'll soon notice that the cursor moves down to the bottom line of
the screen and remains there, while the text you've typed in scrolls
off the top of the screen. If you press and hold the SELECT key, the
screen will scroll down and the text you typed will return to view.
As this happens, the cursor changes to an arrow pointing down to its
"true" position. As you continue to hold down the SELECT key, the
text you typed will continue to scroll down, and if you have enough
memory, it will even disappear from view off the bottom of the
screen.
Eventually, though, you'll bump into the upper screen. Press and
hold the RETURN key, and in a little while the text you typed will
scroll off the top of the virtual screen, too. Once it does this it
has been erased from the Atari's memory and can never be retrieved.
To return to the bottom of the virtual screen, press the SHIFT+SELECT
keys and hold them down. The screen will scroll up and bring the
cursor back into view.
6.0.2.2 Horizontal scrolling--START
and SHIFT + START keys
Type a sentence (such as, "The quick brown fox jumped over the...")
until you reach the right-hand side of the line. If you continue to
type, you'll notice the cursor has become an arrow pointing right,
off the edge of the screen, toward where the next character should
display. Press the START key and watch the characters scroll
leftward, until the screen is blank and the cursor has changed back
into a small square on the left-hand edge of the screen. You've just
used the START key to scroll, character-by- character, to the
rightmost 40 columns of the 80-column display.
To return to the first 40 columns, press SHIFT+START. You can use
START and SHIFT+START to center the cursor on whatever column you
wish. When the cursor is positioned in its true location, it
displays as a square. When it is located in a screen area other than
its true location (i.e., in the previous page buffer or on columns
across the screen), it displays as an arrow pointing towards its true
position.
6.0.2.3 Combining vertical and
horizontal scrolling
You can use the SELECT and SHIFT+SELECT keys and the START and
SHIFT+START keys to position yourself anywhere on the virtual screen.
If characters are typed by you or sent by the remote computer while
the cursor is off the screen, they will be displayed in the correct
spot, but you won't see them until you return to the portion of the
screen that contains the cursor.
6.0.2.4 Locking the Cursor for Faster
Data Entry
Set the CURSOR item of the menu to ON SCREEN. This causes
Chameleon to keep the cursor on the screen at all times. If
characters sent to the screen would cause the cursor to move off the
screen, Chameleon will scroll automatically to keep the cursor square
on the screen. This feature is useful when you have a lot of
information to type in. You can type faster when Chameleon keeps
track of the cursor on the screen, because you won't have to stop
every few words to reposition the cursor with the START and
SHIFT+START keys.
For long printouts, many people prefer to control scrolling
themselves (CURSOR LOCK OFF), since them can them move the screen
around to read the text at their own reading rate as well as back up
to reread a section.
6.0.2.5 File Transfer Protocol and the
Virtual Screen
All the file transfer protocols except Snapshot work more smoothly
when there is a large amount of memory to buffer text. When File
Transfer Protocol is set to any of these modes the virtual screen is
reduced to 24 lines (the height of the actual screen). When the File
Transfer Protocol is set to None or Snapshot, Chameleon does not need
to buffer text, and so the virtual screen again expands to fill all
of the memory.
6.0.2.6 When is the Virtual Screen
Cleared?
The virtual screen is cleared of all the text it contains whenever
its size or shape is altered. In particular the screen will clear
if:
- you change from one the the
buffered File Transfer
Protocol modes to one of the
unbuffered File Transfer
Protocol modes
- you change the baud rate
- you change the Line Length
The most important case where the virtual screen will NOT clear is
when you change File Transfer Protocol from None to Snapshot, which
makes it easy to copy a portion of your virtual screen to file.
6.0.3 System Reset and Break Key
If you press the SYSTEM RESET key, you'll have to power-cycle your
Atari to regain control.
Chameleon has disabled the computer console's BREAK key in menu or
terminal mode because it's so easy to press mistakenly and because
the interface module software would stop sending data in that case.
When a file I/O is in progress (for example, when you're entering
or leaving menu mode, or during File Transfer Protocol mode), you can
use the BREAK key to abort the I/O.
6.0.4 Sending a "Break" Signal to the
Host Computer
You'll sometimes want to send a "break" signal to the host
computer-- to tell it to stop sending data. To do so, press the
SHIFT+Atari keys. Each time you press these keys, Chameleon will send
a half-second of BREAK signal to the other computer.
File Transfer Protocols
and Technical Information
1. Simple File Transfer Protocols
1.1 Terms
File Transfer Protocol
is a generic term for
any method of moving
data from one place to
another, for instance,
between two Atari
computers or between
an Atari computer and
a large time sharing
system.
Sending refers to moving data
from your Atari
computer to some other
computer.
Receiving refers to moving data
from another computer
into your Atari
computer.
There are many ways to send and receive information. Chameleon
supports three different file transfer protocols:
- simple protocols, which can
be used with almost any
other computer
- Modem protocols, which work
with many microcomputers
- Kermit protocols, which work
with many time-sharing
computers
The Modem and Kermit protocols are described in later chapters.
This chapter describes the simple protocols. These protocols have
been designed to work with almost any other computer or time-sharing
system. Unfortunately, these protocols are not as easy to use, nor as
error-resistant as the Modem or Kermit protocols. If the computer
you want to talk to supports either the Modem or the Kermit
protocols, you should use them instaid.
1.2 Flow Control
Since the Atari computer can't receive characters while it is
accessing the disk drive, Chameleon must be able to tell the other
computer to stop sending information, then to start sending it again.
This ability to stop and start is known as flow control.
For the simple protocols, that is, for Send and Receive, Chameleon
uses ^S/^Q flow control. This is also known as XON/XOFF flow
control, and is supported my most time sharing computers. If this
isn't the case with your computer, contact the system's staff and ask
about getting "XON/XOFF flow control" installed (or write a program
to simulate such a feature). "XON/XOFF flow control" refers to the
process whereby a system stops printing characters when you (or
Chameleon) send it an ASCII ^S (for XOFF), and then waits for you (or
Chameleon) to send an ASCII ^Q (for XON), when it continues sending
characters.
Chameleon uses this flow control to tell the system to stop sending
characters for a moment, so that it can turn off the RS-232C port and
save the characters it has collected to the file you specified. Thus
if your system doesn't have flow control, you can't receive more
characters at a time than Chameleon has room for in its internal
buffer. This internal buffer varies, depending on the size of your
computer, from about 300 to 32,000 bytes.
When one Chameleon is sending a file to another Chameleon, the
first one will stop sending characters when it gets a ^S and it will
restart when it receives a ^Q. Thus, two Atari computer owners who
each own Chameleon can transfer uncopyrighted files to one another
over phone lines.
1.2.1 Types of devices that can send
You can send from any device from which you can read, except for C:
(cassette) K: (keyboard), S: (TV monitor), and E: (Screen Editor)
devices, which either Chameleon uses or would interfere with
Chameleon. This essentially restricts you to sending disk files.
D1:HILOGAME.BAS Disk file
1.2.2 Types of devices that can
receive
You can receive to any device that you can write to, except for C:
(cassette) S: (TV monitor) and E: (Screen Editor) devices, which
would interfere with Chameleon. Examples are:
P: Printer
D1:DATAFILE.TXT Disk file
1.3 Sending to a Time Sharing Program
To send a file to a time sharing system, follow these steps:
1. Establish a connection with
the system, log in, and run
your favorite editor.
2. Go into text entry mode.
If the mode requires line
numbers make sure your file
has them. If a certain
sequence of characters will
stop text entry, check that
your file does not contain
those characters.
Similarly, make sure your
file has no control
characters that might abort
the editor and return you
to the top level.
3. Press the OPTION key to go
into Chameleon's menu mode.
Change the File Name menu
line to the file you want
to send. Select a File
Type of Text. Select a
File Transfer Protocol of
Send.
4. Press the START key.
Chameleon will put you into
terminal mode.
5. Press the SHIFT+OPTION keys
to start the sending.
Chameleon will open your
file and send it to the
other computer.
6. Chameleon continues to send
until one of three events
occurs:
- It comes to the end of
the file, whereupon it
prints Quitting to
terminal mode and
returns you to
terminal mode.
- You type the Q key on
the keyboard,
whereupon it prints
Quitting to terminal
mode and returns you
to terminal mode.
- A file I/O error
occurs, whereupon it
prints File I/O error
###, where ### is an
error code listed in
the appendix, and
returns you to
terminal mode.
7. Once you're back in
terminal mode, you can type
the special characters that
tell your system's text
editor you're finished
inputing characters.
That's it.
1.3.1 Notes
Older time sharing systems often assume terminals will type only a
few characters a second, and some -- such as the author's Unix system
-- will crash if characters are sent continuously at 2400 baud. If
you find that you lose characters when you send, use the Flow Control
item of the menu to slow down sending to a rate your system can
handle.
Note also that there are often more efficient ways to save
characters from the terminal than with a text editor. Characters can
be sent directly to a file (ask a systems staff member if you're
familiar with how to do this). This kind of procedure lets the system
save your characters faster (and so lose fewer of them).
When File Type is Text, Chameleon sends a carriage return after
each line, which may cause the lines to write over one another on the
display, but it's usually the correct way to enter text to a time
sharing system. Use a specifically prepared file and the File Type
Binary mode if your text editor requires something else.
1.4 Receiving from a Time Sharing
System
The steps for receiving a file are as follows:
1. Press the OPTION key to go
to Chameleon's main menu.
2. Select File Name and enter
the file name. Select the
appropriate File Type
option (probably Text), and
set File Transfer Protocol
to Receive.
3. Press the START key.
Chameleon will put you into
terminal mode.
4. Type all but the last
character (which is
typically pressing the
RETURN key) of the command
to send the file to your
terminal.
5. Press SHIFT+OPTION. The
prompt "Type char; I'll
send it, then start" will
appear. Now type the last
character in your command
(probably RETURN).
6. Receiving will begin. It
will continue until one of
two events occurs:
- You type a Q
character, whereupon
Chameleon types
QUITTING TO TTY MODE
and returns you to
terminal mode.
- A file I/O error
occurs. Chameleon
will display a File
I/O error was ###
message, where ### is
an error code listed
in the error code
appendix.
The receive file is closed when you type the Q. If you press
SHIFT+OPTION again, before changing the File Name, the same file will
be re-opened. If this is a disk file, the old contents will be lost.
1.4.1 Notes
Some operating systems use characters like tab (ASCII 9) to
compress the number of spaces in a file. There's usually a way to
tell the system not to do so; otherwise, you'll have to go through
the received file and manually convert the tabs to the appropriate
number of spaces.
When a ^S is sent to the time sharing system, it must stop sending
data within 100 characters. If it doesn't, you'll get the message
The Buffer Overflowed, and you'll lose all the characters sent from
that point to when the system finally does stop sending data.
1.5 Taking a Photograph of the Screen
Use the Snapshot option of the File Transfer Protocol mode to copy
part or all of the virtual screen to an Atari file. The steps are as
follows.
1. Press the OPTION key to go
to Chameleon's menu mode.
2. Select File Transfer
Protocol Snapshot, and set
File Name to the file name
you want to dump to. If
you want each line of text
to end in an Atari EOL,
then you should set File
Type to Text. If you want
each line to end in a CR/LF
pair, set the File Type to
Binary.
3. Press the START key to go
to terminal mode.
4. When you're ready to send a
copy of part of the virtual
screen to your specified
file, press the
SHIFT+OPTION keys.
5. Chameleon will display the
message Mark Top of Region.
Use the SELECT and
SHIFT+SELECT keys to scroll
the virtual screen up and
down until the first line
you want to copy is at the
top of the TV screen. Then
hit the SPACE BAR.
6. Chameleon will display the
message Mark Bottom of
Region. Use the SELECT and
SHIFT+SELECT to scroll the
virtual screen up and down
until the last line you
want to copy is at the
bottom of the TV screen.
Hit the SPACE BAR.
7. Chameleon displays the
message Dumping Screen for
You and saves the screen to
your specified device.
Only the characters from
the left edge of the screen
to the rightmost nonblank
character of each line will
be saved.
1.5.1 Notes
If, in the middle of marking the region to dump, you decide not to
dump that text, you can type Q to quit out of the snapshot.
Chameleon says OK then, I won't dump and returns you to terminal
mode.
If any error occurs, Chameleon displays a File I/O error was ###
message, where ### represents an error code listed in the File I/O
error code appendix and returns you to terminal mode. Otherwise, it
displays the message Quitting to terminal mode and returns you to
terminal mode.
If no errors occur, you can continue to copy portions of the
virtual screen (presumably new data has been written to it) by
pressing the SHIFT+OPTION keys again. One copy will be written to
your specified device each time you press these keys. Chameleon
ignores any characters sent to it while it's dumping the screen.
If you press SHIFT+OPTION again, before you've changed the File
Name, the contents of the disk file will be lost.
1.6 Transferring a File Between Two
Atari Home Computers
The steps for transferring information from one Atari Home Computer
to another are as follows:
1. Establish a telephone
connection between the two
computers. One agrees to
be the sender, the other
the receiver. Each user
turns on their modem and
loads Chameleon into RAM.
2. The receiver sets up her
system to:
- File Transfer Protocol
Receive
- File Name <whatever>
- File Type Binary
3. The sender sets up his
system to:
- File Transfer Protocol
Send
- File Name <whatever>
- File Type Binary
4. The receiver presses the
SHIFT+OPTION keys and types
an asterisk (*).
5. When the sender sees the
asterisk, he presses the
SHIFT+OPTION keys.
6. Transfer of the file should
then begin.
7. When it finishes, both
parties hang up their
phones.
1.6.1 Notes
Both parties should exercise good judgment in transferring only
files whose copyright allows for such transfer.
The flow control File Transfer Protocol used by Chameleon is
extremely general, but also extremely trusting. If you have poor
quality communication lines, some characters will probably be lost or
changed during transmission. For a text file, these occurrences are
of little consequence. For a binary file, however, it's very
important that all characters transmit exactly as is. For these
files, make sure to set INPUT PARITY and OUTPUT PARITY to NONE.
For serious use of File Transfer Protocol over low-grade lines, you
really want a checksummed file transfer protocol, like the Modem and
Kermit protocols described in the next chapters.
2. Modem File Transfer Protocol
Modem is a public domain protocol for transferring files between
many kinds of computers. It was designed by Ward Christensen for use
with CP/M might become the standard file transfer protocol for
personal computers because:
- It defines a standard format
for text files.
- It detects and corrects
errors in transmission.
- It can transfer all eight
bits of a binary file.
Chameleon uses Modem protocol when the File Transfer Protocol item
reads Modem Send or Modem Receive. Modem Send transfers files from
the Atari to the remote computer, and Modem Receive transfers files
from the remote computer to the Atari.
2.1 What Kinds of Files can be
Transfered Using Modem
The Modem protocol is designed around the CP/M file format, which
is much simpler than the Atari DOS-II file format. On a CP/M system,
text and binary files are stored in exactly the same way, and all
files are a multiple of 128 characters long. Text files end at the
first ^Z in the file, while binary files start loading at 100 hex and
end on a 128 byte boundary.
The Atari DOS-II file format, on the other hand, stores files as
any number of bytes, with special "magic number" bytes at the start
of the file. The Atari DOS-II file system is "smarter" than the CP/M
file system. While this is a good thing for Atari users, it does
mean that some Atari files have no CP/M counterpart.
Chameleon tries its best to convert Atari file to and from CP/M
files, but there are some restrictions.
Chameleon's Modem can:
- send text files
- receive text files
- send Atari DOS-II binary
files
- receive Atari DOS-II binary
files
Chameleon's version of the Modem protocol can't
- send a text file with a
control-z in it (this is a
CP/M problem)
- receive a CP/M binary file
(this is also a CP/M
problem)
Since CP/M binary files contain machine language for the 8080/Z80,
which the 6502-based Atari can't execute anyway, these restrictions
are not very important.
2.2 Modem screen messages
The Modem protocol divides the file being transferred into small
parts, called "blocks." Each block is sent with a number (from 0 to
255, starting with 1 and wrapping from 255 to 0) and some other
characters that help the receiver detect any errors that might have
occurred in transmission. If there are no errors, an ACK (short for
acknowledge) code is sent to the sender. If there are errors, then
an NAK (short for negative-acknowledge) is sent, and the sender will
re-transmit the block again. More details of the protocol can be
found in the Modem appendix.
Anyway, while a Modem file transfer is in progress, Chameleon
displays a status message telling you how the transfer is
progressing. It's general format is:
For Modem Send:
If block ### was sent without error:
Got ACK for Block ###
If block ### was sent incorrectly:
Got NAK for Block* ###
For Modem Receive:
If block ### was received without
error:
Sent ACK 4 Block ###
If block ### was received
incorrectly:
Sent NAK 4 Block* ###
2.3 Modem Send
To send a file to another computer using the Modem protocol, follow
these steps:
1. Establish a connection with
the system, log in, and run
that system's remote-Modem
program. specify that the
remote system is going to
receive the file.
2. Press the OPTION key to go
into Chameleon's menu mode.
Set the File Name item to
the file you want to send.
Change File Type to the
type of file you want to
send. Select a File
Transfer Protocol of Modem
Send.
3. Press the START key to go
to terminal mode.
4. Press the SHIFT+OPTION keys
to start the Modem sending.
5. Chameleon continues to send
until one of these events
occurs:
- It comes to the end of
the file, whereupon it
prints Quitting to
Terminal mode and
returns you to
terminal mode.
- You type a 'Q'
character on the
keyboard, whereupon it
prints Quitting to
Terminal Mode and
returns you to
terminal mode.
- A file I/O error
occurs, whereupon it
prints File I/O error
###. ### is an error
code which is
explained in the error
code appendix.
- It fails to transmit a
block more than ten
times, whereupon it
prints Aborting: too
many NAKs and returns
you to the terminal
mode.
6. The other computer's Modem
program knows when the file
transmission is over, so it
will automatically save the
file and exit.
2.4 Modem Receiving
The steps for receiving a file with the Modem protocol are as
follows:
1. Run the remote system's
remote-Modem program,
asking it to send the file
you want.
2. Press the OPTION key to go
to Chameleon's menu mode.
3. Select File Name and enter
the file name. Select the
appropriate File Type
option (probably Text), and
set File Transfer Protocol
to Modem Receive.
4. Press the START key to go
to terminal mode.
5. Press SHIFT+OPTION to begin
transfering.
6. Receiving will begin. It
will continue until one of
these events occurs:
- You type a "Q"
character, whereupon
Chameleon types
Quitting to Terminal
Mode and returns you
to terminal mode.
- A file I/O error
occurs. Chameleon
will display a File
I/O error was ###
message, where "###"
is an error code.
- Chameleon receives ten
bad blocks in a row,
in which case it
displays Aborting: too
many NAKs and returns
you to terminal mode.
- The file transfers
successfully, in which
case Chameleon prints
Qutting to terminal
mode and returns you
to terminal mode.
7. If you press SHIFT+OPTION
again, before changing the
File Name, the data in the
file will be destroyed.
2.5 Using Modem to Transfer a File
Between Two Ataris
The steps for transferring information from one Atari Home Computer
to another using the Modem protocol are as follows:
1. Establish a telephone
connection between the two
computers. One agrees to
be the sender, the other
the receiver. Each user
turns on their modem and
loads Chameleon into RAM.
2. The receiver sets up her
system to:
- File Transfer Protocol
Modem Receive
- File Name <whatever>
- File Type Binary
3. The sender sets up his
system to:
- File Transfer Protocol
Modem Send
- File Name <whatever>
- File Type Binary
4. The receiver types an
asterisk (*) and presses
the SHIFT+OPTION keys.
5. When the sender sees the
asterisk, he presses the
SHIFT+OPTION keys.
6. Transfer of the file should
then begin.
7. When it finishes, both
parties hang up their
phones.
3. Kermit File Transfer Protocol
The Kermit file transfer protocol was designed by Columbia
University for error free file transfer between a wide variety of
personal and time-sharing computers. While not yet as available in
the micro-computer community as the Modem protocols, Kermit has two
advantages:
1. You can transfer more than
one file at a time
2. You can transfer files
between your Atari and half
duplex IBM mainframe
computers.
A complete description of the Kermit protocol can be found in the
June 1984 issue of "Byte" magazine. It's titled, "Kermit: A
File-Transfer Protocol for Universities, Part 1: Design
Considerations and Specifications", by Frank da Cruz and Bill
Catchings, Byte, vol. 9, No. 6, pp. 255-278.
3.1 What kinds of files can be
transfered using Kermit
Kermit was designed primarily for transfer of text files between
microcomputers and large time-sharing computers. Every Kermit
implementation, including this one, supports text transfer.
There are several methods of transfering binary data using the
Kermit protocol. Chameleon uses the simplest one; simply preserving
the parity bit. This means that Chameleon's Kermit will properly
transfer a binary file if (and only if) the Parity is set to None,
and all eight bits of data actually make it from one computer to the
other. This means that you will probably be able to transfer a
binary file to any other microcomputer which supports Kermit, but not
to most time-sharing systems.
3.2 Kermit screen messages
While a Kermit transfer is in progress, the status line of the
terminal screen will display messages reflecting the state of the
file transfer. Here are the important messages:
"Receiving <file name> <packet number> <retry flag> (Q-quits)" this
means that the file named <file name> is being received by your
computer. The <packet number> should cycle from 0 to 63, with about
80 characters of the file being received each time the number
changes. <Retry flag> is character that appears whenever a
transmission error occurs.
"Sending <file name> <packet number> <retry flag> (Q-quits)" this
means that the file named <file name> is being sent by your computer.
The <packet number> should cycle from 0 to 63, with about 80
characters of the file being sent each time the number changes.
<Retry flag> is character that appears whenever a transmission error
occurs.
"Aborting; unexpected '#' packet" this means that either Chameleon
or the other computer is confused. Check that you've told one
computer to send, and the other computer to receive, and try again.
3.3 Kermit Sending
To send a file to another computer using the Kermit protocol,
follow these steps:
1. Establish a connection with
the system, log in, and run
that system's remote Kermit
program. Specify that the
remote system is going to
receive the file. For
example, on a DEC Vax,
running VMS, you would
type:
$ Kermit <RETURN>
Kermit-32> receive <RETURN>
2. Press the OPTION key to go
into Chameleon's menu mode.
Set the File Name item to
the file you want to send.
Note that, with Kermit, you
can send multiple files by
using the '*'. For
example, to send all the
files on the diskette in
drive 1, you would set the
File Name to:
File Name D1:*.*
Change File Type to the
type of file you want to
send. Select a File
Transfer Protocol of Kermit
Send.
3. Press the START key to go
to terminal mode.
4. Press the SHIFT+OPTION keys
to start sending the file.
5. Chameleon continues to send
until one of these events
occurs:
- It comes to the end of
the file, whereupon it
prints Quitting to
Terminal mode and
returns you to
terminal mode.
- You type a 'Q'
character on the
keyboard, whereupon it
prints Quitting to
Terminal Mode and
returns you to
terminal mode.
- A file I/O error
occurs, whereupon it
prints File I/O error
###. ### is an error
code which is
explained in the error
code appendix.
- It fails to transmit a
block more than ten
times, whereupon it
prints "Aborting:
Other host not
responding" and
returns you to the
terminal mode.
6. When you've returned to
terminal mode, repeatedly
press the RETURN key until
you see the other
computer's prompt. Then
type "Exit" and RETURN. On
a VMS system, for example,
that would look like this:
<return>
Kermit-32> exit <return>
$
If there was a file error,
the other computer's Kermit
program mays still be
trying to receive the data.
In that case, you will have
to type ten to twenty
carriage returns before you
get the other system's
prompt back.
3.4 Kermit Receiving
The steps for receiving a file with the Kermit protocol are as
follows:
1. Establish a connection with
the system, log in, and run
that system's remote Kermit
program. Type all but the
last character of the
command to send the files
you wish to receive. For
example, on a DEC Vax,
running VMS, to have all
the files in the default
directory sent to your
Atari, you would type:
$ Kermit <RETURN>
When you've returned to terminal mode, repeatedly press the
RETURN key during the computer's prompt. Then type "Exit" and
RETURN. On a VMS system, for example, that would look like this:
<return>
Kermit-32> exit <return>
$
If there was a file error, the other computer's Kermit program mays
still be trying to send the data. In that case, you will have to
type ten to twenty carriage returns before you get the other system's
prompt back.
3.5 Using Kermit to transfer files
between two Ataris
The steps for transferring information from one Atari Home Computer
to another using the Kermit protocol are as follows:
1. Establish a telephone
connection between the two
computers. One agrees to
be the sender, the other
the receiver. Each user
turns on their modem and
loads Chameleon into RAM.
2. The receiver sets up her
system to:
- File Transfer Protocol
Receive
- File Name D1:
- File Type Binary
3. The sender sets up his
system to:
- File Transfer Protocol
Send
- File Name <whatever>
- File Type Binary
4. The receiver presses the
SHIFT+OPTION keys and types
an asterisk (*).
5. When the sender sees the
asterisk, he presses the
SHIFT+OPTION keys.
6. Transfer of the file should
then begin.
7. When it finishes, both
parties hang up their
phones.
3.6 Kermit File Conversion
This section is for advanced users interested in the internal
format of the Atari Kermit file format--details of the actual Kermit
protocol may be found in the Byte article.
3.6.1 File names
Atari DOS II file names consist of a letter, followed by up to
seven letters or digets, optionally followed by a period and zero to
three more letters or digets. Happily, this exactly matches Kermit's
standard for file names. Most computer systems will accept Atari DOS
II style names, but you should check for any limitations. (Some
systems, for example, allow only five characters before the period.)
Some other computer systems allow very long file names. Chameleon
will happily pass any file name it receives on to DOS II. If the
received file name is illegal, Chameleon will report an error message
and abort the transfer, leaving you in terminal mode. You can solve
this problem by renaming the files on the other computer to conform
to the Atari DOS II standard.
3.6.2 File Type Text
On Kermit Send, Atari text files are converted into standard text
files as follows:
- All EOLs ($9b) are converted
into CR($0d)/LF($0a) pairs
- All Atari-TABs ($7f) are
converted into ASCII-TABs
($09)
- The high bit is removed from
each character.
On Modem Receive, standard text files are converted into Atari text
files as follows:
- All CRs ($0d) are converted
into EOLs ($9b)
- All LFs ($0a) are removed
from the file
- All ASCII TABs ($09) are
converted into ATASCII TABS
($127)
3.6.3 File Type Binary
No translations are made for File Type Binary. If the Parity is
set to None, and if the transmission medium and the other computer
preserve the eighth bit, then the binary data will be transmitted
without change.
3.7 Special instructions for using
Kermit with an IBM Mainframe
Large time sharing IBM computers can run a version of the Kermit
protocol under the CMS environment. Chameleon's Kermit must be told
that it is communicating with an IBM mainframe in order to properly
transfer files. To transfer files to an IBM mainframe, you must set
the main menu line Terminal Type to IBM 3031.
4. Character and Control Codes
Following are the character and control codes for each terminal
type Chameleon emulates:
Table 4-1: The Keyboard
When you have Parity set to NONE, the Atari key controls whether
the high bit is ON or OFF (most Operating Systems don't care).
Characters such as CTRL-4 or CTRL-SHIFT-<any key>, which aren't
legal in ATASCII (or ASCII) cause Chameleon to lock until you type a
legal character.
Table 4-2: Control Codes
4.1 TEST terminal
The TEST terminal type simple prints all character it receives,
including control codes. Bytes with the high bit set appear in
inverse video. Control characters appear as their ATASCII equivalents
(e.g., ASCII nulls show up as little hearts and CTRL-P as a little
club).
4.2 GLASS terminal
The GLASS TTY terminal type prints all characters except ASCII 0-31
and ASCII 127. Most control codes are ignored. The following,
however, are recognized:
^G visual bell (flash screen border)
^H back space (cursor left)
^I tab to next 8-column tab stop
^J line feed (cursor down)
^L form feed (clear screen,
home cursor)
^M carriage return
Table 4-3: Glass TTY Control Codes
When the cursor is at the end of a line and a character is typed,
the word and the cursor are "wrapped" to the next line.
4.3 IBM 3031 terminal
The IBM 3031 is a terminal type designed for communicating with IBM
mainframe computers. It is very much like a Glass TTY, but it forces
half duplex. The Kermit file transfer protocol has to know wether or
not it is communicating with an IBM mainframe. It checks the main
menu, and assumes that it is talking to an IBM mainframe if the
Terminal Type is set to IBM 3031.
4.4 ADM-3A Terminal
The ADM-3A terminal prints the same characters as the Glass TTY,
but it handles a different set of control characters. They are as
follows:
^G visual bell (flash screen border)
^H back space (cursor left)
^J line feed (cursor down)
^K cursor up
^L cursor right
^M carriage return
^Z clear screen, home cursor
^[ Y+32 X+32 move cursor to (X, Y)
^^ home cursor
Table 4-4: ADM-3A Control Codes
4.5 VT-52 Terminal
The VT-52 terminal prints the same characters as the GLASS TTY. It
reacts to control characters the same as the GLASS, except when ESC
(decimal 27) is received. Chameleon will treat the next character
received specially; if it isn't in the following table, Chameleon
ignores the character; if it is in the table, the action is as
indicated.
ESC, followed by:
A Move cursor up one line.
B Move cursor down one line.
C Move cursor right one column.
D Move cursor left one column.
H Move cursor to top left corner.
I Reverse line feed.
J Clear from cursor to end of screen.
K Clear from cursor to end of line.
Y <Y+32> <X+32> Move cursor to (X,Y).
Z Send ESC / Z to the other computer.
Table 4-5: VT-52 Escape Codes
4.6 VT-52XL Terminal
The VT-52XL is an imaginary terminal. It's just like the VT-52,
except that six more escape sequences have been defined.
ESC, folowed by:
F Enter reverse video mode.
G Exit reverse video mode.
L Insert a space at the cursor.
M Delete the character at the cursor.
N Insert a blank line at the cursor.
O Delete the line at the cursor.
Table 4-6: VT-52XL Extended Codes
If you are using a Unix time-sharing system, for example, you could
send the file UNIXTERM.CAP (provided on the Chameleon diskette) to
your unix system, then type "source chameleon" to the csh to provide
full support for Chameleon.
set noglob;
setenv TERM vt52xl ;
setenv TERMCAP 'xl|vt52xl|Chameleon:\
:so=\EF:se=\EG:\
:al=\EN:dl=\EO:im:em:ic=\EL:dm:ed:\
:dc=\EM:bs:cd=\EJ:ce=\EK:\
:cl=\EH\EJ:cm=\EY%+ %+ :co#80:li#24:\
:nd=\EC:pt:sr=\EI:up=\EA:\
:ku=\EA:kd=\EB:kr=\EC:kl=\ED:';
unset noglob;
echo Chameleon supported ;
Figure 4-1: Text of UNIXTERM.CAP
I. File I/O Error Codes
67 can't FTP from/to the C device
69 can't FTP from/to the E device
75 can't FTP from/to the K device
82 can't FTP from/to the R device
83 can't FTP from/to the S device
128..255 Standard ATARI DOS errors.
II. Modem 2 Protocol Specification
The Modem 2 protocol was designed to be used with CP/M based
personal computers. It was invented prior to 1/1982 by Ward
Christensen. At one time, he could be reached via CBBS/Chicago at
(312) 545-8086, or by voice at (312) 849-6279.
Space considerations force the ommision of the full Modem 2
Protocol Spec. Note that this version of Chameleon is fully
compatable with the AMODEM 4.x implementation of the Modem protocol.
Happy Telecommunicating!
Back to previous page
