Jump to content
IGNORED

Simple TI text editor (for cassette use)


jrhodes

Recommended Posts

What would you guys recommend for a TI program for basic text editing / note taking on a TI?

I am looking for something i can throw down some notes or a simple block of text, and save it to cassette (physical, not wav)

Program itself needs to be loadable from Basic / XB (or a EA5 i can load from the funnelweb loader)

 

So far, all i can come up with is to write each line as a REM, and save the whole thing to tape:

 

10 REM Todo list

11 REM 1. Find a better text editor

12 REM 2. Buy a TiPi

 

Theres got to be a better way?

Edited by jrhodes
Link to comment
Share on other sites

interesting! I would love to learn to write a program like that. :)

 

I may start to write one! Would have to use XB... the save routine could be a simple matter of reading each screen location, one by one, and PRINTING to the device. When loaded, it would do the same thing to re-draw the screen.

 

The question is the editing.... A cursor to travel the screen, then a routine to replace the contents of that location.

 

 

:D Should be fun. Im sure there is one of these out there already, but I may try to make one, just for the experience.

  • Like 1
Link to comment
Share on other sites

BITD I knew a guy who had a sidecar printer interface (I think it was a Parallax) and a cassette recorder, anyway he wrote a simple program 5 line program for TI Extended BASIC that would take 80 characters and when enter was pressed would send that line to the printer, clear the screen and be ready to accept another 80 characters. He called it, "The Poor Man's Press". It was simple but functional.

Link to comment
Share on other sites

That probably works good, but i am not interested in dumping straight to printer.

I just want to be able to jot down a note, and have it saved to cassette, for recall later from basic / xb.

 

Pretty easy to write this in basic.. (not tested on real hw)

 

10 DIM TEXT$(255)

15 D=1

20 INPUT TEXT$(D)

25 IF TEXT$(D)="LOAD" THEN 200

30 IF TEXT$(D)="SAVE" THEN 120

40 IF TEXT$(D)="LIST" THEN 70

45 IF TEXT$(D)="QUIT" THEN 270

50 D=D+1

60 GOTO 20

70 D=D-1

75 CALL CLEAR

80 FOR A=1 TO D

90 PRINT TEXT$(A)

100 NEXT A

110 GOTO 20

120 PRINT "SAVING FILE"

125 D=D-1

130 OPEN #1:"CS1",OUTPUT,DISPLAY ,VARIABLE 80

140 PRINT #1:D

150 FOR A=1 TO D

160 PRINT #1:TEXT$(A)

170 NEXT A

180 CLOSE #1

190 GOTO 270

200 PRINT "LOADING FILE"

210 OPEN #1:"CS1",INPUT ,DISPLAY ,VARIABLE 80

220 INPUT #1:D

230 FOR A=1 TO D

240 INPUT #1:TEXT$(A)

250 NEXT A

260 GOTO 75

270 END

  • Like 1
Link to comment
Share on other sites

For what it's worth, reading/writing single lines to cassette is super painfully slow - every line has the multiple-second leading tone. I once had a BASIC 'pinball' like game that loaded 20 rows to represent the table, and it was painful.

 

Thus, I'd recommend any such editor consider concatenating lines (maybe using fixed width, else including maybe a length byte so you can unpack it again), just to reduce the number of records you need to store. I think the record length on cassette is fixed (160 bytes??), so you'll want to stay under that, but otherwise, you'll appreciate the improvement in record/read time. ;)

Link to comment
Share on other sites

Are you familiar with using the OPEN, INPUT AND PRINT statements with FILE PROCESSING?

The example on page II-127 of the USER'S REFERENCE GUIDE. Isn't to far beyond rocket science!

How long are these notes supposed to be?

How fast do you expect to be able to type?

a record length of 192 equates to 6 lines of text.

This is the maximum length each recording on tape can be. Very short but perhaps long enough for short memos.

The longer tape recording method used by OLD, SAVE, cannot be achieved using BASIC's OPEN statement. :roll:

Edited by HOME AUTOMATION
Link to comment
Share on other sites

Are you familiar with using the OPEN, INPUT AND PRINT statements with FILE PROCESSING?

Honestly, no. There was at least 2 programs that relied on external data-files, which i hacked to use data lines within the main program after figuring out the format the data was being stored & read from the file.

I enjoy using old machines like the TI and commodores, but i can not truly call myself a programmer of any of them.

 

 

The example on page II-127 of the USER'S REFERENCE GUIDE. Isn't to far beyond rocket science!

I glanced at the user reference guide a few times, not anytime recently though.

 

 

How long are these notes supposed to be?

I imagine not more then one or two paragraphs at a time. Just random bits of brain fluff, jotted down in a timely manner.

 

How fast do you expect to be able to type?

I never was good at true typing. That said, i can "hunt and peck" at a good pace.

What i lack in keyboard skill, i make up for in memory. If i have given a particular subject any real amount of brain time, i can usually recall associated thoughts and ideas from the timeframe of first thought when i need.

I.E. i am not too concerned with forgetting what i was going to type/write by the time i can get it transferred to a digital format accurately.

Edited by jrhodes
Link to comment
Share on other sites

Actually, there was a program that gave Extended BASIC users a nice word processing program BITD that could also save to cassette. It was WORTEXT from Amnion Stoneware. It my be online somewhere. . .and I may have a copy of it in my program library, but no guarantees there.

  • Like 1
Link to comment
Share on other sites

I asked about the type-speed because using an INPUT statement repeatedly can be awkward for more than a few lines of print... using CALL KEY would allow for contiguous typing... however at TI BASIC's run speed you might have to get used to typing more slowly and having to keep the keys depressed longer, in order to avoid missed keystrokes.

I like the flow of arcadeshopper's program(above). I haven't tried it yet... looks like you'll have to remember to hit enter often... I thought maybe the longest records combined with pending INPUT/PRINT statements might condense the data per tape record.

Another way to go... a screen capture to tape could be less obtrusive to operate... you could type on the screen in immediate mode... using FCTN 4(CLEAR) instead of ENTER in order to avoid BASIC's unwanted responses.

I tried a little something on WIN994a... I really feel a need to use real iron for this one. I noticed for the first time that WIN994a's tape counter; counts character positions! :thumbsup:

Link to comment
Share on other sites

Arcadeshopper, i have not got to try yours out yet, but i will give it a shot,

I found these two programs in a set of amnion library disks: E163 "miti text", and G104 "miniword"

Both seem to support cs1 after looking at the code.

Will be giving them a good try sometime, still interested in wortext if it can be found.

cs1 word programs.zip

Arcadeshopper, i tried yours out in win994a simulator, since it has cs1 output support.

I am getting "i/o error 03 in 130" when i try to save.

In classic99, i used miniword and told it to save to cs1. I know classic99 does not yet support output to cs1, but it went through the normal saving cs1 prompts, without error, so i feel confident it will work on hardware just fine.

Ditto for miti-text. :)

fixed version of arcadeshoppers text editor:

10 DIM TEXT$(255)
15 D=1
20 INPUT TEXT$(D)
25 IF TEXT$(D)="LOAD" THEN 200
30 IF TEXT$(D)="SAVE" THEN 120
40 IF TEXT$(D)="LIST" THEN 70
45 IF TEXT$(D)="QUIT" THEN 270
50 D=D+1
60 GOTO 20
70 D=D-1
75 CALL CLEAR
80 FOR A=1 TO D
90 PRINT TEXT$(A)
100 NEXT A
110 GOTO 20
120 PRINT "SAVING FILE"
125 D=D-1
130 OPEN #1:"CS1",INTERNAL,FIXED 64,OUTPUT
140 PRINT #1:D
150 FOR A=1 TO D
160 PRINT #1:TEXT$(A)
170 NEXT A
180 CLOSE #1
190 GOTO 270
200 PRINT "LOADING FILE"
210 OPEN #1:"CS1",INTERNAL,FIXED 64,INPUT
220 INPUT #1:D
230 FOR A=1 TO D
240 INPUT #1:TEXT$(A)
250 NEXT A
260 GOTO 75
270 END
Edited by jrhodes
Link to comment
Share on other sites

The extra spaces between the commas are placed there automatically to accommodate the longer alternative options, such as

INPUT(5 chars.) vs. OUTPUT(6 chars.) or
DISPLAY(7 chars.) vs. INTERNAL(8 chars.)

Ran into the same problem doing the screen capture. :roll:

I'll bet 210 executed first... can't OPEN #1 twice... maybe add a CLOSE #1 line before 260... or just change the OPEN to #2.

Ran into the same problem doing the screen capture. :-D

Link to comment
Share on other sites

RXB has several better versions of CALL KEY or CALL ONKEY

 

CALL KEY("",0,K,S) ! No action is taken till a key is pressed and returned in K of course S is status.

This is much faster then input as no cursor flash is used to slow the program, and a backspace could be used in editor just like INPUT does.

 

CALL ONKEY("1234567890",0,K,S) GOTO 100,200,300,400,500,600,700,800,900,1000 ! Unless a key in string is pressed it ignores this line, if a number is pressed goes to that one in list

i.e. 5 would go to line 500 or 0 would go to line 1000

Link to comment
Share on other sites

Here is a program I found that might be useful for you.

 

SSSD.dsk

 

TAPEBASECB is the original program. Runs in Console Basic or Extended Basic.

 

TAPEBASEXB is the same program that I ran through XBASHER and TIGERCUB PRESCAANNER.. Runs in Extended Basic only.

 

 

  • Like 5
Link to comment
Share on other sites

About that issue of the leader tone recorded for each record sent out by BASIC, how do some of the modules get around that? Things like Household Budgement Mangement, PRK, or Video Chess write out their data to tape with 1 leader tone. Do they save them somehow as a program image ? And then going a step further, would it be possible to write an assembly routine or a GPL routine that calls the cassette DSR to do the same thing from within Extended BASIC?

 

Just thinking if you had an array of 8K in size somewhere in memory, you could call the cassette DSR and tell it to save all 8K in 1 record (like an 8K BASIC program) with 1 leader tone.

Edited by Casey
Link to comment
Share on other sites

Hmm from RXB manual:

 IO             subprogram                            PAGE  I3
          -------------------------------------------------------------
 
          Format         CALL IO(type,address[,...])
 
                         CALL IO(type,bits,cru-base,variable,variable
                         [,...])
 
                         CALL IO(type,length,vdp-address[,...])
 
          Description
 
          The IO subprogram allows access to and control of any chip in
          the console or peripheral cards. The type refers to different
          access methods like playing sound from GROM or VDP memory
          automatically. The type can also specify reading or writing
          directly to a Control Register Unit (CRU) address. Thereby
          allowing direct chip control, or direct chip bypass if the
          user wishes. The IO subprogram is a Graphics Programming        
          Language (GPL) command. So the function is exactly like GPL 
          despite being run from the XB environment. As most of XB is                            
          written in GPL the user gains greater GPL like control.
          After all the Operating System is written in GPL for a 
          good reason.*Note these docs are from GPL Manuals.
 
                 type             address specifications
                ~~~~~~            ~~~~~~~~~~~~~~~~~~~~~~
                  0   ----------  GROM sound list address.
                  1   ----------  VDP  sound list address.
                  2   ----------  CRU input.
                  3   ----------  CRU output.
                  4   ----------  VDP address of Cassette write list.
                  5   ----------  VDP address of Cassette read list.
                  6   ----------  VDP address of Cassette verify list.
 
           The length specifies the number of bytes. The length can be
          from -32768 to 32767 depending on the amount of VDP memory
          that is available. Of course a value of -32768 is HEX >8000
          and 32767 is HEX >7FFF and VDP normally in a TI is only 16384
          or HEX >4000 of VDP. So be careful or lock-up will result.
          The cru-base is the CRU address divided by 2  in decimal form
          as the command automatically doubles the value input. The CRU
          -base ranges from 0 to 8191 or HEX >0000 to >1FFF with a EVEN
          address for 8 bits or more being scanned. That means that a
          value of 8191 will lock-up the system as it is looking for a
          bit in 8192 that does not exist.

























          IO                                                   PAGE  I4
          -------------------------------------------------------------
          The variable can input or output values ranging from 0 to 255
          as that is equivalent to a single byte value. As there are
          two variables 16 bits can be represented in the two 8 bit
          variables. If CRU input reads less than 8 bits, the unused
          bits in the byte are reset to zero. If CRU input reads less
          then 16 but more than 8 bits, the unused bits in the word
          will be reset to zero. The bits range from 1 to 16 for input
          or output.
 
          AUTO-SOUND INSTRUCTION GROM/GRAM/VDP
 
          Format         CALL IO(type,address[,...])
 
           Control of the Sound Generator Chip (SGC) in the system
          console is through a pre-defined table in GROM/GRAM or VDP
          memory. Sound output is controlled by the table and the VDP
          Interrupt Service Routine (ISR). A control byte at the end of
          the table can cause control to loop back up in the table to
          continue, or end sound output. The format of the table is the
          same regardless of where it resides. The table consists of a
          series of blocks, each of which contains a series of bytes
          which are directly output to the SGC.
           Since the VDP generates 60 interrupts per second, the
          interrupt count is expressed in units of one-sixtieth of a
          second.
           When the IO command is called, upon the next occurring
          VDP interrupt, the first block of bytes is output to the SGC.
          The interpreter (Operating System) waits the requested number
          of interrupts (for example, if interrupt counts are 1, every
          interrupt causes the next block to be output). Remember that
          interpretation of XB continues normally while the SGC control
          is enabled.
           The sound control can be terminated by using an interrupt
          count of 0 in the last block of the table. Alternatively, a
          primitive looping control is provided by using a block whose
          first byte is 0, and the next 2 bytes indicate an address in
          the same memory space of the next sound block to use. (That
          means one block points to another block only in the same type
          of memory).


































          IO                                                   PAGE  I5
          -------------------------------------------------------------
           If the first byte is hex FF or decimal 255, the next two
          bytes indicate an address in the other memory space. (That
          means one block points to another block but in another type
          of memory.) These allow switching sound lists from GROM/GRAM
          to VDP or VDP to GRAM/GROM. By making this the beginning of
          the entire table, the sound sequence can be made to repeat
          indefinitely.
           The type 0 indicates sound lists in GROM or GRAM and type 1
          indicates sound lists in VDP.
           Executing a sound list while table-driven sound control is
          already in progress (from a previous sound list) causes the
          old sound control to be totally supplanted by the new sound
          instruction. (That means any sound chip command will over-
          ride old sound chip commands).
           The SGC has 3 tone (square wave) generators - 0, 1, and 2
          all of which can be working simultaneously or in combination.
          The frequency (pitch) and attenuation (volume) of each
          generator can be independently controlled. In addition, there
          is a noise generator which can output white or periodic
          noise. For more information on controlling the SGC, see the             
          TSM9919 SGC specification.                                                
 
          ATTENUATION CONTROL (for generators 0, 1, 2 or 3)
 
          One byte must be transmitted to the SGC:
 
          Binary     1-REG#-1-Attenuation
 
                REG# = register number (0,1,2,3)
                Attenuation = Attenuation/2
                      (e.g. A=0000 0  db = highest volume;
                            A=1000 16 db = medium volume;
                            A=1111 30 db = off. )
 
          EXAMPLE: 1 10 1 0000 : turn on gen. #2 highest volume.
                   1 01 1 0100 : turn on gen. #1 medium high volume.
                   1 11 1 1111 | turn off gen. #3 (noise generator).































          IO                                                   PAGE  I6
          -------------------------------------------------------------
          
          FREQUENCY CONTROL   (for generators 0, 1, 2)
          -----------------
          Two bytes must be transmitted to the SGC for a given register
          and to compute the number of counts from the frequency F
          use: N = 111860 / F
 
          Binary     1-REG#-N(1s 4 bits)-00-N(ms 6 bits)
                            Note that N must be split up into its least
                            significant 4 bits and most significant 6
                            bits (10 bits total).
 
           The lowest frequency possible is 110 Hz and the highest is
          55938 Hz.
 
          NOISE CONTROL                 |
          -------------                 |
          One byte must be transmitted to the SGC:
 
          Binary     1-1-1-0-0-T-S
 
                T = 0 for white noise, 1 for periodic noise;
                S = Shift rate (0,1,2,3) = frequency center of noise.
                    S=3=frequency dependent on the frequency of tone
                    generator #3.
 


































          IO                                                   PAGE  I7
          -------------------------------------------------------------
 
          Programs
 
          Line 100 clears screen.       | >100 CALL CLEAR ! Chimes
          Line 110 to ...               | >110 DATA 5,159,191,223,255,2
                                        |  27,1,9,142,1,164,2,197,1,144
                                        |  ,182,211,6,3,145,183,212,5,3
                                        |  ,146,184,213,4
                                        | >120 DATA 5,167,4,147,176,214
                                        |  ,5,3,148,177,215,6,3,149,178
                                        |  ,216,7
                                        | >130 DATA 5,202,2,150,179,208
                                        |  ,6,3,151,180,209,5,3,152,181
                                        |  ,210,4
                                        | >140 DATA 5,133,3,144,182,211
                                        |  ,5,3,145,183,212,6,3,146,184
                                        |  ,213,7
                                        | >150 DATA 5,164,2,147,176,214
                                        |  ,6,3,148,177,215,5,3,149,178
                                        |  ,216,4
          Line 160 ends sound list.     | >160 DATA 5,197,1,150,179,208
                                        |  ,5,3,151,180,209,6,3,152,181
                                        |  ,210,7,3,159,191,223,0
          Line 170 reads list into B and| >170 A=A+1 :: READ B :: CALL
          A is counter                  |   POKEV(A,B)
          Line 180 checks end of list?  | >180 IF B=0 THEN 190 ELSE 170
          Line 190 shows how to access. | >190 PRINT "TYPE:": :"CALL IO(
                                        |  1,8192)"
                                        | >200 CALL IO(1,8192)
                                        | 
          
          Line 310 continues AD loop.   | >310 NEXT AD
          Line 320 executes sound list. | >320 CALL IO(1,4096)
          Line 330 prints out suggestion| >330 PRINT "CRASH": :"TYPE:":
          on how to test IO.            |  "CALL IO(1,4096)"

























  

          IO                                                   PAGE  I8
          -------------------------------------------------------------
 
          Programs
 
          Line 100 clears the screen.   | >100 CALL CLEAR ! CRASH
          Line 110 to ...               | >110 DATA 2,228,242,5
                                        | >120 DATA 2,228,240,18
                                        | >130 DATA 2,228,241,16
                                        | >140 DATA 2,228,242,14
                                        | >150 DATA 2,228,243,12
                                        | >160 DATA 2,228,244,10
                                        | >170 DATA 2,229,245,9
                                        | >180 DATA 2,229,246,8
                                        | >190 DATA 2,229,247,7
                                        | >200 DATA 2,229,248,6
                                        | >210 DATA 2,229,249,5
                                        | >220 DATA 2,230,250,4
                                        | >230 DATA 2,230,251,3
                                        | >240 DATA 2,230,252,2
                                        | >250 DATA 2,230,253,1
                                        | >260 DATA 2,230,254,1
          Line 270 ends sound list.     | >270 DATA 1,255,0,0
          Line 280 AD is VDP address to | >280 FOR AD=4096 TO 4160 STE
          start with and ends with.     |  P 4
          Line 290 reads list.          | >290 READ V1,V2,V3,V4
          Line 300 moves them into VDP. | >300 CALL POKEV(AD,V1,V2,V3,V
                                        |  4)
          Line 310 continues AD loop.   | >310 NEXT AD
          Line 320 executes sound list. | >320 CALL IO(1,4096)
          Line 330 prints out suggestion| >330 PRINT "CRASH": :"TYPE:":
          on how to test IO.            |  "CALL IO(1,4096)"
 
           All data values must converted to Binary in order to see
          what is going on. You now have all the data that I have as
          to this phase of IO types 0 and 1. See Editor Assembler
          Manual also for more data on sound lists and sound chip.
























          IO                                                   PAGE  I9
          -------------------------------------------------------------
          Sound table creator for conversion of sound data.

          100 CALL CLEAR :: PRINT "*SOUND DATA TABLE CREATOR*"
          110 Q$="0123456789ABCDEF"
          120 INPUT "GENERATOR # ?":GN
          130 INPUT "DURATION ?":DUR
          140 INPUT "FREQUENCY ?":FREQ
          150 INPUT "VOLUME ?":VOL :: PRINT : : :
          160 IF DUR>17 THEN 180
          170 DUR=17
          180 REM  DURATION 
          190 DUR=INT((DUR*255)/4250) :: CONV=DUR :: GOSUB 400
          200 DUR$=SEG$(HX$,3,2) :: IF FREQ>-1 THEN 290
          210 REM   NOISE FREQUENCY  
          220 FR=ABS(FREQ)-1 :: FR$="E"&STR$(FR)
          230 REM  NOISE VOLUME 
          240 VOL=INT(VOL/2) :: CONV=VOL
          250 GOSUB 430 :: VOL$="F"&SEG$(HX$,4,1)
          260 PRINT "DATA>02";FR$;",>";VOL$;DUR$: : :
          270 GOTO 360
          280 REM  TONE FREQUENCY 
          290 FR=INT((111860.8/FREQ)+.5)
          300 CONV=FR :: GOSUB 400
          310 FR$=SEG$(Q$,GN*2+7,1)&SEG$(HX$,4,1)&SEG$(HX$,2,2)
          320 REM  TONE VOLUME 
          330 VOL=INT(VOL/2) :: CONV=VOL :: GOSUB 400
          340 VOL$=SEG$(Q$,GN*2+8,1)&SEG$(HX$,4,1)
          350 PRINT "DATA>03";SEG$(FR$,1,1)&SEG$(FR$,2,1);",>";
          SEG$(FR$,3,2);VOL$;",>";DUR$;"00": : :
          360 PRINT: :"ANOTHER SOUND (Y/N)?"
          370 CALL ONKEY("YN",3,K,S) GOTO 100,390
          380 GOTO 370
          390 CALL CLEAR :: END
          400 REM  DECIMAL TO HEX 
          410 AY=INT(CONV)/16 :: BY=INT(AY)/16 
          420 CY=INT(BY)/16 :: DY=INT(CY)/16
          430 AP=(AY-INT(AY))*16 :: BP=(BY-INT(BY))*16
          440 CP=(CY-INT(CY))*16 :: DP=(DY-INT(DY))*16
          450 HX$=SEG$(Q$,DP+1,1)&SEG$(Q$,CP+1,1)&
          SEG$(Q$,BP+1,1)&SEG$(Q$,AP+1,1) :: RETURN
         
          Use this program to create Hex strings that can use
          CALL MOVES to move strings into VDP to be played from
          a CALL IO(1,VDP-address)


















          IO                                                   PAGE I10
          -------------------------------------------------------------
 
          CRU ACCESS INSTRUCTION
 
          Format         CALL IO(type,bits,cru-base,variable,variable
                         [,...])
 
           The IO types 2 and 3 can be used to control devices.
          IO always must be the CRU address divided by 2 as any 
          value above 8192 will be out of range. The cru-base must be  
          divided by 2 as the 9901 chip ignores the least significant 
          bits of the base register it uses. See Editor Assembler 
          Manual page 61. The CRU data to be written should be right  
          justified in the byte or word. The least significant bit 
          will output to or input from the CRU address specified by 
          the CRU base address. Subsequent bits will come from or go 
          to sequentially higher CRU addresses. If the CRU input reads 
          less than 8 bits, the unused bits in the byte are reset to 
          zero. If the CRU input reads less than 16 bits but more than 
          8 bits, the unused bits in the full two 8 bit bytes will be 
          reset to zero.
 
          Programs
          Line 100 display what it does | >100 DISPLAY AT(1,1)ERASE ALL
          for you.                      |  :"THIS PROGRAM CHECKS FOR
                                        |    UNUSUAL KEYS BEING PRESSED
                                        |  , EVEN IF MORE THEN FOUR KEY
                                        |  ARE BEING PRESSED AT ONCE"
          Line 110 scans CRU at >0006   | >110 CALL IO(2,16,3,A,B):: IF
          and reports keys pressed.     |   A=18 AND B=255 THEN 110 ELS
                                        |  E CALL HPUT(24,3,RPT$(" ",30
                                        |  ),24,24,STR$(A)&" "&STR$(B))
          Line 120 more reports.        | >120 IF A=146 THEN CALL HPUT(
                                        |  24,3,"FUNCTION KEY")ELSE IF
                                        |  B=191 THEN CALL HPUT(24,3,"C
                                        |  ONTROL KEY")ELSE IF B=223 TH
                                        |  EN CALL HPUT(24,3,"SHIFT KEY
                                        |  ")
          Line 130 still more reports.  | >130 IF B=251 THEN CALL HPUT(
                                        |  24,3,"ENTER KEY")ELSE IF B=2
                                        |  53 THEN CALL HPUT(24,3,"SPAC
                                        |  E BAR")ELSE IF B=254 THEN CA
                                        |  LL HPUT(24,3,"PLUS/EQUAL KEY
                                        |  ")
          Line start over scan of keys. | >140 GOTO 110

















          IO                                                   PAGE I11
          -------------------------------------------------------------
 
          Programs
 
          Line 100 clears screen.       | >100 CALL CLEAR
          Line 110 explains program.    | >110 CALL HPUT(4,7,"This is a
                                        |   demo of the",6,7,"CALL IO(3
                                        |  ,8,2176,B)",8,7,"3 = TYPE(CR
                                        |  U output)",10,7,"8 = NUMBER
                                        |  OF BITS",12,7,"2176=address/
                                        |  2")
          Line 120 turn off card, show  | >120 CALL IO(3,8,2176,0):: FO
          the present byte value being  |  R B=0 TO 255 :: CALL HPUT(14
          sent.                         |  ,7,"B=byte (value "&STR$(B)&
                                        |  ")")
          Line 130 display block to get  | >130 CALL HPUT(18,5,"********
          attention.                    |  ******************",19,5,"WA
                                        |  TCH THE DRIVE LIGHTS",20,5,"
                                        |  **************************")
          Line 140 send byte to card and| >140 CALL IO(3,8,2176,B):: NE
          when done with loop, clear for|  XT B :: CALL HCHAR(14,24,32,
          starting over program.        |  7):: GOTO 110
                                        |
          Line 100 explains program.    | >100 ! TURNS OFF/ON/OFF EACH
                                        |  CARD FROM >1000 TO >1F00 BUT
                                        |  WILL LOCKUP WITH CERTAIN
                                        |  CARDS.
          Line 110 cru address from     | >110 FOR CRU=2048 TO 3968 STE
          >1000 to >1F00, turn off card,|  P 128::CALL IO(3,8,CRU,0,3,8
          turn on card, delay for 2     | >,CRU,255)::FOR A=1 TO 200::N
          seconds, turn off card, turn  |  EXT A::CALL IO(3,8,CRU,0)::N
          off card. Loop end.           |  EXT CRU

          Options
           Some CRU address are used by the Operating System or XB and
          any attempt to redefine them will create problems. Also some
          of the address areas will return incorrect values as they
          have changed since IO has accessed them. These problems will
          never become completely apparent at first, so take care.
          Additionally some cards have the same problem, if the card
          has a program that has a interrupt or CRU links turned on as
          you access it, a complete lock up will result as a fight for
          control ensues. So with that happy thought, a alternate way
          is to use EXECUTE or LINK instead.


















          IO                                                   PAGE I12
          -------------------------------------------------------------
 
          CASSETTE INPUT/OUTPUT/VERIFY INSTUCTION
 
          Format         CALL IO(type,length,vdp-address[,...])
 
           The three different cassette I/O instructions use the same
          format. The write and read instructions physically perform
          Input/Output to the cassette. The verify instruction will
          read a tape and compare it, byte by byte, against what is in
          the specified VDP area. All will report an  I/O error if one
          is detected. No prompts are present with these three formats.   
          These three types control the cassette directly so no prompt 
          will tell the user to turn on or off the cassette record/play 
          buttons. The programmer must inform the user with own prompt.
 
          Programs
          (Presently I have no cassette to write programs with.)
 
          AUDIO GATE
          ----------
          CRU bit 24 is the audio gate which allows data being read to
          be heard. If the bit is set to 1, the data being read is
          heard, and if the bit is set to 0, the data is not heard.
          Setting the bit to a 0 or 1 is done with an IO instruction, or
          a Assembly instruction.
 
          MOTOR CONTROL
          -------------
          There are two CRU bits (22 and 23) used to control cassettes
          1 and 2, respectively. When there is no Cassette IO being
          done, both motors remain on. When Cassette IO is specified,
          the DSR (Device Service Routine) will control the data being
          read. If there are two motor units connected, the data will be
          read simultaneously, or you may have the option of reading
          data from one motor unit and playing the recorded voice from
          another motor unit through the TV (Monitor) speaker. 
          
          *NOTE:
          Compatibility with or without 32K or other devices is not a
          concern as IO needs no RAM to work with. Therefore from just
          a console all IO commands will work fine. If you only have a
          Cassette and RXB you can quickly load/save/verify without
          menus, or just make up your own.


















         
Edited by RXB
  • Like 1
Link to comment
Share on other sites

[slightly O.T.]

Dang, rich... You are really making me drool for a copy of RXB.

Seriously, my next TI purchase is a 3-way toss up between a RXB cart, final grom, or tipi.

Has anyone ever tried to mod RXB into console rom?

Just imagine being able to boot into RXB with nothing in the cart port, straight from the main menu...

  • Like 1
Link to comment
Share on other sites

Thanks Rich! I will do some playing with this over the weekend (I have a cassette recorder attached to my 99/4A that I can run RXB on) and do some comparison testing with a simple program in TI BASIC that uses the traditional file access methods and one that uses RXB to save a block of VDP memory to cassette. I'm already sure I know which one is better, but it'll give me a chance to get more into RXB as well. So much to learn!

  • Like 1
Link to comment
Share on other sites

This seems like more of a novelty than a utility...
...but than again, maybe good for something.

100 A=0
110 E=2
120 B=168
130 D=1
140 A=A+1
150 E=E+1
160 IF E<>31 THEN 190
170 E=3
180 D=D+1
190 CALL GCHAR(D,E,C)
200 A$=CHR$©
210 B$=B$&A$
220 IF A<>B THEN 140
230 T$(F)=B$
240 F=F+1
250 B$=""
260 IF A=672 THEN 290
270 B=B+168
280 GOTO 140
290 CALL CLEAR
300 OPEN #1:"CS1",OUTPUT,FIXED 192,INTERNAL
310 FOR Z=0 TO 3
320 PRINT #1:T$(Z)
330 NEXT Z
340 END
350 OPEN #1:"CS1",INPUT,FIXED 192,INTERNAL
360 FOR X=0 TO 3
370 INPUT #1:T$(X)
380 NEXT X
390 FOR W=0 TO 3
400 PRINT T$(W)
410 NEXT W
420 GOTO 420

How to use:

1) Type on screen...use FCTN 4 instead of ENTER.
2) Type RUN
3) Wait... about 120 sec.
4) Follow recording cassette prompts.

SAVED!

To recover:

1) Type RUN 350
2) Follow playing cassette prompts.
3 Previously saved screen displays

...The bottom 2 lines are unusable.

 

screencapture.wav

screencapture.dsk

 

Good luck!

  • Like 1
Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
  • Recently Browsing   0 members

    • No registered users viewing this page.
×
×
  • Create New...