Quote:
I ran your code in TiEmu, and it crashes with an Address Error (black bar on the top) when I press any key to quit. It does this on the TI-89 and TI-92+. I have the latest OS from the TI site (2.09). I'm a little hesitant to put it on my real 92+ if it's going to crash every time like that.
Oh, really ? It has never crashed here, either on TIEmu or the real 89T HW4 or 89 HW2 
Yeah, if it crashes for you on TIEmu, you'd probably better not send that to your calculator. But I don't understand why...
Quote:
What adapter are your referring to? If you mean an adapter cable to plug the calculator into the soundcard, I actually just have a 3.5mm stereo cable plugged into the soundcard, my TI link cable plugged into the TI-86, and 3 alligator clip cables connecting the two. Yay alligator clips!
I must have a male 3.5mm stereo jack with a wire, and I do have a female 2.5mm stereo jack, which I could solder together... but they're 75 km away from the place where I work during the week 
Re-posting the latest version:
Code: #define USE_TI89
#define USE_TI92P
#define USE_V200
#define MIN_AMS 100
#define OPTIMIZE_ROM_CALLS
#define SAVE_SCREEN
#include <alloc.h>
#include <cert.h>
#include <flash.h>
#include <graph.h>
#include <intr.h>
#include <inttypes.h>
#include <kbd.h>
#include <link.h>
#include <peekpoke.h>
#include <stdio.h>
#include <string.h>
#include <system.h>
static volatile uint32_t int1_ticks = 0;
static volatile uint32_t int5_ticks = 0;
static INT_HANDLER saved_int_1;
static INT_HANDLER saved_int_5;
static uint8_t frame[30];
__attribute__((__regparm__(2))) void send_frame(uint8_t * ptr asm("%a0"), uint16_t len asm("%d0"));
//! New AUTO_INT_1 handler: count ticks, and execute AMS's handler, which handles keyboard reading.
DEFINE_INT_HANDLER(MyInt1)
{
int1_ticks++;
ExecuteHandler(saved_int_1);
}
//! New AUTO_INT_5 handler: count ticks, but don't execute the AMS timers and battery checker at a non-default rate.
DEFINE_INT_HANDLER(MyInt5)
{
int5_ticks++;
send_frame(frame, 13);
//ExecuteHandler(saved_int_5);
}
// Notes:
// * clock -> tip
// * SET bit 0 of 60000E to pull down
// * bit 2 of 60000E SET means pulled down.
// * data -> ring
// * SET bit 1 of 60000E to pull down
// * bit 3 of 60000E SET means pulled down.
// Length is currently limited to 255 bytes.
asm("
.set CLOCK_WRITE_BIT, 0
.set DATA_WRITE_BIT, 1
.set CLOCK_READ_BIT, 2
.set DATA_READ_BIT, 3
| Write clock
.macro PULLDOWN_CLOCK
bset #CLOCK_WRITE_BIT,(%a1)
.endm
.macro PULLUP_CLOCK
bclr #CLOCK_WRITE_BIT,(%a1)
.endm
| Write data
.macro PULLDOWN_DATA
bset #DATA_WRITE_BIT,(%a1)
.endm
.macro PULLUP_DATA
bclr #DATA_WRITE_BIT,(%a1)
.endm
| Write clock and data at the same time
.macro PULLDOWN_BOTH
st.b (%a1)
.endm
.macro PULLUP_BOTH
sf.b (%a1) | clr.b (%a1)
.endm
.macro PULLUP_CLOCK_PULLDOWN_DATA
move.b #0x2,(%a1)
.endm
.macro PULLDOWN_CLOCK_PULLUP_DATA
move.b #0x1,(%a1)
.endm
| Read clock / data / both
.macro READ_CLOCK
btst #CLOCK_READ_BIT,(%a1)
.endm
.macro READ_DATA
btst #DATA_READ_BIT,(%a1)
.endm
.macro READ_BOTH dest
move.b (%a1),dest
.endm
.macro SEND_BIT
| Clock high for 17 µs, low for 35 µs, high for 52 µs
| Data = input bit for 52 µs, high for 52 µs
bclr #CLOCK_WRITE_BIT,%d2
move.b %d2,(%a1)
moveq #19,%d0
0:
dbf %d0,0b
bset #CLOCK_WRITE_BIT,%d2
move.b %d2,(%a1)
moveq #39,%d0
1:
dbf %d0,1b
PULLUP_BOTH
move.b %d2,(%a1)
moveq #59,%d0
2:
dbf %d0,2b
.endm
.text
.even
.globl send_frame
send_frame:
move.w %d3,-(%sp)
| Direct link I/O wire access
lea 0x60000E,%a1
| Compute checksum
| TODO: compute checksum incrementally !
move.w %d0,%d3
lea 12(%a0),%a0
sub.w #12+1,%d0 | len
| TODO: handle improper lengths
moveq #0,%d1 | val
moveq #0,%d2 | accumulator for checksum
loop_checksum:
move.b (%a0)+,%d1
add.w %d1,%d2
dbf %d0,loop_checksum
| Write checksum in little-endian form
move.b %d2,(%a0)
lsr.w #8,%d2
move.b %d2,1(%a0)
| Jamming phase: ~9.8ms
PULLDOWN_CLOCK_PULLUP_DATA
| dbf timings: 10 CPU clock cycles when cc false and branch taken, i.e. <~ 1 us @ ~12 MHz.
| We need to loop ~12K times.
move.w #12000-1,%d0
loop_jamming:
dbf %d0,loop_jamming
PULLUP_BOTH
| Get back to the beginning of the frame
suba.w %d3,%a0
| Add checksum length
addq.w #2-1,%d3
loop_send_bytes:
bsr.s send_byte
dbf %d3,loop_send_bytes
| TODO for directed frames: actually listen for the checksum...
| move.w #(182+60+50+8*(20+40+60)),%d0
|loop_wait_checksum:
| dbf %d0,loop_wait_checksum
| TODO: ACK/NAK the checksum if it's a directed frame
| lea ack(%pc),%a0
| bsr.s send_byte
move.w (%sp)+,%d3
rts
.text
.even
send_byte:
move.w %d3,-(%sp)
| Both high for 52 + 110 µs
PULLUP_BOTH
move.w #182-1,%d0
loop1_byte:
dbf %d0,loop1_byte
| Both low for 52 µs
PULLDOWN_BOTH
moveq #60-1,%d0
loop2_byte:
dbf %d0,loop2_byte
| Both high for 43 µs
PULLUP_BOTH
moveq #50-1,%d0
loop3_byte:
dbf %d0,loop3_byte
move.b (%a0)+,%d1
moveq #8-1,%d3
loop_send_bit:
| From bit 7 (MSB) down to bit 0 (LSB)
rol.b #1,%d1 | Leftmost bit goes to C
| We want the data line to have the same state as the input bit, so we want the DATA_WRITE_BIT to be not(input bit)
| if carry clear (i.e. input bit is 0) then pull down (i.e. set bit) else pull up (i.e. clear bit)
| if carry set (i.e. input bit is 1) then pull up (i.e. clear bit) else pull down (i.e. set bit)
| Sxx is [if condition xx = true then 0xFF -> dest else 0 -> dest]
scc %d2
SEND_BIT
dbf %d3,loop_send_bit
move.w (%sp)+,%d3
rts
|
|ack:
| .byte 0xAA
| .even
");
//! Where all the fun starts...
void _main(void) {
short saved_int5_rate = PRG_getRate();
HANDLE cert_handle;
unsigned long cert_len;
CFILE context;
CERT_FIELD field;
unsigned short i;
uint8_t calc_id[5];
int1_ticks = 0,
int5_ticks = 0;
// Retrieve unique calculator ID, the proper (but large and slow) way.
// The improper way, with very little chance of false positives, would be searching for 0A 15 <5 bytes> 0A 2D 40.
FL_getCert(&cert_handle, &cert_len, FALSE);
if (cert_handle != H_NULL && cert_len > 0) {
unsigned char *ptr = HeapDeref(cert_handle);
copen (&context, ptr, cert_len);
// Root cert field of the Certificate memory.
if (cfindfield (&context, 0x330, &field)) {
copensub (&context, &field);
// Serial number field.
if (cfindfield (&context, 0xA10, &field)) {
copensub(&context, &field);
memcpy(calc_id, context.Pos, 5);
}
}
HeapFree(cert_handle);
}
saved_int_1 = GetIntVec(AUTO_INT_1);
SetIntVec(AUTO_INT_1, MyInt1);
saved_int_5 = GetIntVec(AUTO_INT_5);
SetIntVec(AUTO_INT_5, MyInt5);
// Disable all linking interrupts
pokeIO(0x60000C, 0x60);
// Setup frame
memcpy(frame, calc_id, 5); // Sender ID
_memset(frame+5, 0, 5); // Receiver ID, 0 for broadcast
frame[10] = 0x01; // Length, little endian 0x0001
frame[11] = 0x00;
frame[12] = 0x01; // Data: 0x01: first part of the handshake used in Flourish & Netpong.
// Let's fire AUTO_INT_5 at ~109.95 Hz (very close to the 110 Hz used by CALCnet)
/*PRG_setStart(257 - 149);
PRG_setRate(0);
// Check AUTO_INT_5 frequency against AUTO_INT_1 frequency (well-defined to 256 Hz on HW1).
while (!(_rowread(0xF000))) {
if ((int1_ticks % 1024) == 0) {
printf_xy(0, 0, "%" PRIu32 " %" PRIu32, int1_ticks, int5_ticks);
}
}
PRG_setRate(saved_int5_rate);*/
while (!(_rowread(0xF000)));
SetIntVec(AUTO_INT_1, saved_int_1);
SetIntVec(AUTO_INT_5, saved_int_5);
OSLinkReset();
GKeyFlush();
}
Compiled with a Makefile that reads as follows:
Code: $ cat Makefile
all: calcnet.c
<tab>tigcc -Os -Wall -W -Wwrite-strings -Wshadow -mregparm=5 -fomit-frame-pointer -ffunction-sections -fdata-sections -fmerge-all-constants --optimize-code --cut-ranges --reorder-sections --merge-constants -Wa,--all-relocs -mno-bss -o calcnet calcnet.c
That calculator was teh awexome.