Jump to content

ZackAttack

Members
  • Content Count

    785
  • Joined

Everything posted by ZackAttack

  1. Another option would be to make it configurable so each user can get the font they like best.
  2. They are still in active development. James, I plan to reach out to you again once I have something close to the final release. You were already kind enough to show off the early prototypes and I didn't want to take up anymore of your time until we have a cart worthy version to send you. As @DirtyHairy said, I have been working on a fork with support for bus stuffing. I plan to release it and the source as a universal bootloader once it's fully functional. I'm aiming to have it released before July of this year.
  3. The amount of time it takes to read the address bus and put the corresponding value on the data bus is fairly large. There's only about 400ns (rough estimate) between when the 6502 puts an address value on the bus and when it expects the data value to be returned. Tight polling helps ensure that as soon as the address value changes the new value is worked on right away. If you only polled at a 2.4MHz rate it would eventually be at just the wrong time so that you end up missing the deadline and leave the previous value on the bus too long. There's also the overhead of interrupt processing. That is fairly minimal on ARM, but if you're doing it 2.4 million times per second it's consuming quite a few cycles and leaving very little time for useful work. What I've done with my projects is to anticipate what the next address will be, pre-calculate the corresponding data value, and then poll for it. As soon as the address changes to what I expect I put the data value on the bus and then use the rest of that cycle to do some computations for the next value. This allows time spent on reversing bits for playfield values, looking up colors in a table, masking sprites etc. Regarding DMA. Most banking schemes should be updating pointers or offsets to switch banks because copying a block of data would take too long. If there were block transfers being done, DMA would definitely be a good idea though. If you're asking this because you've encountered a banking scheme which has too much latency it may be the flash cache mechanism. ST claims 0 cycle wait states with their flash accelerators, but I've noticed when debugging firmware with a logic analyzer that there are occasionally visible delays due to flash caching that can cause a missed deadline. It's a bigger problem on the 7800 because the 6502 is clocked faster in that one. Eventually we should run all the critical banking code from SRAM to avoid these caching penalties. I've also noticed that it's dependent on code location in the flash. So making a change to a completely unrelated portion of code can move everything over just enough to cause a problem. Just like in 6502 ASM when you forget to org a lookup table and some changes push it across a page boundary and leave you with an extra cycle in your display kernel all of a sudden.
  4. Yeah, just make sure to leave the system powered on for a minute after running the firmware.bin or until the "update complete" screen is displayed. Whichever comes first. If your firmware is too old to support updates it won't even be able to load the firmware bin file format. Should be safe.
  5. Rather than disabling the carts, you could create a simple rom that puts up some text with a message to the end user and then redirect all their downloads to it. That way they can be informed that the device they purchased is in violation of GPL and where to legally obtain harmony, uno, and plus carts.
  6. I agree with @DirtyHairy, pirated harmony carts is not acceptable and I don't want work with anyone that continues to do so. My stance is either he comes into full compliance for all projects or he's not welcome in any of them. Hopefully he goes with the former since he appears to be capable of making some good contributions to the community. Btw, are we sure that they are in fact pirated? If he designed the board and firmware from scratch that wouldn't be any different than uno and plus cart supporting dpc+ games.
  7. I've been toying around with building my own PCB for the 2600 and I've noticed that the price difference between ENIG gold fingers and hardened gold is quite a bit. Especially in low volumes. Does anyone know if there are existing cart PCBs that have used ENIG for the gold fingers plating and how well they have held up? My concern is that ENIG might seem to work fine for the first couple of years, but will eventually have corrosion or wear problems that only show up after years of service.
  8. That might be a good choice if you have a need for the JTAG functionality in other projects. STM and ESP can use JTAG too, but I have yet to encounter a scenario where it was actually needed or helpful. I just use one of the cheap usb stick type ones from amazon. Just search amazon for st-link v2 and you'll find a bunch of choices like this: https://www.amazon.com/HiLetgo-Emulator-Downloader-Programmer-STM32F103C8T6/dp/B07SQV6VLZ/
  9. Ok, I'll answer my own question in case anyone else wants to go this path. st-link works fine with only the swdio, swclk, and ground connected. I suspect you'd only need the nrst pin connected in the case where PA13 and PA14 are being mapped to alternate functions and are no longer functioning as the SWD port. Since this should never apply to the plus cart the nrst pin can be ignored. Though based on the usb flash instructions the nrst button is the one closer to the usb connector. Perhaps if st-link is ever having connection issues, it's worth a try to reset it. I'm including some pictures with annotations on how I connected the st-link. Excuse the terrible soldering job, it was done in a rush, outside, in the dark, with a flashlight. Once you add the two yellow wires, simply connect them to st-link and a third for ground. I jammed a female hookup wire on there, but an alligator clip or soldered wire would be just as good. Then you can click run/debug from within stm32cubeide, set breakpoints, inspect memory, etc. Don't forget to keep the console powered on when using st-link since it will have no usb cable to power it. I think that's convenient because you don't have to worry about collisions with the console and USB power supplies. Not sure if that matters or not, but I can't imagine it would be a good idea to power the board from both at the same time.
  10. Tested on two more systems tonight. NTSC Light Sixer: works fine NTSC JR: Plus cart firmware did not load. Will need to debug that before I can proceed with DPC+ test.
  11. I want to attach my st-link to the plus cart so I can debug the firmware directly from cubeide and not have to bother with jumpers every time I load a new build. I was able to find the corresponding pins for swdio and swclk but nrst doesn't appear to be brought out to the i/o headers. I assume it's going to one of the buttons on the breakout board. Has anyone had success with flashing/debugging via st-link? Which button is tied to nrst?
  12. How many NTSC systems has this been tested on? How long does it take to reproduce? What does the failure look like? I played chaotic grill for 10-15 minutes on my ntsc 7800 without seeing any issue. If it weren't for the flicker I may have played all night. That game is awesome. I suspect this may be an issue with detecting the wrong address. Specifically this line of code: while ((addr = ADDR_IN) != addr_prev) addr_prev = addr; When working with the uno firmware I noticed that my JR would hold a transient address on the bus long enough for that code to pick it up. So the cart essentially services two memory accesses for each address change in the console. For simpler schemes like a 4K ROM it doesn't really matter because the f407 is so fast, but I could see it being a problem for more complicated ones like this. I'll test with the JR tomorrow and hopefully see a failure.
  13. I just added a permissive license to the strong arm repo. I think that's necessary since most will want to modify something and include it with their games. Unocart firmware has a license on github as well: https://github.com/robinhedwards/UnoCart-2600/blob/master/LICENSE It's worth noting that although the unocart is the only hardware that currently supports this framework, the plan has always been to have a stripped down cheaper cart for publishing games. In that scenario the unocart licensing wouldn't apply since strong arm can bootstrapped directly without going through the uno firmware.
  14. It's been a while since I've played with that, but if I recall correctly. There were two types of failures with the early bus stuffing attempts. The first type was when the cart failed to stuff its value onto the bus. The other type was timing related. Some systems, mine in particular, have some unusual address bus activity in the transition time between valid bus signals. The timings are compliant with the 6502 datasheet as far as I can tell. The problem is that the carts don't have access to any clock signals and have to poll the address bus to determine which rom location to emulate or which address location its stuffing a value into. If a transient value is identified as the next location, the cart will produce the wrong value and probably spend too much time doing so to catch the actual value that follows. I completely bypass this problem in the strong-arm framework by keeping track of where 6502 will be reading next, precalculating the corresponding value, polling for the specific address value, and posting the data onto the bus as soon as the expected address is present on the bus. This has the bonus side effect of leaving more time to do useful work on the ARM core between 6502 bus servicing.
  15. Have you ever tried out this other bus stuffing implementation demo on that problematic junior?
  16. If you look at the unocart firmware you'll find that it's already writing to the flash memory for the larger schemes like 3E when the bin is too big to fit in RAM. So just use that as a template to add flash memory writing support to your own arm project. I think it would be good if we reserved sector 3 for saved game data and defined a simple structure to allow multiple games to share it. It would also be nice to add import/export functionality to the firmware so you could backup to SD or share your games saves. Though if you only care about a stand alone cart, you could use whatever sector you want, any way you want.
  17. Assuming you are referring to the values that are at those locations after power on reset. The firmware would need to be enhanced to restore the original RAM values before handing execution over to the ace file. The current firmware overwrites all the TIA RAM on startup and discards the original values. Might be worth posting something in the official firmware thread.
  18. vcsWrite3() is a WIP implementation of bus stuffing. I plan to implement error detection and correction to account for some systems that have been problematic in the past. When it's done there will be a routine provided that does the error detection and provides the masks and values needed for A, X, and Y. Then vcsSetMasks() would be called during initialization and vcsLd*() would be called for A, X, and Y prior to using vcsWrite3(). Write3() will select STA, STX, STY, or SAX depending on the value being stuffed so that only 6 of the 8 bits need to be overridden by the ARM chip. Which 2 bits aren't stuffed will depend on the results of the error detection.
  19. The ACE file format is used to update the unocart firmware. ACE compatibility is part of the required testing for unocart firmware releases. It's safe to assume that ACE will continue to be supported on unocart. The c/c++ framework itself is pretty self contained and could even be used with other hardware solutions as long as the microcontroller has enough resources. Stella is the main thing you need to take into consideration. For development purposes I have a fork of the stella source that can run ACE/Strong-ARM games. The way this is done is only suitible for development purposes though. I wouldn't expect stella to support this new format until there were enough games released to make it worth while. TLDR; if you use this framework you should expect your game to only be playable on unocart. The entire tech stack is open source. That should minimize the risk of developing for a platform that gets abandoned. If you provide more details about exactly what you're planning on building. I'd be happy to provide more details about how well suited this framework would be.
  20. That's great. I can take care of building a new firmware updater with the new firmware once you're done and also with testing everything.
  21. Have you tried generating a log of all the bus activity while the game is running? I think if you posted a log you'd get some help with figuring out how the customized chip works. You could hack together a data logger with an uno-cart and a Y adapter. Customizing the uno-cart firmware to be a datalogger is fairly trivial and a Y adapter would just require a few connectors, a donor pcb and some patience to solder everything.
  22. You could also position the first copy far enough right so the second copy wraps around to the left side of the screen.
  23. Keep in mind the peripheral clock is typically slower than the core CPU clock. You're correct though. It's possible to get a stable address that is not the next actual address. In practice this isn't really an issue because it's no different than having a really fast rom. There will be some transient values driven on the data bus while the address settles down, but eventually the correct address/data pair are produced and because there's a considerable delay between when the address is valid and the data is read it's always sorted itself out in time. The one exception to this is pitfall 2 because a lot more processing is done for each address and sometimes this can trip it up. I made a custom firmware build that logged the stable addresses to SD card when we were troubleshooting an issue with a specific system. On my 2600 jr it would pick up at least one wrong address for every right address. You could poll for longer but the problem with that is it increases latency and could lead to a failure to service the data bus in time. To get around this problem and allow useful work to be done in place of the address polling I keep track of what the next ROM address would be and wait for the address bus to be set to that before proceeding to update the data bus. This allows the data value to be calculated in advanced and also eliminates servicing any transient address values. The only downside is that you have to emulate enough of the 6502 to know which rom address comes next. For my purposes it's not difficult since I run all my game logic in ARM and only use a few load/store instructions to update the TIA registers. That project is also open source.
  24. Why don't you start posting some graphics? If you provide some screen mockups you'll get feedback on what is and isn't possible with a classic 4/8k game. You'll have a better chance at recruiting programmers or programming it yourself if the game design is well documented and properly matched to the 2600 limitations.
  25. I posted a separate topic with bin herehttp://atariage.com/forums/topic/279712-raycasting-with-bus-stuffing-demo/?fromsearch=1
×
×
  • Create New...