MC6800 CW Send by Wayne Sewell WB5NYC - Byte Magazine, Vol 00-14, Oct. 1976-10

When dealing with personal computers, it is necessary for a person to be familiar with his machine from both the hardware and software point of view. It has been my observation that hardware people often tend to stay in hardware and software people in software, each learning just enough about the other side to get along. I am guilty of this myself - I never do in hardware what could feasibly be done in software. Hopefully, this situation will change as my knowledge of microcomputing increases, but for the time being I am assuming that the computer runs because of the little elves pushing electrons around in the processor and putting most of my effort into programming.

This article is for people with similar bent. There are several electronic Morse code keyers on the market, but rather than spend precious cash, why not use that little digital demon of a small computer that you paid all of that money for. You've probably been trying to find a valid use for it anyway. Think of the glory as you transmit a message in Morse code several hundred characters long at a speed of 1000 WPM. (While there is a legal speed limit for radio Teletype, to my knowledge Morse Code bandwidth is not explicitly mentioned in FCC regulations.) Then comes a real challenge: Find someone whose computer can receive at that speed. Finally, the ultimate goal: Read the response sent back to you at the same speed. [See articles by Robert Grappel and Jack Hememway, by Bruce Filgate, and by Lawrence Krakauer in this issue.]

This article describes a software Morse code generator. The program listed is for a 6800 system (specifically the one sold by Southwest Technical Products); but a complete description of the generator is included to facilitate conversion to other systems.

Data Format

The data format used in my Morse code generator makes it possible to pack any of the "dot" and "dash" combinations associated with a Morse code character into a single byte. The rightmost 5 or 6 bits (throughout this article, "rightmost" and "least significant" are synonymous) contain the pattern of dots and dashes, and the upper 2 or 3 bits contain a count which informs the program how many of the data bits are actually associated with the character. The remaining bits are set to zero arbitrarily. Out of all of the characters in international Morse code, there are only two which will not work in this system: space and the error code. It is not surprising that the space is a maverick in any data representation, since it is not really data at all, but a lack of data. It is simply a lengthening of the normal interval between characters to form an interval between words, and must be handled as a special case. Similarly, the error code is not really a character either.

Table2: Special Codes and ASCII Graphics.
To send:		Keyboard Entry
SK	End of work	'#'	ASCII hexadecimal 23
BT	Break	'&'	ASCII hexadecimal 26
AR	End of Message	'$'	ASCII hexadecimal 24
KN	Invitation to transmit specified station only	'+'	ASCII hexadecimal 2B
AS	Wait	'='	ASCII hexadecimal 3D
ERROR CODE (8 dots)		'!'	ASCII hexadecimal 21
		DEL	ASCII hexadecimal 7F

When an error is made during a Morse transmission, due to a spasmodic twitch of the operator's hand or similar cause, the errant operator sends a string of 8 dots, meaning: "Oh I'm sorry I made and error please disregard the last character I send please will you huh." Both the space and the error code, since they don't fall in the normal scheme of things, are treated as special cases: Immediately upon detection, the program intercepts them, modifies them to a compatable format, and inserts them back into the main logic Flow.

For all characters five elements long or less, the format is absurdly simple, as shown in figure 1a. The high order 3 bits contain a binary number from 1 to 5 corresponding to the number of dots and/or dashes in the character. The right most 5 bits contain the data elements themselves, where 0 is a dot and 1 is a dash. They are stored from right to left so that when the byte is shifted to the right, they are transmitted serially in the proper sequence. As an example, the Morse code character Q is transmitted as "_ _ . _". The element count is four, so a binary 100 string is stored in the leftmost 3 bits of the byte. Using the coding scheme above, the equivalent Morse bit pattern for Q (the binary string 1011) is stored in the rightmost 4 bits. In this case, bit 4 is not needed so it is a "don't care" bit which is set to zero arbitrarily. Therfore, the code for Q stored in the table is the binary string 100001011 or hexadecimal 8B.

If all Morse code characters contained five elements or less, the coding system would be much simpler. However, many of the special characters, uncooperative cusses that they are, contain six elements. At first glance, this doesn't seem to be an obstacle, since the 3 bit count field can contain a binary number up to 7, inclusive. However, there are only 5 bits left over within the byte, which means that although the count can keep track of more than five elements, there is no place to store them. The one fact that keeps the entire system from collapsing into a pile of random logic is that there are no special codes with six elements, but I have been unable to come up with on containing seven. Since the difference between a count of six, binary string 110, and a count of seven (111) is one bit; and since there will never be a count of seven, then bit 5 becomes a "don't-care" and can be used as a data bit if bits 6 and 7 are both 1. We simply consider ny count greater than five (leftmost 2 bits on) to be equal to six, shift our wild card bit right with the others, and the problem is solved, as seen in figure 1b. When the count is extracted in this case, bit 5 is forced to a zero, making the count equal to six.

When Morse transmission actually starts, the data bits are shifted right one at a time. If the rightmost bit is a zero, the weight factor for a dot is loaded; if the rightmost bit is equal to a 1, the dash weight factor is loaded, normally exactly three times that of a dot. The key is turned on, and the timing subroutine, controlled by the value stored in ELESPEED, generates the proper delay for that element. The key is then turned off and the timing subroutine is reentered, this time to generate the space between elements, normally equal to a single dot time. This loop is repeated for every element in the character, shifting right each time. The space between elements is added to the last element in the character, also.

If a string of characters is being transmitted, rather than a single character, the space between them is generated according to the value stored at location CHRSPEED. If element and character speeds are synchronized, the delay caused by CHRSPEED is exactly twice the space between elements, which has already been generated after the last element. Combining the two causes the total space between characters to be exactly the length of a dash, the established spacing between Morse code characters (see figure 2).

If a space (in ASCII, hexidecimal 20) is detected, it is treated as a phantom character consisting of one dot length with the key off. When added to the 3 dot interval following the previous character, and the equal interval following itself, a total interval of 7 dot times is generated, the standard spacing between words. (ASCII codes with no Morse code equivalents are also treated as spaces.)

Speed Control

Table1: Speed Control Values.
Morse Code Rate (WPM)	Value Loaded into ELESPEED (hexadecimal)	Value Loaded into CHARSPEED (hexadecimal)
5	00D6	01AC
10	006B	00D6
15	0047	008E
20	0035	006A
25	002b	0056
30	0024	004B
35	001F	003E
40	001B	0036
50	0015	002A
60	0012	0024
70	000F	001E
80	000D	001A
90	000C	0018
100	000B	0016
200	0005	000A
500	0002	0004
1000	0001	0002

There are two separate controls for Morse code spacing: element speed and character speed. The element speed is the time duration of the smallest element of the Morse pattern. The time duration of dashes, dots, and the breaks in between are based upon it. If normal weighting is used, a dot is equal to one of these intervals, a dash is equal to three of them, and the space between dots and dashes within a character is equal to a single dot interval. The 2 byte field labelled ELESPEED contains a 16 bit binary number specifying the element delay as an integer number of milliseconds. With normal weighting, the duration of a dot will be exactly the number of milliseconds contained in ELESPEED, and the duration of a dash will be exactly three times that.

If you wish the element and character speeds synchronized (20 WPM character sent at 20 WPM intervals, etc), the binary value stored in CHRSPEED should be exactly double the binary value stored in ELESPEED. In this configuration the program will generate perfectly synchronized Morse code according to the extablished standard (dash duration three time of dot, durstion of space between elements equal to one dot, duration of space between characters equal to that of one dash, and duration of space between words seven times that of one dot). When you change speeds, change the values of ELESPEED and CHRSPEED (once again, the value of the latter should be twice the value of the former.)

If you wish to lengthen the interval between characters, without changing their internal speed, simply increase the value of CHRSPEED. For instance, if you with to practice copying code, you can set the ELESPEED field at the value for 20 WPM and the CHRSPEED field to the 5 WPM value. This will cause 20 WPM characters to be sent at 5 WPM intervals. You can tweak either speed to any 16 bit value you want (except zero), but the value of CHRSPEED must never be equal to less than two times that of ELESPEED or the spacing will be demolished!

And It Comes Out Here

The Morse code generator program is designed to output Morse signals through a parallel IO port. Two different types of output are available simultaneously: logical and oscillating. The logical output corresponds to the Morse signal as it is broadcast - the output is high during a dot or dash andlow in the times between. This corresponds to the telegraph key itself and may be fed to the transmitter directly or via a relay or other driver. The oscillating output changes state every millisecond while the logical output is high andis held low during the times the logical output is low. This output, when connected to a speaker, produces a 500 Hz tone and can be used as a sidetone or a code practice oscillator. Both types of output can be produced simultaneously, as seen in figure 3.

Which of the lines in your parallel port are to be used at logical outputs and which are oscillators is determined by the control byte labeled INITMASK. For every bit in INITMASK which is equal to zero, the corresponding bit in the parallel port is a logical output. Every bit in INITMASK which is in an on state causes the corresponding line in the output port to oscillate.

I am not a hardware type person; therefore, I am not going to attempt describing the interface necessary to take the Morse code output of the nonoscillating line and transfer it to your ham rig, especially since every transmitter has its own keying system. In a classic copout I say, "It is up to the user to take the logical output of the PIA (0 = key off, +5 V = key on) and get it onto the air without blasting the PIA output driver".

Viva Southwest Tech

This Morse data generator was written for a Southwest Technical Products 6800 system, which uses the Motorola MC6830L7 ROM (MIKBUG Revision 9). A complete cross assembly of CWBUFFER is printed in listing 1. The program was written to be configuration independent, however, and will work for any 6800 system having programmable memory at locations hexadecimal 00 to 49, at least 190 bytes of programmable memory elsewhere, and one PIA. The ASCII to Morse conversion subroutine is completely relocatable and reentrant, althouth the main generator routines (CWBUFFER and TRANSMIT) are not.

All of the timing loops are calibrated for the Southwest Technical Produdcts System, which has a 1.797 MHz master oscillator crystal. If your clock runs at a different speed, you may want to tweak the loop constant so that the output of one of the oscillating lines is exactly 500 Hz (each outer loop of the MILDELAY subroutine is supposed to last exactly one millisecond). The loop constant is at hexadecimal location 160; incrementing or decrementing it by one will increase or decrease the interval which should correspond to a millisecond by six machine cycles. If you aren't concerned with perfect timing, you can compensate by loading different values into ELESPEED and CHRSPEED.

The parallel port address used in the program corresponds to the serial control interface used by MIKBUG,which is really a parallel interface that only simulates a serial interface via software. Connect a small 8 ohm speaker between connections RO and GND on the serial control interface. (Your computer will probably be unable to talk to the TVT or Teletype while the speaker is attached, due to loading problems.) In the program turn on the rightmost bit in INITMASK to produce the oscillating output.

There is only one output line normally available from the PIA on the Southwest Technical Products serial control interface, although it separates into two output systems, RS-232 and 20 mA current loop. Another line on the PIA's A side is used for MIKBUG input, which leaves six lines conpletely unused. These lines can be used for Morse output if you bring them out via jumpers from the backside of the PIA. Of course, MIKBUG has designated them as inputs in the A side data direction register; but if you OR a hexadecimal 7E into the DDR, you will reset them as outputs and leave the normal MIKBUG lines alone. You can use any combination of those lines for Morse output.

Sundry Drivers

The Morse Code Generator Program (< Link to original artile PDF) is designed to be used as a subroutine. It simply takes a character or string of characters in memory and outputs the Morse code equivalents. It is completely up to the user as to how this data is input, whether through the keyboard, read from tape, generated by a random number genertor, or conjured up by evil spirits. All that is required is that the Morse code routine's controlls (ELESPEED, CHRSPEED, and INITMASK) be set before the subroutine is entered, and, if the CWBUFFER entry point is used, that the index register contains the address of the first byte of the string and stop byte, hexadecimal 03, follows immediately after the last byte of the string.

I have included three simple drivers which could be used for the 6800: one that generates one Morse character at a time from the keyboard; a second that buffers characters until a delimiter character (line feed) is encountered, after which it sends out the characters it has stored in one brilliant blast of precision keying; and a third driver which fills up a buffer with random characters, then sends them out (for code practice). These drivers are shown as in the original article link.

The single character driver (SINGLECH) lies dormant until a character is entered from the keyboard. When the character is received, it is passed immediately to TRANSMIT and the Morse code is sent out the PIA. The driver then goes back to sleep until a new character comes in.

The buffered driver loads incomming characters into a buffer in memory until either a line feed or ETX (Control C, hexadecimal 03) character is encountered. When either is received the starting address is loaded into the index register, a delimiter (ETX) is stored in the buffer after the last data byte; and the buffer is passed to CWBUFFER, which outputs the CW codes in a continuous stream until the end of the buffer is reached. Control that returns to the driver, which starts loading the buffer all over again. When a backspace command (Control H, hexadecimal 08) is received, the character immediately preceeding the command is deleted from the buffer.

CODEPRAC, the code practice program, fills a buffer in memory with random characters, then passes them to CWBUFFER, which sends them out the PIA into your speaker (hopefully you have set INITMASK so that the line is an oscillating output). The speed and spacing are controlled by whatever you have loaded into ELESPEED and CHRSPEED.

The code practice application is where the dual speed controls really come into play. When a person is first learning code, he obviously has to start at an extremely low character rate. At this speed, the dots and dashes are extremely dragged out and sound completely different than they do at higher speeds. The Morse code neophyte should really learn to recognize the characters by listening to the total pattern, not by counting dots and dashes. However, speeding up the characters also speeds up the character rate if normal element to space ratios are maintained and an entire message has gone by while the beginner is still trying to recognize the first character. Therefore, the ideal situation is to retain the sound of the high speed characters and yet increase the interval between them. This is accomplished by leaving the element speed (ELESPEED) the same and increasing the duration of time between characters (CHRSPEED) to whatever length is desired.

Anyway, to get back to the code practice driver, it will continue to send characters at the CHRSPEED rate until the end of the buffer is reached, at which the end of the buffer is reached, at which time it will generate another set of practice characters. Unfortunately, the random number generation routine itself is missing. The code practice driver was a last minute addition, and there was not time to develope one. (The program was tested using a kluge substitution.) However, there are different versions floating around. The one you use should generate a one byte random number and return it in accumulator A. It should not destroy accumulator B or the index register. Load the address of the routine in the dummy jump to subroutine at hexadecimal location 01D5. The address at location 01E7 is the end of buffer address or your maximum memory location. Don't forget to leave a place for the random number generator subroutine.

The drivers in this article are very primitive, and are designed simply to get you running. If your system is a Southwest Tech one, you should be able to load all of the programs and the table into your system exactly as coded (CODEPRAC too, with the addition of a random number routine), connect a speaker between RO and ground on the control interface, load ELESPEED and CHRSPEED according to table 1, turn on the right most bit of INITMASK, branch to the starting address of the driver of your choice, and start typing. As you hear the speaker sing a 500 Hz area with perfect 1 to 3 to 7 spacing, you may reflect that maybe programmers aren't such bad guys after all. Seriously, the sidetone output is a perfect way to ensure that the program is working with each of the various drivers before you tie it into your rig.

Other 6800 Systems

For non Southwest Tech 6800 systems, the installation of the Morse generator program is not much more difficult. The address of the PIA used for the Morse code output and that of the input routine are the primary concerns. If your system uses MIKBUG, which has the single character input routine at hexadecimal location E1AC and the serial control interface at 8004, so much the better - you shouldn't have to modify a single byte. If your configuration is different, substitute your own PIA address at hexadecimal locations 015D, 0195, 01C0, and 01CE, and your ASCII input routine address at location 01C3 and 019B.

The programs in this article were not assembled on Motorola's assembler. They were run on SPUCLA (Sewell's Psychedelic Universal Cross Assembler), a homemade cross assembler which runs on the IBM 379 and generates code for the 6800 and four other microprocessors. Listing 1 and 2, and the tables 3 and 4 were generated by SPUCA.

The formats are almost identical. but there are some minor differences that should be pointed out for the sake of clarity. The major difference is in instructions using the indexed mode of addressing. Motorola places the symbol for the index register (X) after the operand with a comma in between, where SPUCA looks for an I before the operand, again with a comma in between. In other words, a Motorola indexed instruction looks like this: LDA A OPERAND,X and one read in by SPUCA is in this format: LDAA I,OPERAND.

Most of the rest of the instructions are identical to Motorola's except that my assembler has no FCC (Form Constant Characters) directive and no separate column for the accumulator ID.

End of Byte Magazine Article

Differences and Adjustments - K7MEM

Differences - You might notice that there are some differences between the original listing (above) and the listing from my assembler (below).

LINE ADDR OP OPER SYMBOL OPC OPERAND COMMENT ----- ---- -- ---- -------- ---- ---------------- ------------------------- 00001 ; ASCII TO MORSE CONVERSION TABLE. 00002 ; 00003 ; THIS TABLE LISTS THE RELATIVE OFFSET, DATA, ASSEMBLY LANGUAGE 00004 ; TEXT, ASCII EQUIVALENT GRAPHICS AND ASCII HEXADECIMAL CODES 00005 ; ($XX FOR CODE XX) FOR EACH CHARACTER RECOGNIZED AND GENERATED 00006 ; BY CWBUFF. 00007 ; 00008 ; TO FIND THE MORSE ENCODED VALUE OF EACH ASCII GRAPHIC, 00009 ; SUBTRACT HEXADECIMAL 20 FROM ITS ASCII HEXADECIMAL VALUE, 00010 ; ADD THE DIFFERENCE TO THE FIRST ADDRESS LOCATION OF 00011 ; ASCWTABL ( 0 IN THIS ASSEMBLY) AND USE THE 16 BIT RESULT 00012 ; AS THE ADDRESS OF THE DESIRED MORSE EQUIVALENT. 00013 ; 00014 0000 ASCWTABL EQU * 00015 0000 00 FCB %00000000 ; SPACE ......(ASCII $20) 00016 0001 FF FCB %11111111 ; ! ERROR ....(ASCII $21) 00017 0002 D2 FCB %11010010 ; " ..........(ASCII $22) 00018 0003 E8 FCB %11101000 ; # (SK) .....(ASCII $23) 00019 0004 AA FCB %10101010 ; $ (AR) .....(ASCII $24) 00020 0005 00 FCB %00000000 ; NULL .......(ASCII $25) 00021 0006 B1 FCB %10110001 ; & (BT) .....(ASCII $26) 00022 0007 DE FCB %11011110 ; ' ..........(ASCII $27) 00023 0008 ED FCB %11101101 ; ( ..........(ASCII $28) 00024 0009 ED FCB %11101101 ; ) ..........(ASCII $29) 00025 000A 00 FCB %00000000 ; NULL .......(ASCII $2A) 00026 000B AD FCB %10101101 ; + (KN) .....(ASCII $2B) 00027 000C F3 FCB %11110011 ; , ..........(ASCII $2C) 00028 000D E1 FCB %11100001 ; - ..........(ASCII $2D) 00029 000E EA FCB %11101010 ; . ..........(ASCII $2E) 00030 000F A9 FCB %10101001 ; / ..........(ASCII $2F) 00031 0010 BF FCB %10111111 ; 0 ..........(ASCII $30) 00032 0011 BE FCB %10111110 ; 1 ..........(ASCII $31) 00033 0012 BC FCB %10111100 ; 2 ..........(ASCII $32) 00034 0013 B8 FCB %10111000 ; 3 ..........(ASCII $33) 00035 0014 B0 FCB %10110000 ; 4 ..........(ASCII $34) 00036 0015 A0 FCB %10100000 ; 5 ..........(ASCII $35) 00037 0016 A1 FCB %10100001 ; 6 ..........(ASCII $36) 00038 0017 A3 FCB %10100011 ; 7 ..........(ASCII $37) 00039 0018 A7 FCB %10100111 ; 8 ..........(ASCII $38) 00040 0019 AF FCB %10101111 ; 9 ..........(ASCII $39) 00041 001A C7 FCB %11000111 ; : ..........(ASCII $3A) 00042 001B D5 FCB %11010101 ; ; ..........(ASCII $3B) 00043 001C 00 FCB %00000000 ; NULL .......(ASCII $3C) 00044 001D A2 FCB %10100010 ; = (AS) .....(ASCII $3D) 00045 001E 00 FCB %00000000 ; NULL .......(ASCII $3E) 00046 001F CC FCB %11001100 ; ? ..........(ASCII $3F) 00047 0020 00 FCB %00000000 ; NULL .......(ASCII $40) 00048 0021 42 FCB %01000010 ; A ..........(ASCII $41 OR $61) 00049 0022 81 FCB %10000001 ; B ..........(ASCII $42 OR $62) 00050 0023 85 FCB %10000101 ; C ..........(ASCII $43 OR $63) 00051 0024 61 FCB %01100001 ; D ..........(ASCII $44 OR $64) 00052 0025 20 FCB %00100000 ; E ..........(ASCII $45 OR $65) 00053 0026 84 FCB %10000100 ; F ..........(ASCII $46 OR $66) 00054 0027 63 FCB %01100011 ; G ..........(ASCII $47 OR $67) 00055 0028 80 FCB %10000000 ; H ..........(ASCII $48 OR $68) 00056 0029 40 FCB %01000000 ; I ..........(ASCII $49 OR $69) 00057 002A 8E FCB %10001110 ; J ..........(ASCII $4A OR $6A) 00058 002B 65 FCB %01100101 ; K ..........(ASCII $4B OR $6B) 00059 002C 82 FCB %10000010 ; L ..........(ASCII $4C OR $6C) 00060 002D 43 FCB %01000011 ; M ..........(ASCII $4D OR $6D) 00061 002E 41 FCB %01000001 ; N ..........(ASCII $4E OR $6E) 00062 002F 67 FCB %01100111 ; O ..........(ASCII $4F OR $6F) 00063 0030 86 FCB %10000110 ; P ..........(ASCII $50 OR $70) 00064 0031 8B FCB %10001011 ; Q ..........(ASCII $51 OR $71) 00065 0032 62 FCB %01100010 ; R ..........(ASCII $52 OR $72) 00066 0033 60 FCB %01100000 ; S ..........(ASCII $53 OR $73) 00067 0034 21 FCB %00100001 ; T ..........(ASCII $54 OR $74) 00068 0035 64 FCB %01100100 ; U ..........(ASCII $55 OR $75) 00069 0036 88 FCB %10001000 ; V ..........(ASCII $56 OR $76) 00070 0037 66 FCB %01100110 ; W ..........(ASCII $57 OR $77) 00071 0038 89 FCB %10001001 ; X ..........(ASCII $58 OR $78) 00072 0039 8D FCB %10001101 ; Y ..........(ASCII $59 OR $79) 00073 003A 83 FCB %10000011 ; Z ..........(ASCII $5A OR $7A) 00074 003B ED FCB %11101101 ; ( ..........(ASCII $5B OR $7B) 00075 003C 00 FCB %00000000 ; NULL .......(ASCII $5C OR $7C) 00076 003D ED FCB %11101101 ; ) ..........(ASCII $5D OR $7D) 00077 003E 00 FCB %00000000 ; NULL .......(ASCII $5E OR $7E) 00078 003F FF FCB %11111111 ; DEL (ERROR) (ASCII $5F OR $7F) 00079 0040 LASTASCW EQU *-ASCWTABL 00080 ; 00081 ; CWBUFFER SUBROUTINE. THIS LISTING GIVES THE COMPLETE ABSOLUTE 00082 ; HEXADECIMAL ASSEMBLED CODE AND SYMBOLIC REPRESENTATION FOR THE 00083 ; CWBUFFER ROUTINE. 00084 ; 00085 0040 0002 CHRSPEED RMB 2 ; # OF MILLISECONDS BETWEEN CHARACTERS 00086 0042 0002 ELESPEED RMB 2 ; LENGTH OF ELEMENT (DIT) DURATION IN MILLISECONDS 00087 0044 0001 INITMASK RMB 1 ; OSCILLATOR CONTROL BYTE 00088 0045 0001 HOLDBYTE RMB 1 00089 0046 0001 MASK RMB 1 00090 0047 0001 COUNT RMB 1 00091 0048 0002 CWPTR RMB 2 ; POINTS TO 1ST BYTE IN STRING 00092 0100 ORG $0100 00093 0100 CWBUFFER EQU * 00094 0100 A6 00 LDAA 0,X ; GET CHAR 00095 0102 81 03 CMPA #3 ; IS THIS THE STOP BYTE? 00096 0104 26 01 BNE CONTINUE ; BR IF NO 00097 0106 39 RTS ; RETURN 00098 0107 CONTINUE EQU * 00099 0107 08 INX ; STORE POINTER 00100 0108 DF 48 STX CWPTR ; STORE POINTER 00101 010A 8D 08 BSR TRANSMIT ; CONVERT THE CHAR TO CW AND TRANSMIT 00102 010C DE 40 LDX CHRSPEED ; LOAD DELAY CONSTANT FOR CHAR SPACING 00103 010E 8D 46 BSR MILDELAY ; DELAY PROPER # OF MILLISECONDS 00104 0110 DE 48 LDX CWPTR ; GET ADDRESS OF CHAR STRING 00105 0112 20 EC BRA CWBUFFER ; GET NEXT CHAR 00106 0114 TRANSMIT EQU * 00107 0114 8D 5C BSR CHARTOCW ; CONVERT CHAR TO CW TRANSMIT CODE 00108 0116 4D TSTA ; A = 0? 00109 0117 26 06 BNE NOTSPACE ; BR IF NO (VALID NON-BLANK CW CHAR) 00110 0119 C6 01 LDAB #1 ; SET NUMBER OF ELEMENTS AT 1, AND MAKE 00111 011B D7 47 STAB COUNT ; THE WEIGHT SAME AS A DIT 00112 011D 20 25 BRA SPACENT ; BYPASS KEY-ONINSTRUCTION 00113 011F NOTSPACE EQU * 00114 011F 16 TAB ; SAVE A IN B 00115 ; RPT 4 00116 0120 59 ROLB ; ROTATE BIT COUNT 00117 0121 59 ROLB ; ROTATE BIT COUNT 00118 0122 59 ROLB ; ROTATE BIT COUNT 00119 0123 59 ROLB ; ROTATE BIT COUNT 00120 0124 C4 07 ANDB #7 ; SET COUNT AT < OR = ? 00121 0126 91 FF CMPA $FF ; IS THIS SPECIAL ERROR CODE ? 00122 0128 26 04 BNE NOTERR ; BRANCH IF NO 00123 012A 4F CLRA ; SET DATA TO ALL DITS 00124 012B 5C INCB ; INCRE COUNT FROM 7 TO 8 00125 012C 20 06 BRA COUNTOK ; STORE COUNT 00126 012E NOTERR EQU * 00127 012E C1 06 CMPB #6 ; BIT COUNT - 6 ? 00128 0130 2D 02 BLT COUNTOK ; BR IF NO 00129 0132 C4 06 ANDB #6 ; SET COUNT AT 6 00130 0134 COUNTOK EQU * 00131 0134 D7 47 STAB COUNT ; STORE BIT COUNT 00132 0136 BITLOOP EQU * 00133 0136 D6 44 LDAB INITMASK ; INITIALIZXE THE OSCILLATOR MASK 00134 0138 D7 46 STAB MASK 00135 013A C6 01 LDAB #1 ; LOAD WEIGHT FACTOR FOR DIT 00136 013C 46 RORA ; ROTATE DATA BIT INTO CARRY 00137 013D 24 02 BCC SEND ; BR IF CARRY CLEAR (DIT) 00138 013F C6 03 LDAB #3 ; LOAD WEIGHT FACTOR FOR DAH 00139 0141 SEND EQU * 00140 0141 73 0045 COM HOLDBYTE ; TURN ON KEY 00141 0144 SPACENT EQU * 00142 0144 8D 22 BSR ELDELAY ; GENERATE DELAY FOR ELEMENT LENGTH 00143 0146 7F 0046 CLR MASK ; CLEAR OSCILLATOR MASK 00144 0149 7F 0045 CLR HOLDBYTE ; TURN OFF KEY 00145 014C C6 01 LDAB #1 ; LOAD WEIGHT FACTOR FOR BREAK BETWEEN ELEMENTS 00146 014E 8D 18 BSR ELDELAY ; GENERATE DELAY FOR ELEMENT LENGTH. 00147 0150 7A 0047 DEC COUNT ; LAST ELEMENT IN CHAR ? 00148 0153 26 E1 BNE BITLOOP ; BR IF NO 00149 0155 39 RTS ; RETURN 00150 0156 MILDELAY EQU * 00151 0156 D6 46 LDAB MASK ; HOLD THE KEY OUTPUT CONSTANT AND FLIP-FLOP 00152 0158 D8 45 EORB HOLDBYTE ; THE OSCILLATOR OUTPUT IF KEY IS ON 00153 015A D7 45 STAB HOLDBYTE ; 00154 015C F7 8004 STAB $8004 00155 015F C6 8F LDAB #$8F ; LOAD MILLISECOND LOOP CONSTANT 00156 0161 LOOP2 EQU * 00157 0161 5A DECB ; COUNT DOWN 00158 0162 26 FD BNE LOOP2 ; BR IF NOT FINISHED 00159 0164 09 DEX ; DECREMENT MILLISECOND COUNT 00160 0165 26 EF BNE MILDELAY ; BR IF NOT FINISHED 00161 0167 39 RTS ; RETURN 00162 0168 ELDELAY EQU * 00163 0168 DE 42 LDX ELESPEED ; LOAD DELAY CONST FOR ELEMENT SPACING 00164 016A 37 PSHB ; SAVE # OF INTERVALS 00165 016B 8D E9 BSR MILDELAY ; DELAY PROPER # OF MILLISECONDS 00166 016D 33 PULB ; RESTORE # OF INTERVALS 00167 016E 5A DECB ; DECREMENT # OF INTERVALS 00168 016F 26 F7 BNE ELDELAY ; BR IF NOT FINISHED 00169 0171 39 RTS 00170 0172 CHARTOCW EQU * 00171 0172 84 7F ANDA #$7F ; STRIP PARITY BIT 00172 0174 80 20 SUBA #32 ; SUBTRACT OFFSET 00173 0176 2D 17 BLT INVALAS ; IF INVALID CHAR OR =0 BRANCH OUT 00174 0178 81 40 CMPA #LASTASCW ; CHARACTER IN TABLE ? 00175 017A 2C 0D BGE NOTFNDAS ; BRANCH IF NO 00176 017C GETENTRY EQU * 00177 017C 5F CLRB ; ALLOCATE AND ZERO OUT A TEMPORARY 00178 017D 37 PSHB ; 2-BYTE AREA ON TOP OF THE STACK 00179 017E 37 PSHB 00180 017F 30 TSX ; POINT INDEX REGISTER TO IT - Fix - K7MEM 00181 0180 A7 01 STAA 1,X ; STORE TABLE OFFSET INTO SECOND BYTE - Fix - K7MEM 00182 0182 EE 00 LDX 0,X ; LOAD CONSTRUCTED POINTER INTO INDEX - Fix - K7MEM 00183 0184 A6 00 LDAA 0,X ; LOAD CW CODE 00184 0186 31 INS ; DELETE TEMPORARY HOLD AREA & REALIGN STACK 00185 0187 31 INS 00186 0188 39 RTS ; RETURN 00187 0189 NOTFNDAS EQU * 00188 0189 80 20 SUBA #32 ; POINT TO LOWER CASE CHARS. 00189 018B 81 20 CMPA #$20 ; BETWEEN UPPER & LOWER CASE ? 00190 018D 2E ED BGT GETENTRY ; BR IF NO (USE LOWER CASE AS UPPER) 00191 018F INVALAS EQU * 00192 018F 4F CLRA ; SET A TO CW NULL 00193 0190 39 RTS ; RETURN 00194 ; 00195 ; THREE DIFFERENT DRIVER ROUTINES OCCUPY THE REMAINDER OF ASSEMBLED CODE 00196 ; PREPARED BY THE AUTHOR. THESE DRIVERS ARE ASDRIVER, SINGLECH, AND CODE PARC. 00197 ; 00198 ; ASDRIVER IS USED TO LOAD A BUFFER, THEN CALL CWBUFFER TO TRANSMIT THE DATA 00199 ; AS MORSE SIGNALS. 00200 ; 00201 ; SINGLECH IS A SIMPLE ROUTINE TO READ A CHARACTER FROM THE KEYBOARD THEN 00202 ; CALL TRANSMIT SUBROUTINE (BYPASSING CWBUFFER) TO OUTPUT THAT CHARACTER AS 00203 ; ITS MORSE EQUIVALENT. 00204 ; 00205 ; CODEPRAC IS A ROUTING USED TO GENERATE A RANDOM SERIES OF MORSE DATA 00206 ; FOR CODE PRACTICE. 00207 ; 00208 ; (NOTE THAT THE INSTRUCTION AT 01D5 SHOULD BE PATCHED TO REFERENCE A 00209 ; RANDOWN NUMBER ROUTINE SPECIFIC TO YOUR OWN COMPUTER SYSTEM). 00210 ; 00211 0191 ASDRIVER EQU * 00212 0191 7F 0045 CLR HOLDBYTE ; CLEAR OUTPUT PORT 00213 0194 7F 8004 CLR $8004 00214 0197 CE 01F7 LDX #BUFFER ; LOAD BUFFER ADDRESS 00215 019A LOADLOOP EQU * 00216 019A BD E1AC JSR $E1AC ; USING MIKBUG THIS SUBROUTINE IS LOCATED AT HEX "E1AC" 00217 019D A7 00 STAA 0,X ; STORE INTO BUFFER - Fix - K7MEM 00218 019F 08 INX ; INCREMENT POINTER 00219 01A0 81 03 CMPA #3 ; IS THIS A CONTROL C (STOP BYTE) ? 00220 01A2 27 10 BEQ NONEED3 ; BR IF YES 00221 01A4 81 0A CMPA #$0A ; IS THIS AN ASCII LINE FEED ? 00222 01A6 27 08 BEQ SENDIT ; BR IF YES 00223 01A8 81 08 CMPA #$08 ; IS THIS AN ASCII BACKSPACE COMMAND ? 00224 01AA 26 EE BNE LOADLOOP ; CONTINUE 00225 01AC 09 DEX ; BACKSPACE POINTER 2 BYTES, 1 FOR DATA BYTE 00226 01AD 09 DEX ; AND 1 BACKSPACE CHAR 00227 01AE 20 EA BRA LOADLOOP ; CONTINUE 00228 01B0 SENDIT EQU * 00229 01B0 86 03 LDAA #3 ; LOAD AND STORE DELIMITER (STOP BYTE) INTO BUFF 00230 01B2 A7 00 STAA 0,X ; Fix - K7MEM 00231 01B4 NONEED3 EQU * 00232 01B4 CE 01F7 LDX #BUFFER ; RELOAD BUFFER ADDRESS INTO INDEX 00233 01B7 BD 0100 JSR CWBUFFER ; CALL CW GENERATOR ROUTINE 00234 01BA 20 D5 BRA ASDRIVER ; START CYCLE ALL OVER AGAIN 00235 ; 00236 ; Missing lines ??? 00237 ; 00238 01BC SINGLECH ORG $01BC ; SINGLE CHARACTER INPUT FROM KEYBOARD 00239 ; 00240 01C2 SINGLOOP ORG $01C2 00241 ; 00242 01CA ORG $01CA 00243 01CA CODEPRAC EQU * 00244 01CA 7F 0045 CLR HOLDBYTE ; CLEAR OUTPUT PORT 00245 01CD 7F 8004 CLR $8004 00246 01D0 CE 01F7 LDX #BUFFER ; STORE ADDRESS OF BUFFER INTO START-OF-BUFFER POINTER 00247 01D3 DF 48 STX CWPTR 00248 01D5 GENLOOP EQU * 00249 01D5 BD 0000 JSR *-* ; CALL A ROUTINE TO GENERATE A 1-BYTE RANDOM NUMBER 00250 01D8 36 PSHA ; SAVE ORIGINAL ASCII CHARACTER 00251 01D9 BD 0172 JSR CHARTOCW ; TEST FOR VALID CW CHARACTER 00252 01DC 32 PULA ; SAVE ORIGINAL ASCII CHARACTER 00253 01DD 27 F6 BEQ GENLOOP ; BR IF NOT VALID 00254 01DF DE 48 LDX CWPTR ; LOAD BUFFER POINTER 00255 01E1 A7 00 STAA 0,X ; STORE CHARACTER INTO BUFFER - Fix - K7MEM 00256 01E3 08 INX ; INCREMENT POINTER 00257 01E4 DF 48 STX CWPTR ; SAVE NEW BUFFER POINTER 00258 01E6 8C 7FFF CPX #BUFFEND ; END OF BUFFER OR END OF MEMORY ? 00259 01E9 26 EA BNE GENLOOP ; BR IF NO, GET ANOTHER CHARACTER 00260 01EB 86 03 LDAA #3 ; LOAD AND STORE DELIMITER (STOP BYTE) INTO BUFF 00261 01ED A7 00 STAA 0,X ; Fix - K7MEM 00262 01EF CE 01F7 LDX #BUFFER ; RELOAD BUFFER ADDRESS INTO INDEX 00263 01F2 BD 0100 JSR CWBUFFER ; GENERATE CW FOR ENTIRE BUFFER 00264 01F5 20 D3 BRA CODEPRAC ; CONTINUE 00265 01F7 BUFFER EQU * 00266 7FFF ORG $7FFF 00267 7FFF BUFFEND EQU * Total Errors: 0 --------------------------------------------------------------------------- | Symbol - Value | Symbol - Value | Symbol - Value | |------------------------+-------------------------+------------------------| | ASCWTABL - $0000 | CWPTR - $0048 | MILDELAY - $0156 | | ASDRIVER - $0191 | ELDELAY - $0168 | NONEED3 - $01B4 | | BITLOOP - $0136 | ELESPEED - $0042 | NOTERR - $012E | | BUFFEND - $7FFF | GENLOOP - $01D5 | NOTFNDAS - $0189 | | BUFFER - $01F7 | GETENTRY - $017C | NOTSPACE - $011F | | CHARTOCW - $0172 | HOLDBYTE - $0045 | SEND - $0141 | | CHRSPEED - $0040 | INITMASK - $0044 | SENDIT - $01B0 | | CODEPRAC - $01CA | INVALAS - $018F | SINGLECH - $01BC | | CONTINUE - $0107 | LASTASCW - $0040 | SINGLOOP - $01C2 | | COUNT - $0047 | LOADLOOP - $019A | SPACENT - $0144 | | COUNTOK - $0134 | LOOP2 - $0161 | TRANSMIT - $0114 | | CWBUFFER - $0100 | MASK - $0046 | - $0000 | ---------------------------------------------------------------------------