Loading ...
Sorry, an error occurred while loading the content.

Re: [Altair Computer Club] Dazzler Software?

Expand Messages
  • John Crane
    Looking at Kaleidoscope and ignoring initial nulls, I see:   31 00 01 3E 81 ....   And those do not translate to hex characters.  They are:   1 null soh
    Message 1 of 23 , Jan 2, 2009
    • 0 Attachment
      Looking at Kaleidoscope and ignoring initial nulls, I see:
       
      31 00 01 3E 81 ....
       
      And those do not translate to hex characters.  They are:
       
      1 null soh > [out of range for ascii]
       
      However, in 8080 assembly they are:
       
      LXI  SP, 100h
      MVI  A, 81h
       
      Which looks like a typical way to start an 8080 program, by setting the stack pointer and getting some data into the accumulator.
       
      So, it looks like they are binary images, not papertapes.  I can zap them straight in and not have to worry about special loaders.
       
       
      I remember all the weirdness with the SWTPC 6800 MIKBUG monitor that used a special Motorola format with hex characters, all to overcome the 7 bit limitation of the ASR-33s of the day.  That one missing bit made loading everything twice as long as it should have been!
       
       
      -J
       

      --- On Sat, 1/3/09, Dan Roganti <ragooman@...> wrote:

      From: Dan Roganti <ragooman@...>
      Subject: Re: [Altair Computer Club] Dazzler Software?
      To: altaircomputerclub@yahoogroups.com
      Date: Saturday, January 3, 2009, 3:42 AM



      oghull wrote:
      --- In altaircomputerclub@ yahoogroups. com, "Andrew Kessel"
      <akessel56@.. .> wrote:
        
      Are those .ptp files standard binary files, that one can upload
          
      through a
        
      serial connection?
          
      I have copies of the manuals for some of the Dazzler programs: Life,
      Dazzlemation, Kaleidoscope, Dazzlewriter, Dazzle-Writer 512, and Tic
      Tac Toe.  If you can't find them elsewhere online, I could probably
      scan at least some of them.  They include program listings and a
      simple tape loader program.
      
      Looking at the tape loader, the tapes appear to be simple 8 bit binary
      memory dumps starting at address 0.
        

      The *ptp files are only hex files with the header padded with 0x00's in the beginning. You can compare this by looking at the code in the manuals, try looking at the Spacewar code. If you use a Hex Editor you can see that it's padded with header bytes in the papertape images, the amount varies depending on the image, but it's always 0x00's. You can edit this and remove the padded bytes and save them as hex files and load them with your monitor.

      I noticed that some of the programs from the manual are not on bitsavers. I use a freeware OCR to extract the assembly code and assemble them again, or just the object code if that's in the manual. There's a couple of  good ones available.I converted the assembly code for Altair Basic and Imsai Basic this way--it let's me patch the code to support different serial port cards.  You first want to extract the pages with the code that you want to OCR, I just use primopdf to print only these pages into a different pdf file.
      http://www.ocrtermi nal.com/
      http://www.omniform at.com/download. html
      http://www.primopdf .com/

      The Daazler manuals are already online at several websites.
      http://maben. homeip.net/ static/S100/ cromemco/ software/ games/index. html
      http://www.hartetec hnologies. com/manuals/ Cromemco/
      http://bitsavers. vt100.net/ pdf/cromemco/

      =Dan
      -- 
      [ Happy New Year --- http://www2. applegate. org/~ragooman/   ]
      
      

    • oghull
      ... The Dazzler paper tapes I have are just binary images. There s no leadin/leadout bytes, no encoding, no checksum, nothing. I don t know why the .ptp
      Message 2 of 23 , Jan 2, 2009
      • 0 Attachment
        --- In altaircomputerclub@yahoogroups.com, John Crane
        <john_crane_59@...> wrote:
        >
        > So, it looks like they are binary images, not papertapes. 
        > I can zap them straight in and not have to worry about special loaders.


        The Dazzler paper tapes I have are just binary images. There's no
        leadin/leadout bytes, no encoding, no checksum, nothing. I don't know
        why the .ptp files have nulls, but my pape tapes don't have them. The
        Cromemco loader just sets HL to 0 (or 0x5000 for dazzlewriter), reads
        a byte from the input port, writes it to memory, increments HL and
        loops. It looks like you can do the same thing with the .ptp files
        after you strip the leading nulls.

        Geoff Harrison.
      • Andrew Kessel
        I use the mbl boot loader usually for binary. Though its been a while. I have a dazler, just never used it, so was curious. ... -- Andrew Kessel
        Message 3 of 23 , Jan 3, 2009
        • 0 Attachment
          I use the mbl boot loader usually for binary. Though its been a while.
           
          I have a dazler, just never used it, so was curious.

          On Fri, Jan 2, 2009 at 5:47 PM, John Crane <john_crane_59@...> wrote:

          Andrew,
           
          Actually I haven't looked at them yet.  I've got a hardware problem in my Dazzler and I'm waiting on some incoming parts.  But it's my understanding that paper tapes were for ASCII-only teletypes.  That means 7 data bits plus a parity bit, not 8 data bits.  You raise a good question - what loader program to use ?
           
           
          -John

          --- On Fri, 1/2/09, Andrew Kessel <akessel56@...> wrote:

          From: Andrew Kessel <akessel56@...>

          Subject: Re: [Altair Computer Club] Dazzler Software?
          To: altaircomputerclub@yahoogroups.com
          Date: Friday, January 2, 2009, 11:16 PM

          Are those .ptp files standard binary files, that one can upload through a serial connection?

          On Wed, Dec 31, 2008 at 11:35 AM, John Crane <john_crane_59@ yahoo.com> wrote:
          Thanks Tom!
           
          -John

          --- On Wed, 12/31/08, Tom Lake <tlake@twcny. rr.com> wrote:

          From: Tom Lake <tlake@twcny. rr.com>
          Subject: Re: [Altair Computer Club] Dazzler Software?
          To: altaircomputerclub@ yahoogroups. com
          Date: Wednesday, December 31, 2008, 12:46 PM


          You can get paper tape images here:

          http://bitsavers. trailing- edge.com/ bits/Cromemco/ paperTapes/

          Tom Lake

          ============ =========
          Posted through Grouply, the better way
          to access your Yahoo Groups like this one.
          http://www.grouply. com/?code= post





          --
          Andrew Kessel





          --
          Andrew Kessel

        • john_crane_59
          ... Well, the Dazzler is up and running! Kalideoscope is pretty amazing for 70 s tech. I haven t managed to get Life to work though - just get one blue cell.
          Message 4 of 23 , Jan 11, 2009
          • 0 Attachment
            --- In altaircomputerclub@yahoogroups.com, John Crane
            <john_crane_59@...> wrote:
            >
            > Looking at Kaleidoscope and ignoring initial nulls, I see:
            >  
            > 31 00 01 3E 81 ....
            >  


            Well, the Dazzler is up and running!

            Kalideoscope is pretty amazing for 70's tech.

            I haven't managed to get Life to work though - just get one blue
            cell. I have the manual, but still no joy. It's communicating with
            the console on the standard port 01, no problem there. I trimmed
            the NULLS from the papertape images, but left a string terminating
            NULL, then tried leaving the BELLs (07h) chars at the end (an
            annunciator telling the TTY user the tape has loaded?)

            I did find something unusual. Although I did not disassemble it, I
            noticed the first three bytes was a jump command the very next
            instruction. Maybe there's a reason for this somewhere in the code.

            -John
          • Rich Whiteman
            31 00 01 loads the stack pointer with what needs to be an area of ram to use for calls, returns, pushes and pops. It works from the loaded area downward. It
            Message 5 of 23 , Jan 11, 2009
            • 0 Attachment
              31 00 01 loads the stack pointer with what needs to be an area of ram
              to use for calls, returns, pushes and pops. It works from the loaded
              area downward. It is not a jump.

              Rich

              LXI SP,word LD SP,word 31word SP <- word

              --- In altaircomputerclub@yahoogroups.com, "john_crane_59"
              <john_crane_59@...> wrote:
              >
              > --- In altaircomputerclub@yahoogroups.com, John Crane
              > <john_crane_59@> wrote:
              > >
              > > Looking at Kaleidoscope and ignoring initial nulls, I see:
              > >
              > > 31 00 01 3E 81 ....
              > >
              >
              >
              > Well, the Dazzler is up and running!
              >
              > Kalideoscope is pretty amazing for 70's tech.
              >
              > I haven't managed to get Life to work though - just get one blue
              > cell. I have the manual, but still no joy. It's communicating with
              > the console on the standard port 01, no problem there. I trimmed
              > the NULLS from the papertape images, but left a string terminating
              > NULL, then tried leaving the BELLs (07h) chars at the end (an
              > annunciator telling the TTY user the tape has loaded?)
              >
              > I did find something unusual. Although I did not disassemble it, I
              > noticed the first three bytes was a jump command the very next
              > instruction. Maybe there's a reason for this somewhere in the code.
              >
              > -John
              >
            • john_crane_59
              Rich, You are correct for Kalideoscope, that was my initial post. I guess I wasn t too clear in my second post. I was talking about the game Life . The
              Message 6 of 23 , Jan 11, 2009
              • 0 Attachment
                Rich,

                You are correct for Kalideoscope, that was my initial post. I guess I
                wasn't too clear in my second post. I was talking about the
                game "Life". The fist five bytes are:

                C3 03 00 31 00

                And, assuming the programs runs from 0000, it should immediatly jump
                to the very next instruction, the 31 (LXI).

                Maybe there's a reason for it, but it sure looks like a waste of three
                bytes.

                -John

                --- In altaircomputerclub@yahoogroups.com, "Rich Whiteman"
                <richwmn@...> wrote:
                >
                > 31 00 01 loads the stack pointer with what needs to be an area of ram
                > to use for calls, returns, pushes and pops. It works from the loaded
                > area downward. It is not a jump.
                >
                > Rich
                >
                > LXI SP,word LD SP,word 31word SP <- word
                >
              • Derek J. Lassen
                IIRC, the hex file format had no transfer address, and assumed x 0000 . Many programmers put constants and jump tables at the beginning. So, we usually coded :
                Message 7 of 23 , Jan 11, 2009
                • 0 Attachment
                  IIRC, the hex file format had no transfer address, and assumed x'0000'. Many programmers put constants and jump tables at the beginning. So, we usually coded :
                           ORG   0
                           JMP    Entry
                  Entry  EQU   *

                  as the first three lines.

                  (s) Derek
                  Altair #000000067

                  At 02:18 AM 1/12/2009 +0000, you wrote:

                  Rich,

                  You are correct for Kalideoscope, that was my initial post. I guess I
                  wasn't too clear in my second post. I was talking about the
                  game "Life". The fist five bytes are:

                  C3 03 00 31 00

                  And, assuming the programs runs from 0000, it should immediatly jump
                  to the very next instruction, the 31 (LXI).

                  Maybe there's a reason for it, but it sure looks like a waste of three
                  bytes.

                  -John

                  --- In altaircomputerclub@yahoogroups.com, "Rich Whiteman"
                  <richwmn@...> wrote:
                  >
                  > 31 00 01 loads the stack pointer with what needs to be an area of ram
                  > to use for calls, returns, pushes and pops. It works from the loaded
                  > area downward. It is not a jump.
                  >
                  > Rich
                  >
                  > LXI SP,word LD SP,word 31word SP <- word
                  >

                • john_crane_59
                  Good point, it could be a remnant from an assembly language template. The programmer just forgot to remove it, as this application does not have any data in
                  Message 8 of 23 , Jan 12, 2009
                  • 0 Attachment
                    Good point, it could be a remnant from an assembly language
                    template. The programmer just forgot to remove it, as this
                    application does not have any data in that area. All the data seems
                    to be grouped at the end.

                    I also found that the code only contains ascii compares for F, S,
                    and Y. However, my manual says the program takes many more one
                    letter commands. In fact, when I looked for the command C (to move
                    the cursor) the ascii code for C (43 upper 63 lower) doesn't appear
                    anywhere in the code, so that also eliminates a jump table holding
                    command chars.

                    Of course, there could be some really funny business going on in the
                    code (derived command codes, etc). But the game of Life is so
                    simple, I don't see the need for it, especially in something like
                    the command processor.

                    Has anyone had any luck with the life program from bitsavers?

                    http://bitsavers.trailing-edge.com/bits/Cromemco/paperTapes/


                    -John






                    --- In altaircomputerclub@yahoogroups.com, "Derek J. Lassen"
                    <xl198CV56@...> wrote:
                    >
                    > IIRC, the hex file format had no transfer address, and assumed
                    > x'0000'. Many programmers put constants and jump tables at the
                    > beginning. So, we usually coded :
                    > ORG 0
                    > JMP Entry
                    > Entry EQU *
                    >
                    > as the first three lines.
                    >
                    > (s) Derek
                    > Altair #000000067
                    >
                    > At 02:18 AM 1/12/2009 +0000, you wrote:
                    >
                    > >Rich,
                    > >
                    > >You are correct for Kalideoscope, that was my initial post. I
                    guess I
                    > >wasn't too clear in my second post. I was talking about the
                    > >game "Life". The fist five bytes are:
                    > >
                    > >C3 03 00 31 00
                    > >
                    > >And, assuming the programs runs from 0000, it should immediatly
                    jump
                    > >to the very next instruction, the 31 (LXI).
                    > >
                    > >Maybe there's a reason for it, but it sure looks like a waste of
                    three
                    > >bytes.
                    > >
                    > >-John
                    > >
                    > >--- In
                    > ><mailto:altaircomputerclub%
                    40yahoogroups.com>altaircomputerclub@yahoogroups.com,
                    > >"Rich Whiteman"
                    > ><richwmn@> wrote:
                    > > >
                    > > > 31 00 01 loads the stack pointer with what needs to be an area
                    of ram
                    > > > to use for calls, returns, pushes and pops. It works from the
                    loaded
                    > > > area downward. It is not a jump.
                    > > >
                    > > > Rich
                    > > >
                    > > > LXI SP,word LD SP,word 31word SP <- word
                    > > >
                    > >
                    > >
                    >
                  • Craig Landrum
                    ... Assuming you have 52 bytes available for a jump table, it is easy to support every character of the alphabet as commands. Subtract A from the character
                    Message 9 of 23 , Jan 12, 2009
                    • 0 Attachment
                      > I also found that the code only contains ascii compares for F, S,
                      > and Y. However, my manual says the program takes many more one
                      > letter commands. In fact, when I looked for the command C (to move
                      > the cursor) the ascii code for C (43 upper 63 lower) doesn't appear
                      > anywhere in the code, so that also eliminates a jump table holding
                      > command chars.
                      >
                      > Of course, there could be some really funny business going on in the
                      > code

                      Assuming you have 52 bytes available for a jump table, it is easy to
                      support every character of the alphabet as commands. Subtract "A" from
                      the character entered, shift left one bit (multiply * 2), the add the
                      result to a register pair (like HL) that contains the start of the
                      26 addresses of the command handlers, load the jump address from the
                      table into HL and JP (HL). Don't support some letter commands? Just
                      point those to a "bad command" routine or ignore them. For a complex
                      program with lots of commands, you are unlikely to find a direct
                      letter for letter comparison, although once you make the jump, there
                      could be direct comparisons for commands that have arguments or
                      two-letter commands.

                      Just a thought.

                      --
                      Craig Landrum
                      Chief Technical Officer
                      mindwrap, inc.
                      Phone: (540) 675-3015 x 229
                      Fax: (540) 675-3130
                      email: craigl@...
                    • john_crane_59
                      ... S, ... move ... appear ... holding ... the ... to ... from ... the ... the ... Just ... complex ... there ... That s the funny businesss I was considering
                      Message 10 of 23 , Jan 12, 2009
                      • 0 Attachment
                        --- In altaircomputerclub@yahoogroups.com, Craig Landrum
                        <craigl@...> wrote:
                        >
                        > > I also found that the code only contains ascii compares for F,
                        S,
                        > > and Y. However, my manual says the program takes many more one
                        > > letter commands. In fact, when I looked for the command C (to
                        move
                        > > the cursor) the ascii code for C (43 upper 63 lower) doesn't
                        appear
                        > > anywhere in the code, so that also eliminates a jump table
                        holding
                        > > command chars.
                        > >
                        > > Of course, there could be some really funny business going on in
                        the
                        > > code
                        >
                        > Assuming you have 52 bytes available for a jump table, it is easy
                        to
                        > support every character of the alphabet as commands. Subtract "A"
                        from
                        > the character entered, shift left one bit (multiply * 2), the add
                        the
                        > result to a register pair (like HL) that contains the start of the
                        > 26 addresses of the command handlers, load the jump address from
                        the
                        > table into HL and JP (HL). Don't support some letter commands?
                        Just
                        > point those to a "bad command" routine or ignore them. For a
                        complex
                        > program with lots of commands, you are unlikely to find a direct
                        > letter for letter comparison, although once you make the jump,
                        there
                        > could be direct comparisons for commands that have arguments or
                        > two-letter commands.
                        >
                        > Just a thought.
                        >
                        > --
                        > Craig Landrum
                        > Chief Technical Officer
                        > mindwrap, inc.
                        > Phone: (540) 675-3015 x 229
                        > Fax: (540) 675-3130
                        > email: craigl@...
                        >


                        That's the funny businesss I was considering - derived command chars
                        and address tables. You explained it very well, thank you! But I
                        checked for that, no ascii codes for "a" or "A" (except in a data
                        string at the end instructing the user to "ENTER DATA"). And no
                        subtracts, subtracts with borrows, or subtracts immediate with or
                        without borrow anywhere in the code.

                        I also found a DB FF, which reads the sense switches. That worries
                        me because there is absolutely no reference to using the switches in
                        the manual.

                        I'm beginning to think I've got the wrong program.

                        -John
                      • D. Hugh Redelmeier
                        ... Interesting. Those low addresses are used for the interrupt jump vector but I guess most programs never used interrupts. I used the interrupt instructions
                        Message 11 of 23 , Jan 12, 2009
                        • 0 Attachment
                          | From: Derek J. Lassen <xl198CV56@...>

                          | IIRC, the hex file format had no transfer address, and assumed x'0000'. Many
                          | programmers put constants and jump tables at the beginning. So, we usually coded :
                          | ORG 0
                          | JMP Entry
                          | Entry EQU *
                          |
                          | as the first three lines.

                          Interesting. Those low addresses are used for the interrupt jump
                          vector but I guess most programs never used interrupts.

                          I used the interrupt instructions for very short subroutine calls (1 byte
                          instead of 3). This also made it possible to "revector" to a different
                          implementation: the low memory was in RAM but my code was in a
                          ByteSaver EPROM.
                        • john_crane_59
                          Yes, I remember TINY BASIC used the RST method, too. Back when every byte was expensive, you saved space where you could. Most later software was ORG-ed @
                          Message 12 of 23 , Jan 13, 2009
                          • 0 Attachment
                            Yes, I remember TINY BASIC used the RST method, too. Back when
                            every byte was expensive, you saved space where you could. Most
                            later software was ORG-ed @ 0100h to provide some standardization.
                            That's what CP/M used too.


                            While relaxing and watching my Dazzler run kalideoscope, I was
                            considering what new project to tackle... then I got one.

                            I heard a *click* and the front panel went dark. Doomsday had come!
                            I immediately pulled the plug and started sniffing. No smoke. At
                            first it seemed the rectifier blew. 8.5 VAC going in and zip coming
                            out. Then I noticed a very tiny spark on the printed trace on one
                            of the 8.5 VAC inputs to the rectifier. Turns out there was a micro
                            crack right across a trace. My guess is that thermal/mechanical
                            stress over the years did it. Possibly the rectifier module isn't
                            properly mounted - if it's too high or too low it might cause stress
                            on the PCB when it's bolted to that bottom metal frame member /
                            humongous heatsink. The PCB is bolted at 4 other points, so any
                            difference in height would cause some bending of the PCB.

                            -John







                            --- In altaircomputerclub@yahoogroups.com, "D. Hugh Redelmeier"
                            <hugh@...> wrote:
                            >
                            > | From: Derek J. Lassen <xl198CV56@...>
                            >
                            > | IIRC, the hex file format had no transfer address, and assumed
                            x'0000'. Many
                            > | programmers put constants and jump tables at the beginning. So,
                            we usually coded :
                            > | ORG 0
                            > | JMP Entry
                            > | Entry EQU *
                            > |
                            > | as the first three lines.
                            >
                            > Interesting. Those low addresses are used for the interrupt jump
                            > vector but I guess most programs never used interrupts.
                            >
                            > I used the interrupt instructions for very short subroutine calls
                            (1 byte
                            > instead of 3). This also made it possible to "revector" to a
                            different
                            > implementation: the low memory was in RAM but my code was in a
                            > ByteSaver EPROM.
                            >
                          • Dan Roganti
                            Geoff wrote: I have copies of the manuals for some of the Dazzler programs: Life, Dazzlemation, Kaleidoscope, Dazzlewriter, Dazzle-Writer 512, and Tic Tac Toe.
                            Message 13 of 23 , Jan 14, 2009
                            • 0 Attachment



                              Geoff wrote:
                              I have copies of the manuals for some of the Dazzler programs: Life,
                              Dazzlemation, Kaleidoscope, Dazzlewriter, Dazzle-Writer 512, and Tic
                              Tac Toe.  If you can't find them elsewhere online, I could probably
                              scan at least some of them.  They include program listings and a
                              simple tape loader program.
                              Geoff,

                              Could you scan the listing for Life ?
                              I don't see it on that bitsavers website.


                              thanks,
                              =Dan
                              -- 
                              [ = http://www2.applegate.org/~ragooman/   ]

                            • oghull
                              ... Sure, but I may not be able to get to it before the weekend. I ll post something when it s ready. Geoff.
                              Message 14 of 23 , Jan 14, 2009
                              • 0 Attachment
                                > Could you scan the listing for Life ?
                                > I don't see it on that bitsavers website.

                                Sure, but I may not be able to get to it before the weekend. I'll
                                post something when it's ready.

                                Geoff.
                              • Dan Roganti
                                Geoff wrote: Could you scan the listing for Life ? I don t see it on that bitsavers website. Sure, but I may not be able to get to it before the weekend. I ll
                                Message 15 of 23 , Jan 14, 2009
                                • 0 Attachment


                                  Geoff wrote:
                                  Could you scan the listing for Life ?
                                  I don't see it on that bitsavers website.
                                      
                                  Sure, but I may not be able to get to it before the weekend.  I'll
                                  post something when it's ready.
                                    


                                  thanks !


                                  =Dan
                                  [ = http://www2.applegate.org/~ragooman/   ]

                                • oghull
                                  ... Done -- www.solivant.com/s-100/cromemco_life.pdf Let me know if you have any problems reading it. Geoff.
                                  Message 16 of 23 , Jan 15, 2009
                                  • 0 Attachment
                                    > Could you scan the listing for Life ?

                                    Done -- www.solivant.com/s-100/cromemco_life.pdf

                                    Let me know if you have any problems reading it.

                                    Geoff.
                                  Your message has been successfully submitted and would be delivered to recipients shortly.