The project is complete, all code was tidied and presented in the project report (available on the Final Year Project page), and instructions on its use was added along with pre-compiled versions and all libraries necessary to do compilation. Note that if you are only interested in using the GBA serial port, you might do better to look at my Game Boy Advance page, which includes pre-compiled versions of CommsProbe and RS232 Terminal programs, along with their relevant instructions.

// BitTest - initialize two variables and output the
//			 results of applying the ~, &, | and ^
//			 operations
 
#include <iostream.h>
 
char* toBinary(int n){
	static char sResult[(sizeof(n)*8)];	// static so the return doesn't point to a local var
 
	// Use bit-wise AND to check if the LSB of n is set, and place into
	// our string accordingly (filling right->left due to numerical significance)
	for(int i=sizeof(sResult); i>=0; i--){
		sResult[i] = (n & 1) ? '1' : '0' ;
		n >>= 1;
	}
 
	return sResult;	// Return a pointer
}
 
int main(int nArg, char* pszArgs[]){
 
	//initialize two arguments
	int nArg1 = 0x0f0f;
	int nArg2 = 0xf0f0;
 
	//now perform each operation in turn
	//first the unary NOT operator
	cout << "nArg1		= b" << toBinary(nArg1) << endl;
	cout << "nArg2		= b" << toBinary(nArg2) << endl;
	cout << "~nArg1		= b" << toBinary(~nArg1) << endl;
	cout << "~nArg2		= b" << toBinary(~nArg2) << endl;
 
	//now the binary operators
	cout << "nArg1 & nArg2	= b" << toBinary(nArg1 & nArg2) << endl;
	cout << "nArg1 | nArg2	= b" << toBinary(nArg1 | nArg2) << endl;
	cout << "nArg1 ^ nArg2	= b" << toBinary(nArg1 ^ nArg2) << endl;
}

#define false 0
#define true 1
 
#include <mygba.h>
#include "general-purpose-comms.h"
 
short SC, SD, SI, SO, IO;
int data;
 
MULTIBOOT
int main(void)
{
    ham_Init();
    ham_InitText(0);
 
    SC = SD = SI = SO = IO = 0;
    while(1)
    {
        if(F_CTRLINPUT_LEFT_PRESSED) SC=(SC+1)%2;
        if(F_CTRLINPUT_RIGHT_PRESSED) SD=(SD+1)%2;
        if(F_CTRLINPUT_B_PRESSED) SI=(SI+1)%2;
        if(F_CTRLINPUT_A_PRESSED) SO=(SO+1)%2;
 
        if(F_CTRLINPUT_L_PRESSED) IO=1;
        if(F_CTRLINPUT_R_PRESSED) IO=0;
 
        set_comms(SC, SD, SI, SO, IO);
 
        int i=0;
        while(i<250000)i++;
    }
}

Where mygba.h is the Ham library function and general-purpose-comm.h is as follows:

#ifndef SIO_MULTIPLAYER_H
#define SIO_MULTIPLAYER_H 1
 
//RCNT is used for mode selection
#define R_RCNT  *(volatile u16*) 0x4000134
 
#include <stdio.h>
 
/* GBAtek 1.4:
134h - RCNT (R) - SIO Mode, usage in GENERAL-PURPOSE Mode (R/W)
Interrupts can be requested when SI changes from HIGH to LOW, as General Purpose mode does
not require a serial shift clock, this interrupt may be produced even when the GBA is in
Stop (low power standby) state.
 
  Bit   Expl.
  0     SC Data Bit         (0=Low, 1=High)
  1     SD Data Bit         (0=Low, 1=High)
  2     SI Data Bit         (0=Low, 1=High)
  3     SO Data Bit         (0=Low, 1=High)
  4     SC Direction        (0=Input, 1=Output)
  5     SD Direction        (0=Input, 1=Output)
  6     SI Direction        (0=Input, 1=Output, but see below)
  7     SO Direction        (0=Input, 1=Output)
  8     Interrupt Request   (0=Disable, 1=Enable)
  9-13  Not used
  14    Must be "0" for General-Purpose Mode
  15    Must be "1" for General-Purpose or JOYBUS Mode
 
SI should be always used as Input to avoid problems with other hardware which does not
expect data to be output there.
*/
 
// Accept a string input of 0 and 1 chars
void set_comms(short SC, short SD, short SI, short SO, short IO){
    u16 data;
    data = (1*SC) + (2*SD) + (4*SI) + (8*SO);
    data = data + (IO * 0xf0);  // Set all pins to IO (1=Out, 0=In)
    data = data + 0x8000;       // Set general purpose mode ('10' MSB-LSB)
 
    R_RCNT = data;
 
    char st[100];
    sprintf(st,"[%04x]",R_RCNT);
    ham_DrawText(1,1, st);
 
    if(IO) ham_DrawText(1,2, "Output"); else ham_DrawText(1,2, "Input ");
 
    if(0x1 & R_RCNT) ham_DrawText(1,11,"SC"); else ham_DrawText(1,11,"--");
    if(0x2 & R_RCNT) ham_DrawText(5,11,"SD"); else ham_DrawText(5,11,"--");
    if(0x4 & R_RCNT) ham_DrawText(10,11,"SI"); else ham_DrawText(10,11,"--");
    if(0x8 & R_RCNT) ham_DrawText(15,11,"SO"); else ham_DrawText(15,11,"--");
}
 
#endif

NB, has occasional problems with interrupt-driven progress indicator at present, so it's been disabled.

#include "mygba.h"
 
MULTIBOOT
 
u32 count=0;
 
void interrupt();
char* toBinary(u8 n);
 
int main(void)
{
    ham_Init();
    ham_InitText(0);
    ham_InitPad();
 
 
    // Setup the keypad interrupt register
    R_CTRLINT=
        256+    // Button R
        512+    // Button L
        4+      // Select
        16384+  // Enable interrupt flag
        32768   // Enable logical AND mdoe (all button required)
        ;
 
    // Enable keypad interrupt handling
    ham_StartIntHandler(INT_TYPE_KEY,&interrupt);
 
    ham_DrawText(1,1,"Press A to sleep");
    ham_DrawText(1,2,"Press L & R & Select to wake");
 
    while(1)
    {
        ham_UpdatePad();
 
        if(Pad.Pressed.A)
        {
            // BIOS 'Stop' command (turn everything off until interrupted)
            asm volatile("swi 0x30000");
        }
    }
 
    return 0;
}
 
 
void interrupt()
{
   count++;
   ham_DrawText(1,3,"%d",count);
   return;
}
 
char* toBinary(u8 n){
	static char sResult[(sizeof(n)*8)];	// static so the return doesn't point to a local var
 
	// Use bit-wise AND to check if the LSB of n is set, and place into
	// our string accordingly (filling right->left due to numerical significance)
	int i=sizeof(sResult);
    while(i>=0){
		sResult[i] = (n & 1) ? '1' : '0' ;
		n >>= 1;
		i--;
	}
 
	return sResult;	// Return a pointer
}

Written to solve problems with my brother's GBA cart (which was losing his save game to Fire Emblam because he plays too quickly).

This is designed to use a Multi-Boot v2 cable (often shortened to MBv2) and copies to/from the PC as well as displaying a menu on the PC which requires user input to proceed.

#include <mygba.h>
#include "mbv2lib.c"
 
MULTIBOOT
 
int i = 0;
const int SRAM_size = 65536;
 
void displayProgress();
 
int main (void)
{
    ham_Init();
    ham_InitText(0);
    ham_DrawText(1,1,"Program started\n");
 
    char c;
    int l = 1;
    FILE fp = 0;
 
    dprintf("Program Started.\n");
    dprintf("Choose:\n");
    dprintf("c : Complete (GBA->before.bin, sram.bin->GBA, verify, GBA->after.bin)\n");
    dprintf("b : Backup (to sram.bin) and verify\n");
    dprintf("B : Backup (to sram.bin)\n");
    dprintf("v : Verify (against sram.bin)\n");
    dprintf("r : Restore (from sram.bin) and verify\n");
    dprintf("R : Restore (from sram.bin)\n");
    dprintf("\n");
 
    // Get character from PC keyboard
    c = dgetch ();
 
    dprintf("Setting SRAM waitstate\n");
    R_WAITCNT = 3;  // Set SRAM wait state for reliable reading/writing
 
    // Setup a timer and interrupt for displaying progress indicators
    M_TIM0CNT_SPEED_SELECT_SET(1);     // increment timer count every 3,841ms
    M_TIM0COUNT_SET(3);                 // Count up to this number
    M_TIM0CNT_TIMER_START;
    M_TIM0CNT_IRQ_ENABLE;               // This timer can trigger interrupts
 
    // Disabled as it's randomly causing the program to hang
    //ham_StartIntHandler(INT_TYPE_TIM0,&displayProgress);
 
    // Backup
    if(c == 'c' || c == 'b')
    {
        // Copy SRAM or Flash backup to PC
        switch(c){
            case 'c':
                ham_DrawText(1,++l,"Backing up SRAM (before.bin)");
                dprintf("\nCopying SRAM to before.bin\n");
                fp = dfopen("before.bin","wb");
                break;
            case 'B':
            case 'b':
                ham_DrawText(1,++l,"Backing up SRAM (sram.bin)");
                dprintf("\nCopying SRAM to sram.bin\n");
                fp = dfopen("sram.bin","wb");
                break;
        }
        for (i = 0; i != SRAM_size; i++)
        {
           dfputc(*(unsigned char *)(i + 0xE000000), fp);
        }
        ham_DrawText(1,++l, "Done");
        dfclose(fp);
        dprintf("Done.\n");
    }
 
    // Restore
    if(c == 'c' || c == 'r' || c == 'R')
    {
        // Copy PC to SRAM
        ham_DrawText(1,++l,"Restoring SRAM (sram.bin)");
        dprintf("\nWriting sram.bin to GBA...\n");
        dprintf("Opening file...");
        fp = dfopen("sram.bin","rb");
        dprintf(" Done.\n");
        dprintf("Entering loop.\n");
 
        for (i = 0; i != SRAM_size; i++)
        {
            *(unsigned char *)(i + 0xE000000) = dfgetc (fp);
        }
        dprintf("End of loop, closing file...");
        dfclose(fp);
        dprintf("Done.\n");
        dprintf("Writing phase complete.\n");
        ham_DrawText(1,++l,"Done");
    }
 
    // Verify
    if(c == 'c' || c == 'b' || c == 'r' || c == 'v')
    {
        ham_DrawText(1,++l,"Verifying SRAM (sram.bin)");
        dprintf("\nVerifying SRAM against sram.bin\n");
        dprintf("Opening file...");
        fp = dfopen("sram.bin","rb");
        dprintf(" Done.\n");
        dprintf("Entering loop.\n");
 
        int errors = 0;
        for (i = 0; i != SRAM_size; i++)
        {
            // File char != SRAM char
            if(dfgetc (fp) != *(unsigned char *)(i+0xE000000))
            {
                errors++;
            }
       }
       dprintf("End of loop, closing file...");
       dfclose(fp);
       dprintf("Done.\n");
 
       if(errors)
       {
            ham_DrawText(1,++l,"%d bytes failed verification",errors);
            dprintf("%d bytes failed verification.\n", errors);
       }
       else
       {
            ham_DrawText(1,++l,"Verify OK!");
            dprintf("Verify OK!\n");
       }
    }
 
    // Backup to after.bin
    if(c == 'c')
    {
        ham_DrawText(1,++l,"Backing up SRAM (after.bin)");
        dprintf("\nCopying current SRAM to after.bin\n");
        fp = dfopen("after.bin","wb");
        for (i = 0; i != SRAM_size; i++)
        {
           dfputc(*(unsigned char *)(i + 0xE000000), fp);
        }
        ham_DrawText(1,++l, "Done backing up SRAM");
        dfclose(fp);
        dprintf("Done.\n");
    }
 
    // Remove interrupt to ensure clean restart
    ham_StopIntHandler(INT_TYPE_TIM0);
    M_TIM0CNT_TIMER_STOP;
    M_TIM0CNT_IRQ_DISABLE;
 
    displayProgress();  // Avoid the progress showing '98 percent done' etc
 
    ham_DrawText(1,++l,"Program completed");
    dprintf("\nProgram complete. Press any key to restart\n\n\n");
    dgetch ();
 
    return 0;
}
 
void displayProgress()
{
    M_INTMST_DISABLE;   // Disable interrupts
 
    ham_DrawText(1,19,"%d percent done.  ", i / (SRAM_size/100));
 
    M_INTMST_ENABLE;    // Re-Enable interrupts
}

where mbv2lib.c is

#define __ANSI_NAMES 0
//
// v1.40 - Initial release.
// v1.41 - Put received keyboard & file data in separate buffers
//         to prevent mixing of data during simultaneous use.
//         Added dfprintf library function.
// v1.42 - Fixed bug in dfputc() where escape characters caused
//         character 0x01 to be sent to console. Thanks to
//         Tim Schuerewegen for finding this bug.
//
//  MB v1.41 or later pc software is required to use this library
// software.
//
// NOTE: THIS LIBRARY USES GLOBAL INITIALIZED DATA SO YOU MUST USE
// A CRT0.S AND A LINKER SCRIPT THAT SUPPORTS THIS AS WELL. GET
// CRTLS V1.1 OR LATER FROM HTTP://www.devrs.com/gba FOR PROPER SUPPORT.
//
// The following library functions are supported:
//
// Library name   Standard Name      Function
//   dprintf        printf       Print a string on PC console.
//   dputchar       putchar      Print a char on PC console.
//   dgetch         getch        Get a char from PC keyboard.
//   dkbhit         kbhit        Return 1 if PC keyboard char is ready.
//
//   dfopen         fopen        Open PC file.
//   dfclose        fclose       Close PC file.
//   dfprintf       fprintf      Print a string to PC file.
//   dfgetc         fgetc        Get char from PC file.
//   dfputc         fputc        Write a char to PC file.
//   drewind        rewind       Set file pointer to start of file.
//
// If you wish to use the standard naming conventions
// rather than the library names then change "__ANSI_NAMES 0"
// to "__ANSI_NAMES 1" instead.
//
// Notes:
//
//  Currently only ONE file may be open at a time.
//
//  If you are sending raw binary data to a PC file, use
//  dfputc instead of dfprintf. Dfprintf will insert
//  carriage return characters before linefeed characters
//  on the PC side if the PC console software is running on
//  dos/windows for proper text formatting.
//
//  If you are missing some .h files during compile than get
// 'arminc.zip' from http://www.devrs.com/gba in the
//  Apps / C Compilers section.
//
// Example command line:
//    mb -s file.mb -c -w 50 -x 255 -m
//
//  In this example, after transferring "file.mb" to the GBA,
// the PC goes into console/file server mode (-c) and also
// shows all of the file open/file close/fgetc/fputc commands
// (-m) on screen. The -w value should be a large enough value
// where the -s is reliable and the -x value should be a large
// enough value where the -c is reliable with the GBA.
//
//      [Sending a file & console mode each have
//       their own delay settings because they
//       each use a different method for transferring
//       data. Each method is about ideal for it's
//       application.]
//
// Example GBA Code:
//
//  #include "mbv2lib.c"
//
//  int main (void)
//    {
//
//    int i,j,k;
//    FILE fp;
//
//    dprintf ("Hello world!");
//
//    // Get character from PC keyboard
//    i = dgetch ();
//
//    // Copy SRAM or Flash backup to PC
//    fp = dfopen("sram.bin","wb");
//    for (i = 0; i != 0x8000; i++)
//       dfputc(*(unsigned char *)(i + 0xE000000), fp);
//    dfclose(fp);
//
//    // Copy PC to SRAM
//    fp = dfopen("sram.bin","rb");
//    for (i = 0; i != 0x8000; i++)
//       *(unsigned char *)(i + 0xE000000) = dfgetc (fp);
//    dfclose(fp);
 
//    // Read data from file
//    fp = dfopen ("foo.bin", "rb");
//    i = dfgetc (fp);
//    j = dfgetc (fp);
//    k = dfgetc (fp);
//    dfclose (fp);
//
//    }
 
// Data transfer format
// --------------------
//
// PC -> GBA Comms:
// Raw data is PC File read data.
// ESCCHR 0x00 = nada (used for input polling)
// ESCCHR 0x01 = Escape character from PC file read
// ESCCHR 0x08 0x?? = Keyboard read data
//
//
// GBA -> PC comms
// Raw data is console print data.
// ESCCHR = escape sequence
// ESCCHR 0x00 = nada (used for input polling)
// ESCCHR 0x01 = Escape character for console print
// ESCCHR 0x02 = file open (gba -> PC)
// ESCCHR 0x03 = file close (gba -> PC)
// ESCCHR 0x04 = fgetc (gba -> PC)
// ESCCHR 0x05 0x?? = fputc (gba -> PC)
// ESCCHR 0x06 = rewind (gba -> PC)
// ESCCHR 0x07 = fputc processed (gba -> pC) (Add CR before LF char if win/DOS machine)
 
#define FILE int
 
// Uncomment the following line to define the following types if needed
//#define INC_SHORT_NAME_TYPES 1
 
#ifdef INC_SHORT_NAME_TYPES
 typedef     volatile unsigned char           vu8;
 typedef     volatile unsigned short int      vu16;
 typedef     volatile unsigned int            vu32;
 typedef     volatile unsigned long long int  vu64;
 
 typedef     unsigned char           u8;
 typedef     unsigned short int      u16;
 typedef     unsigned int            u32;
 typedef     unsigned long long int  u64;
 
 typedef     signed char             s8;
 typedef     signed short int        s16;
 typedef     signed int              s32;
 typedef     signed long long int    s64;
#endif
 
#ifdef INC_REG_DEFS
 #define REG_BASE        0x4000000
 #define REG_SIOCNT      (REG_BASE + 0x128)  // Serial Communication Control
 #define REG_SIODATA8    (REG_BASE + 0x12a)  // 8bit Serial Communication Data
 #define REG_RCNT        (REG_BASE + 0x134)  // General Input/Output Control
#endif
 
#include "vsprintf.c"
 
#define __DOUTBUFSIZE 256
#define __FINBUFSIZE 256  //Must be a multiple of 2! (ex: 32,64,128,256,512..)
#define __KINBUFSIZE 64   //Must be a multiple of 2! (ex: 32,64,128,256,512..)
#define __ESCCHR 27
 
#define __ESC_NADA   0
#define __ESC_ESCCHR 1
#define __ESC_FOPEN  2
#define __ESC_FCLOSE 3
#define __ESC_FGETC  4
#define __ESC_FPUTC  5
#define __ESC_REWIND 6
#define __ESC_FPUTC_PROCESSED 7         // PC side add CR before LF if DOS machine
#define __ESC_KBDCHR 8
 
unsigned char __outstr[__DOUTBUFSIZE];
unsigned char __finstr[__FINBUFSIZE];
unsigned char __kinstr[__KINBUFSIZE];
int finptr = 0;
int foutptr = 0;
int kinptr = 0;
int koutptr = 0;
 
int __dputchar (int c)
   {
   int rcv;
   static int LastChar = 0;
   static int KbdCharNext = 0;
 
   // Set non-general purpose comms mode
   *(u16 *)REG_RCNT = 0;
 
   // Init normal comms, 8 bit transfer, receive clocking
   *(u16 *)REG_SIODATA8 = c;
   *(u16 *)REG_SIOCNT = 0x80;
 
   // Wait until transfer is complete
   while (*(vu16 *)REG_SIOCNT & 0x80) {}
 
   // Wait until SC is low
   while (*(vu16 *)REG_RCNT & 1) {}
 
   // Force SD high
   *(u16 *)REG_RCNT = 0x8022;
 
   // Wait until SC is high
   while ((*(vu16 *)REG_RCNT & 1)==0) {}
 
   rcv = *(vu16 *)REG_SIODATA8;
 
   if (KbdCharNext)
      {
      // Put into keyboard buffer
      __kinstr[kinptr++] = rcv;
      kinptr &= (__KINBUFSIZE-1);
 
      KbdCharNext = 0;
 
      // Make received char look like a NADA character
      // so that it won't be buffered elsewhere.
      LastChar = __ESCCHR;
      rcv = __ESC_NADA;
      }
 
   if (LastChar == __ESCCHR)
      {
      // Process escape character
      switch (rcv)
         {
         case __ESC_ESCCHR:
            __finstr[finptr++] = __ESCCHR;
            finptr &= (__FINBUFSIZE-1);
            break;
         case __ESC_KBDCHR:
            KbdCharNext = 1;
            break;
         }
      LastChar = 0;
      }
   else
      {
      if (rcv == __ESCCHR)
         LastChar = __ESCCHR;
      else
         {
         // If char received from PC then save in receive FIFO
         __finstr[finptr++] = rcv;
         finptr &= (__FINBUFSIZE-1);
         }
      }
   return(1);
   }
 
int dputchar (int c)
   {
   (void) __dputchar(c);
   if (c == __ESCCHR)
      (void) __dputchar(__ESC_ESCCHR);
   return (1);
   }
 
void __PrintStr (char *str)
   {
   while (*str)
      (void) dputchar(*str++);
   }
 
int dgetch (void)
   {
   int c;
 
   // If no character is in FIFO then wait for one.
   while (kinptr == koutptr)
      {
      __dputchar(__ESCCHR);
      __dputchar(__ESC_NADA);
      }
 
   c = __kinstr[koutptr++];
   koutptr &= (__KINBUFSIZE-1);
 
   return (c);
   }
 
int dfgetch (void)
   {
   int c;
 
   // If no character is in FIFO then wait for one.
   while (finptr == foutptr)
      {
      __dputchar(__ESCCHR);
      __dputchar(__ESC_NADA);
      }
 
   c = __finstr[foutptr++];
   foutptr &= (__FINBUFSIZE-1);
 
   return (c);
   }
 
int dkbhit (void)
   {
   return(kinptr != koutptr);
   }
 
FILE dfopen (const char *file, const char *type)
   {
   __dputchar(__ESCCHR);
   __dputchar(__ESC_FOPEN);
 
   while (*file)
      (void) dputchar(*file++);
   dputchar(0);
 
   while (*type)
      (void) dputchar(*type++);
   dputchar(0);
 
   return(1);
   }
 
int dfclose (FILE fp)
   {
   __dputchar(__ESCCHR);
   __dputchar(__ESC_FCLOSE);
 
   return(1);
   }
 
int dfgetc (FILE fp)
   {
   __dputchar(__ESCCHR);
   __dputchar(__ESC_FGETC);
 
   return(dfgetch());
   }
 
int dfputc (int ch, FILE fp)
   {
   __dputchar(__ESCCHR);
   __dputchar(__ESC_FPUTC);
 
   __dputchar(ch);                 /* Bug fix. Was:  dputchar(ch); */
 
   return(1);
   }
 
void drewind (FILE fp)
   {
   __dputchar(__ESCCHR);
   __dputchar(__ESC_REWIND);
   }
 
void __PrintStrToFile (FILE fp, char *str)
   {
   while (*str)
      {
      __dputchar(__ESCCHR);
      __dputchar(__ESC_FPUTC_PROCESSED);
 
      dputchar(*str++);
      }
   }
 
#ifndef dprintf
	#define dprintf(x...) ({ dsprintf(__outstr, x); __PrintStr(__outstr); })
#endif
#define dfprintf(y,x...) ({ dsprintf(__outstr, x); __PrintStrToFile(y,__outstr); })
 
#ifdef __ANSI_NAMES
  #define printf  dprintf
  #define fprintf dfprintf
  #define putchar dputchar
  #define getch   dgetch
  #define kbhit   dkbhit
 
  #define fopen   dfopen
  #define fclose  dfclose
  #define fgetc   dfgetc
  #define fputc   dfputc
  #define rewind  drewind
#endif

Adapted from http://www.fivemouse.com.com/gba to compile with HAM and echo sent characters locally, the code is spread accross multiple files, so I've just compressed the files into a .rar file.

http://robmeerman.co.uk/downloads/GBA%20RS232%20Terminal.rar