ShuriZma
/
bsnes
mirror of https://github.com/bsnes-emu/bsnes.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
bsnes/higan/sfc/controller/usart/usart.hpp

41 lines
769 B
C++
Raw Normal View History

Update to v086r04 release. byuu says: There will probably be a series of small WIPs as I experiment here. snes/controller/serial is now snes/controller/uart. Asynchronous serial communications, typically capped at 57,600 baud. snes/controller/usart is new. It aims to emulate the SNES connected to a Teensy++ board, and can easily handle 524,288 baud. And much more importantly, it's synchronous, so there are no timing issues anymore. Just bit-bang as fast as you can. Right now, the USART code is just enough for SNES->PC to transfer data to ... well, nothing yet. Unless anyone is actually using the UART stuff, I'll be removing it once the USART is totally up and running. No sense maintaining code that is 10x slower, more error prone, and used by nobody. Note: this is all thanks to blargg being absolutely amazing.
2012-02-25 08:49:27 +00:00
struct USART : Controller, public library {
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
void enter();
Update to v087r02 release. byuu says: Changelog: - extended USART with quit(), readable(), writable() [both emulation and hardware] - quit() returns true on hardware when Ctrl+C (SIGINT) is generated (breaks main loop); no effect under emulation yet (hard to simulate) - readable() returns true when data is ready to be read (non-blocking support for read()) - writable() returns true when data can be written (non-blocking support for write()) [always true under emulation, since we have no buffer size limit]
2012-03-10 12:47:19 +00:00
bool quit();
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
void usleep(unsigned milliseconds);
Update to v087r02 release. byuu says: Changelog: - extended USART with quit(), readable(), writable() [both emulation and hardware] - quit() returns true on hardware when Ctrl+C (SIGINT) is generated (breaks main loop); no effect under emulation yet (hard to simulate) - readable() returns true when data is ready to be read (non-blocking support for read()) - writable() returns true when data can be written (non-blocking support for write()) [always true under emulation, since we have no buffer size limit]
2012-03-10 12:47:19 +00:00
bool readable();
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
uint8 read();
Update to v087r02 release. byuu says: Changelog: - extended USART with quit(), readable(), writable() [both emulation and hardware] - quit() returns true on hardware when Ctrl+C (SIGINT) is generated (breaks main loop); no effect under emulation yet (hard to simulate) - readable() returns true when data is ready to be read (non-blocking support for read()) - writable() returns true when data can be written (non-blocking support for write()) [always true under emulation, since we have no buffer size limit]
2012-03-10 12:47:19 +00:00
bool writable();
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
void write(uint8 data);
Update to v086r04 release. byuu says: There will probably be a series of small WIPs as I experiment here. snes/controller/serial is now snes/controller/uart. Asynchronous serial communications, typically capped at 57,600 baud. snes/controller/usart is new. It aims to emulate the SNES connected to a Teensy++ board, and can easily handle 524,288 baud. And much more importantly, it's synchronous, so there are no timing issues anymore. Just bit-bang as fast as you can. Right now, the USART code is just enough for SNES->PC to transfer data to ... well, nothing yet. Unless anyone is actually using the UART stuff, I'll be removing it once the USART is totally up and running. No sense maintaining code that is 10x slower, more error prone, and used by nobody. Note: this is all thanks to blargg being absolutely amazing.
2012-02-25 08:49:27 +00:00
uint2 data();
void latch(bool data);
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
Update to v086r04 release. byuu says: There will probably be a series of small WIPs as I experiment here. snes/controller/serial is now snes/controller/uart. Asynchronous serial communications, typically capped at 57,600 baud. snes/controller/usart is new. It aims to emulate the SNES connected to a Teensy++ board, and can easily handle 524,288 baud. And much more importantly, it's synchronous, so there are no timing issues anymore. Just bit-bang as fast as you can. Right now, the USART code is just enough for SNES->PC to transfer data to ... well, nothing yet. Unless anyone is actually using the UART stuff, I'll be removing it once the USART is totally up and running. No sense maintaining code that is 10x slower, more error prone, and used by nobody. Note: this is all thanks to blargg being absolutely amazing.
2012-02-25 08:49:27 +00:00
USART(bool port);
~USART();
private:
bool latched;
bool data1;
bool data2;
Update to v087r01 release. byuu says: Changelog: - fixes ARM core unaligned memory reads (fixes HNMS2 AI, hopefully completely, we'll see though) [Cydrak] - ARM 40000010 writes are now connected to d2 rather than the timer - ARM bus_readbyte() removed (would love to do the same for writebyte if we can ... then we can drop back to bus_read + bus_write only) - USART with IObit set acts as a regular gamepad now (don't have this hooked up with real hardware, but oh well, it's technically possible so there's that) - OpenGL/GLX will use 30-bit when you have a 30-bit display; no need for config file video.depth anymore
2012-03-10 12:37:36 +00:00
unsigned counter;
Update to v086r04 release. byuu says: There will probably be a series of small WIPs as I experiment here. snes/controller/serial is now snes/controller/uart. Asynchronous serial communications, typically capped at 57,600 baud. snes/controller/usart is new. It aims to emulate the SNES connected to a Teensy++ board, and can easily handle 524,288 baud. And much more importantly, it's synchronous, so there are no timing issues anymore. Just bit-bang as fast as you can. Right now, the USART code is just enough for SNES->PC to transfer data to ... well, nothing yet. Unless anyone is actually using the UART stuff, I'll be removing it once the USART is totally up and running. No sense maintaining code that is 10x slower, more error prone, and used by nobody. Note: this is all thanks to blargg being absolutely amazing.
2012-02-25 08:49:27 +00:00
uint8 rxlength;
uint8 rxdata;
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
vector<uint8> rxbuffer;
Update to v086r04 release. byuu says: There will probably be a series of small WIPs as I experiment here. snes/controller/serial is now snes/controller/uart. Asynchronous serial communications, typically capped at 57,600 baud. snes/controller/usart is new. It aims to emulate the SNES connected to a Teensy++ board, and can easily handle 524,288 baud. And much more importantly, it's synchronous, so there are no timing issues anymore. Just bit-bang as fast as you can. Right now, the USART code is just enough for SNES->PC to transfer data to ... well, nothing yet. Unless anyone is actually using the UART stuff, I'll be removing it once the USART is totally up and running. No sense maintaining code that is 10x slower, more error prone, and used by nobody. Note: this is all thanks to blargg being absolutely amazing.
2012-02-25 08:49:27 +00:00
uint8 txlength;
uint8 txdata;
Update to v086r05 release. byuu says: USART implements reading and writing, but I don't yet have code to test SNES reading yet. So ... obviously I need to do that next. Went ahead and required nall::function, so the modules will have to be C++11. I don't see anyone else making these, and it avoids the annoyance of deducing the correct controller port based on dynamic casting the active thread. Apparently a library can have a main() function to no ill effect, so there's no need for USART_HARDWARE. Same exact code with different flags will make the binary and the library.
2012-02-25 08:52:42 +00:00
vector<uint8> txbuffer;
Update to v087r02 release. byuu says: Changelog: - extended USART with quit(), readable(), writable() [both emulation and hardware] - quit() returns true on hardware when Ctrl+C (SIGINT) is generated (breaks main loop); no effect under emulation yet (hard to simulate) - readable() returns true when data is ready to be read (non-blocking support for read()) - writable() returns true when data can be written (non-blocking support for write()) [always true under emulation, since we have no buffer size limit]
2012-03-10 12:47:19 +00:00
function<void (
function<bool ()>, //quit
function<void (unsigned)>, //usleep
function<bool ()>, //readable
function<uint8 ()>, //read
function<bool ()>, //writable
function<void (uint8)> //write
)> init;
Update to v086r07 release. byuu says: USART improvements. The clock pulse from reading data() drives both reading and writing. Also added a usart_init() to bind the initializer functions, so all you need now is: extern "C" usartproc void usart_main() { ... } And inside, you use usart_read(), usart_write(), etc. So we can add all the new functions we want (eg I'd like to have usart_readable() to check if data is available) without changing the entry point signature. blargg enhanced his Teensy driver to ignore frame error reads, as well.
2012-02-25 09:12:08 +00:00
function<void ()> main;
Update to v086r04 release. byuu says: There will probably be a series of small WIPs as I experiment here. snes/controller/serial is now snes/controller/uart. Asynchronous serial communications, typically capped at 57,600 baud. snes/controller/usart is new. It aims to emulate the SNES connected to a Teensy++ board, and can easily handle 524,288 baud. And much more importantly, it's synchronous, so there are no timing issues anymore. Just bit-bang as fast as you can. Right now, the USART code is just enough for SNES->PC to transfer data to ... well, nothing yet. Unless anyone is actually using the UART stuff, I'll be removing it once the USART is totally up and running. No sense maintaining code that is 10x slower, more error prone, and used by nobody. Note: this is all thanks to blargg being absolutely amazing.
2012-02-25 08:49:27 +00:00
};