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

Re: [Altair Computer Club] Dazzler Software?

Expand Messages
  • 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 1 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 2 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 3 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 4 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 5 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 6 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 7 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 8 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 9 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 10 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 11 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 12 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 13 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 14 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 15 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.