Jump to content

Search the Community

Showing results for tags '6502'.

More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


  • Atari Systems
    • Atari General
    • Atari 2600
    • Atari 5200
    • Atari 7800
    • Atari Lynx
    • Atari Jaguar
    • Atari VCS
    • Dedicated Systems
    • Atari 8-Bit Computers
    • Atari ST/TT/Falcon Computers
  • Classic Consoles
  • Classic Computing
  • Modern Consoles
  • Gaming General
  • Marketplace
  • Community
  • Community
  • Game Programming
  • Site
  • PC Gaming
  • The Club of Clubs's Discussion
  • I Hate Sauron's Topics
  • 1088 XEL/XLD Owners and Builders's Topics
  • Atari BBS Gurus's Community Chat
  • Atari BBS Gurus's BBS Callers
  • Atari BBS Gurus's BBS SysOps
  • Atari BBS Gurus's Resources
  • Atari Lynx Programmer Club's CC65
  • Atari Lynx Programmer Club's ASM
  • Atari Lynx Programmer Club's Lynx Programming
  • Atari Lynx Programmer Club's Music/Sound
  • Atari Lynx Programmer Club's Graphics
  • The Official AtariAge Shitpost Club's Shitty meme repository
  • The Official AtariAge Shitpost Club's Read this before you enter too deep
  • Arcade Gaming's Discussion
  • Tesla's Vehicles
  • Tesla's Solar
  • Tesla's PowerWall
  • Tesla's General
  • Harmony/Melody's CDFJ
  • Harmony/Melody's DPC+
  • Harmony/Melody's BUS
  • Harmony/Melody's General
  • ZeroPage Homebrew's Discussion
  • Furry Club's Chat/RP
  • PSPMinis.com's General PSP Minis Discussion and Questions
  • PSPMinis.com's Reviews
  • Atari Lynx 30th Birthday's 30th Birthday Programming Competition Games
  • 3D Printing Club's Chat
  • Drivers' Club's Members' Vehicles
  • Drivers' Club's Drives & Events
  • Drivers' Club's Wrenching
  • Drivers' Club's Found in the Wild
  • Drivers' Club's General Discussion
  • Dirtarians's General Discussion
  • Dirtarians's Members' Rigs
  • Dirtarians's Trail Runs & Reports
  • Dirtarians's Wrenching
  • The Green Herb's Discussions
  • Robin Gravel's new blog's My blog
  • Robin Gravel's new blog's Games released
  • Atari Video Club's Harmony Games
  • Atari Video Club's The Atari Gamer
  • Atari Video Club's Video Game Summit
  • Atari Video Club's Discsuuions
  • Star Wars - The Original Trilogy's Star Wars Talk
  • PlusCart User's Bug reports
  • PlusCart User's Discussion
  • DMGD Club's Incoming!
  • DASM's General
  • AtariVox's Topics
  • Gran Turismo's Gran Turismo
  • Gran Turismo's Misc.
  • Gran Turismo's Announcements
  • The Food Club's Food
  • The Food Club's Drinks
  • The Food Club's Read me first!
  • The (Not So) Official Arcade Archives Club's Rules (READ FIRST)
  • The (Not So) Official Arcade Archives Club's Feedback
  • The (Not So) Official Arcade Archives Club's Rumor Mill
  • The (Not So) Official Arcade Archives Club's Coming Soon
  • The (Not So) Official Arcade Archives Club's General Talk
  • The (Not So) Official Arcade Archives Club's High Score Arena
  • Adelaide South Australia Atari Chat's General Chat & Welcome
  • Adelaide South Australia Atari Chat's Meets
  • Adelaide South Australia Atari Chat's Trades & Swaps
  • KC-ACE Reboot's KC-ACE Reboot Forum
  • The Official Lost Gaming Club's Lost Gaming
  • The Official Lost Gaming Club's Undumped Games
  • The Official Lost Gaming Club's Tip Of My Tounge
  • The Official Lost Gaming Club's Lost Gaming Vault
  • The Official Lost Gaming Club's Club Info
  • GIMP Users's Discussion


There are no results to display.

There are no results to display.


  • AtariAge Calendar
  • The Club of Clubs's Events
  • Atari BBS Gurus's Calendar

Find results in...

Find results that contain...

Date Created

  • Start


Last Updated

  • Start


Filter by number of...


  • Start










Custom Status



Currently Playing

Playing Next

Found 50 results

  1. Two months ago I found a SID disassembler at the website of Covert BitOps. I rewrote large parts of it and added support for SAP and NSF (NES) files. It tries to do some simple code-flow analysis to determine code and data blocks. The output is compatible with ATASM. Because I want to avoid it'll bitrot on my harddisk, like so many other of my projects, I decided to post it here. Have fun. Possible improvements (todo-list): * command line option to manually mark blocks as code or data * add emulation engine to better handle self-modifying code * multiple assembly formats (xasm, mads, et cetera) siddasm2.c.gz
  2. I've been reading several threads regarding various hard reset schemes people are using or have recommended and every method seems to be convoluted and complicated to deploy when back in the mid-80's many of my friends with Ataris and myself would simply run a momentary push-button switch through a resistor to pin-40 of the 6502 (Sally) chip that would pull the reset pin low while pressing the button. This always seemed to me to be the most elegant solution and the simplest as well. Since pin-40 of the processor is the RESET pin, logically this would be the right path. Since the pin is pulled high through a resistor already, pulling it low (to ground) through a lower value resistor will cause the processor to reset, thus rebooting the computer. The Atari users in my group of friends never had any failures due to this method of choice for hard resetting the Atari. Does anyone know why other more intricate or complicated methods are the only ones talked about now (methods that use TTL chips and focus on various other chips and pins)??
  3. Has anyone ever tried to run some of the modern CPU benchmarks (like SPECint and SPECfp) on the classic 8-bit (6502, Z80) and 16-bit (68000, 65816) CPUs? My googling has found nothing. (Only thing I could find was a rating for the 68060.) How hard would it be to set something like that up?
  4. Hi! This is my first post here. ​ ​I have created a new computer language, that makes 6502 code. ​Before I release it, it would like to test to make a Atari 2600 program. ​ ​But as I don't have time to learn all about 2600 now, I wounder if there is a assembly program I can translate as a example. After that maybe someone would like to test it for writing their own programs. And I can provide the code for that program that i translate, as a programming example. Does anyone know of some suitable assembly code for this? I worst case I could take some machine code, and translate that. ​ ​Any ideas? And where can I find info about the used fileformat for Atari 2600 emulators? ​ ​ ​
  5. A post was recently made to the Commodore 8-bit forum regarding the game Icebox Plus. It's a slightly different take on Pengo with even easier controls (Joystick only in game). Nonetheless, it is a lot of fun including a nicely managed difficulty ramp. Reason for posting to this forum is the author has made available the entire 6502 assembly language source code for that port which I thought may be of interest to someone.
  6. While I think that the Lynx is just fine with its 6502 CPU, and understand why it didn't get a Motorola 680, I still wonder: What made Atari and Epyx make the final decision to use the MOS 6502 rather than, say, the Zilog Z80b, Intel 8088, or one from Hudsonsoft? What, other than cost possibly, made the 6502 their pick?
  7. Let me introduce myself: I am the original creator and Copyright owner of ULTIMON! I have decided to make this old version (along with its new PDF Manual) available for anyone to download and use completely free of charge. Although it will still remain subject to my Copyright. You may download the original ROM and the new Manual from: https://www.box.com/...jd2zs8pce0saeae The ROM should work for: 600XL (64K), 800XL, 800XLE, 130XE & 65XE. Enjoy! In the near future a MyBIOS compatible version of ULTIMON will be released.
  8. Why did the Game Boy use a Z80 instead of a 6502 like the NES (and the closely related 65816 of the SNES)? Were there any power advantages to the Z80 that would help with battery life? Wouldn't it have made more sense to use a 6502, than they could reuse code and make it easier to port NES games over.
  9. I was trying to do something that my feeble memory thought worked 30 years ago in Mac/65 and not getting any joy in atasm. I'm making macros to act as wrappers to function calls in a library of routines. Then I'm conditionally assembling routines in the library, so if they are not referenced, they don't get included and waste space. I was figuring this would work.... (only important parts included) .macro mFunc ; other stuff happens jsr libFunc .endm ; Later in the main code.... mFunc ; Later.... .if .ref libFunc libFunc ; fun stuff ensues rts .endif This does not work. The .ref does not see the libFunc referenced, so it does not build libFunc. Should this work? Or am I insane? If the forward referenced label doesn't work, how about a declared value in the macro like this?... .macro mFunc DO_FUNC .= 1 ; other stuff happens jsr libFunc .endm ; Later in the main code.... mFunc ; Later.... .if .ref DO_FUNC ; and .def does not work either. libFunc ; fun stuff ensues rts .endif DO_FUNC set in the macro is also not seen. neither .ref or .def sees it. Next fallback plan... DO_FUNC .= 0 ; Later on.... .macro mFunc DO_FUNC .= 1 ; other stuff happens jsr libFunc .endm ; Later in the main code.... mFunc ; Later.... .if DO_FUNC>0 libFunc ; fun stuff ensues rts .endif This (annoyingly) does work. DO_FUNC defined outside the scope of a macro can have its value changed in a macro, and THAT value change is seen by the conditional assembly. Rather not have to throw in a bunch of flags in a header file separate from the library file which is included in the end of the assembly.
  10. The Wikipedia page about the 1292 Advanced Programmable Video System claims it was particularly difficult to program: It made me curious. Did nearly every other processor and microcontroller back in the 1970's default to opcode $00 equals NOP? So far I have found the following: Zilog Z80 and Intel 8080: $00 = NOP (No Operation) Intel 8048 : $00 = NOP (No Operation) RCA 1802: $00 = IDL (Idle) So far, so good. But how about the others? MOS 6502: $00 = BRK (Break, causes an interrupt) GI CP-1610: $0000 = HLT (Halt, not sure what it does but likely not NOP) Motorola 6809: $00 = NEG $nn (not entirely sure about this syntax, but at least NEG) Signetics 2650: $00 = Branch to address in immediate register B (per the Wikipedia article) I failed to look up what the TMS-9900 and the Fairchild F8 do with opcode $00 or $0000. It seems that Motorola 6801/03 doesn't define $00 at all. Likely I have missed some relevant processors and microcontrollers of the time, but it seems like the article describes how a programmer used to Intel or Zilog would be confused about the Signetics. Programmers used to MOS, GI or Motorola may have been confused too, but at least not expecting NOP. Now machine code programming has far more interesting challenges than which instruction equals which value when encoded as binary/hex/decimal data, I would think that works out rather quickly, in particular if you were able to have a cross assembler on some mini computer or similar when developing software for the 1292 APVS series.
  11. I must know. I also would like to know if other parts of the 2600 will use more time if I interact with them. Thanks!
  12. This next section is a big one. Wouldn't it be great if you could test code as you programmed it? Well that's where Code-As-You-Go comes into play. The mode can be accessed with a dedicated button on a keyboard. It's labeled "CAYG." Take a look at this: That's the code as you go screen. On the panel at the right, you can enter the data you want to test. On the upper right of the screen is the address that the code will assemble to. In this example, the written code will compile at address $001404. You could instead have it display which line of the source code the code will go in. First, give the subroutine a name. In this example, we have a routine called "TetrisLFSR." This will be a Motorola 68000 version of the NES Tetris RNG routine. The NES version of Tetris iterates its RNG (a 16-bit LFSR) in the following manner: Set the output bit to the XOR of bits 1 and 9, and right-shift that input into the RNG. We will replicate this routine as we enter the code. For this test, enter the input in d0. We need to enter a 16-bit value. Using a mouse, click on the fourth-to-last digit of the d0 register, then type "7259." The digit highlighted in green is the cursor. Note that the register values are displayed in hexadecimal. If you enter an invalid hexadecimal digit, nothing happens. When you enter the last digit, the cursor stays there. (If it were an A-register, the cursor would be red.) Now, time for the first instruction. Type "move.b", tab, then "d0,d2", and hit Enter (if you hit Space, it will tab for you). When you press Enter, the last line of code you wrote is automatically executed in the CAYG window, and its machine language code appears in the window as well. In M68K assembly, the instruction "move.b d0,d2" is represented by $1400. The screen looks like this: Note that after you typed the code line, that instruction automatically executed. The last byte of d0 is $59, so the last byte of d2 is now also $59. The next two instructions are "move.w d0,d1" and "lsr.w #8,d1". These are necessary to retrieve the upper byte of a 16-bit value in d1. After the second line was typed, d1 became $7259. After the third line, it became $0072. In the machine code box is E049, which is the code for "lsr.w #8,d1." Remember, only the compiled code for the last line you typed appears in the machine code box. Next, we want to take the XOR of bits 1 and 9 of the bytes in d1 and d2. Since 1 and 9 differ by exactly 8, no shifting of either byte is needed. Just XOR the bytes by typing "eor.b d2,d1", then pressing Enter. Register d1 is now equal to $2B, which is the XOR of $72 and $59. It is bit 1 from this value we need to extract and get into the X (extend) flag. To do this, type "lsr.b #2,d1", and press Enter. The value in d1 became $0A. But more importantly, look at the X and C flags. They lit up, so their value is 1. Any flag that is clear appears as white-on-black, while a set flag is indicated by the opposite color scheme. Since the XOR of bits 1 and 9 of our 16-bit value was 1, a 1 will be right-shifted in to get the new RNG value. Here is the last piece of the puzzle. Now that we have our output bit in X (and C), we can use a "roxr" instruction to shift it in. Type "roxr.w #1,d0", and hit Enter. And there you have it. The new RNG value is $B92C. With the ability to see the code execute as you type it, coding will become as easy as pie. You could also toggle register updating off/on, and you could also move your cursor to any line in the code, and press a certain button to step through the code and see the results. After finishing the code, press the CAYG button again. All the code you wrote in the CAYG screen will be placed at the place in the source code you were at when you went to this screen. You can then edit it, delete it, or change it as normal. All in all, the code-as-you-go feature could be a breakthrough for future assemblers. No matter whether it's 6502, M68K, Z80, or anything else, it's the next innovation in coding.
  13. On the Atari 8-Bit Forum, Heaven/TQA asked for help with retrieving an ASCII version of his demo sources in Macro-Assembler XE format. Because I recently wrote a detokenizer for Mac/65, I thought it'd be fun to try this file format too. Here's the result. It successfully detokenizes all the sample .ASM files I found in his zip-file, but I'm sure some functionality is missing (at least three assembler directives). If you stumble upon files that fail, please send them to me and I'll update the detokenizer. Or send me the Macro-Assembler XE manual, so I can add all directives at once. Compile with: gcc -O3 -std=c99 -W -Wall -o demaxe demaxe.c Run with: ./demaxe fubar.asm > fubar.txt Should also work under cygwin/mingw32. If there's interest in a Windows-binary, I might setup a cross-compiler. Leave a message below demaxe.c.gz
  14. While I was browsing some old source code, I frequently stumbled upon MAC/65 tokenized files. Being too lazy to repeatedly start an emulator to convert them to (AT)ASCII and being unable to find a program online to detokenize them, I set out to write such a program myself. With some luck, I found a description of the format in the form of an old Analog Computing article. After that, it was pretty straightforward. Here's the source. Compile with gcc -W -Wall -O3 -o demac65 demac65.c. If you want line numbers, uncomment the printf statement. If you want all lowercase, there's tr(1). Have fun demac65.c.gz
  15. Hi, I wanted to try out using the S: CIO screen editor in Assembler, but I'm not sure I am going about it in the right way. When I do an OPEN, PRINT "Hello World", CLOSE, I get the attached screen, but it has 2 cursors in column 0, and a cursor after the "Hello World". The code is quite simple, and uses the OPEN, PRINT and CLOSE macros from Mac65. *= $5000 JMP PROGRAM_INIT ; ; MAC65 Macro files. Mainly used for I/O Macros ; .INCLUDE "SYSEQU.M65" .INCLUDE "IOMAC.LIB" .INCLUDE "OS.asm" PROGRAM_INIT LDA #<END_OF_PROGRAM_MEMORY STA APPMHI LDA #>END_OF_PROGRAM_MEMORY STA APPMHI+1 LDA #1 STA CRSINH LDA #0 STA LMARGN OPEN 1,12,0,"S:" ; PRINT 1," " LDA #20 STA COLCRS LDA #0 STA COLCRS+1 STA ROWCRS PRINT 1,"Hello World " CLOSE 1 LOOP1 JMP LOOP1 RTS END_OF_PROGRAM_MEMORY *=$2E0 .WORD PROGRAM_INIT I've also attached the ATR containing the executable (T1SET.EXE). Is there any way of getting rid of the extra cursor characters (actually all 3 of them)? I thought they would not be present as I set CRSINH to 1 right at the start of the program. At the moment I am working from Chapter 8 of the Atari System Reference manual by Bob Duhamel - if anyone can point me to any other info on using the S: device from Assembler, that would also be appreciated. The reason I'm looking at this is that I saw this post: and started to wonder about using the S: driver, which I haven't used before (I'm planning on converting the screen I/O in ATR Maker Deluxe - and other programs - to use the S: device, but I want to write some test programs first to make sure it works OK). Also, I'm not sure if I am setting APPMHI correctly, this is required according to the Reference Manual, but not something I can recall using before. Any help would be appreciated! t1set.atr
  16. I am having a small issue with my code. I am trying to get the duck to stop when it reaches the top after hitting the flyaway state. However no matter what I try the code gets ignored. Source Code Relevant section Any of you experts have any ideas on what's going on?
  17. This guy has tried to estimate MIPS on some CPUs from the seventies. http://drolez.com/retro/ That doesn't look too good for the 9900. And maybe performance was further crippled, when comparing computers, with the TI-99/4A shoehorn design including multiplexer, wait states and read before write stuff.
  18. Hi, I'm new here. I am interested in creating a simple 2 player fighting game similar to Street Fighter or Mortal Kombat. I was wondering before I started coding, how feasible this would be due to the VCS's hardware limitations. I have been reading Andrew Davies tutorial series on the forum as well as have some knowledge of 6502 and M68000 assembly.
  19. I rolled up a quick-n-dirty simple retro birthday card for a friend. (No music. Maybe for next year's card.) (And, No, FillInTheBlank is not their actual name. ) Assembly code. Redefined character sets do the animated flames. Display kernel updating colors on every scan line. lots of laziness in evidence. Too lazy to actually do a VBI or DLI. Assembly code is here if anyone is interested: https://github.com/kenjennings/WIP-HBFITB Video is on youTube: https://youtu.be/WLELDFDT3uM
  20. Hi Guys, I have been tracking down an issue in a game I am creating where the my scanline count was going wrong and it was because somehow the decimal flag was being set so a 'sbc' was not as I expected. Currently my work around is doing a 'cld' just before this bit of code but I don't know how it gets set in the first place. I have looked for the obvious and I am not doing a 'sed' anywhere in my code. Does anyone know more about this to advise me how this flag can get set in another way that might help me find the answer? It would be good to set some kind of cognitional breakpoint in stella so I can just find the code that way but I don't know if its possible. Thanks, Mike
  21. Linky only http://www.cast-inc.com/ip-cores/processors/index.html And it lists 6502, Z80 and 68000, perhaps they should also get into making 6502/z80 and 68000 Custom IC's like vic2/3, sid or pokey/antic/c or gtia and ofcourse paula/agnes and denise, glue and shifter/shifter 2 Could be interesting
  22. My software needs to not only detect the presence of a 65C816 CPU (taken care of), but also compute and report the CPU speed. The way I've gone about this (assuming a 6502 for the moment) is to run a block of code which updates a counter while waiting for a full frame to elapse (with DMA off, of course). We know the cycle count of the code block, so armed with the final value of the counter, we can compute the number of cycles per frame. The first thing I ran into (Antic DMA being disabled) is RAM refresh, which I understand takes 9 cycles per scan line. Factoring this into the calculation seemed to yield a result closer to what's expected: i.e. ($9B * 2) * 9 added to the overall cycle count in PAL mode. The figures soon drift wildly off when the CPU is a 65C816, however. I'm not sure if this is down to my misunderstanding the cycle counts of 6502 instructions in emulation mode, or not properly accounting for RAM refresh cycles. I notice that SysInfo computes the CPU speed quite accurately, so are there any special compensations required when trying to work out the speed of a 65C816 CPU running in emulation mode on an A8? Or is there a better way of measuring speed entirely?
  23. The vast majority of the systems in the late 70s and early 80s were built around these 8-bit CPUs. Could anyone with programming or engineering experience from that era chime in with what some of the advantages and disadvantages or each chip were? Which do you think was better? For computing? For gaming? Here's a quick list that I can think of. Please correct me where I'm wrong and add your own that I've missed. Z80: Adam/ColecoVision Sega SG-1000 Sega Master System MSX most early arcade games Game Boy Game Gear Astrocade (Also listed as a coprocessor on many 16-bit arcades/consoles) 6502: Atari 2600 Atari 8-bit computers/5200 Apple II NES/Famicom Atari Lynx Commodore 64 PC Engine/TurboGrafx 16/Duo/Express The Commodore 128 was unique in that it had both a Z80 and a 6502. And what ever happened to Zilong and MOS? Why were they never able to translate their success in the 8-bit market over into the 16-bit market and beyond?
  • Create New...