remote.c File Reference

#include <stdio.h>
#include <kernel.h>
#include <sifrpc.h>
#include <string.h>
#include <iopcontrol.h>
#include <loadfile.h>
#include <sbv_patches.h>
#include <debug.h>
#include <librm.h>

Include dependency graph for remote.c:

Go to the source code of this file.

Functions
static s32	VblankStartHandler (s32 cause)
static s32	VblankEndHandler (s32 cause)
static const char *	getRmStatus (u32 status)
static const char *	getRmButton (u32 button)
int	main (int argc, char *argv[])

Variables
unsigned char	SIO2MAN_irx []
unsigned int	size_SIO2MAN_irx
unsigned char	RMMAN_irx []
unsigned int	size_RMMAN_irx
static int	VblankStartSema
static int	VblankEndSema

Function Documentation

getRmButton()

static const char* getRmButton ( u32  button )

static

Definition at line 70 of file remote.c.

{
        switch(button)
        {
                case RM_AUDIO:
                        return "AUDIO";
                case RM_SHUFFLE:
                        return "SHUFFLE";
                case RM_ANGLE:
                        return "ANGLE";
                case RM_PROGRAM:
                        return "PROGRAM";
                case RM_SUBTITLE:
                        return "SUBTITLE";
                case RM_REPEAT:
                        return "REPEAT";
                case RM_SLOW_BACK:
                        return "SLOW-BACK";
                case RM_SLOW_FORW:
                        return "SLOW-FORWARD";
                case RM_SCAN_BACK:
                        return "SCAN-BACK";
                case RM_SCAN_FORW:
                        return "SCAN-FORWARD";
                case RM_ONE:
                        return "ONE";
                case RM_TWO:
                        return "TWO";
                case RM_THREE:
                        return "THREE";
                case RM_FOUR:
                        return "FOUR";
                case RM_FIVE:
                        return "FIVE";
                case RM_SIX:
                        return "SIX";
                case RM_SEVEN:
                        return "SEVEN";
                case RM_EIGHT:
                        return "EIGHT";
                case RM_NINE:
                        return "NINE";
                case RM_ZERO:
                        return "ZERO";
                case RM_CLEAR:
                        return "CLEAR";
                case RM_TIME:
                        return "TIME";
                case RM_PREV:
                        return "PREV";
                case RM_NEXT:
                        return "NEXT";
                case RM_ATOB:
                        return "ATOB";
                case RM_PLAY:
                        return "PLAY";
                case RM_PAUSE:
                        return "PAUSE";
                case RM_STOP:
                        return "STOP";
                case RM_DISPLAY:
                        return "DISPLAY";
                case RM_TITLE:
                        return "TITLE";
                case RM_MENU:
                        return "MENU";
                case RM_RETURN:
                        return "RETURN";
                case RM_TRIANGLE:
                        return "TRIANGLE";
                case RM_SQUARE:
                        return "SQUARE";
                case RM_CIRCLE:
                        return "CIRCLE";
                case RM_CROSS:
                        return "CROSS";
                case RM_UP:
                        return "UP";
                case RM_DOWN:
                        return "DOWN";
                case RM_LEFT:
                        return "LEFT";
                case RM_RIGHT:
                        return "RIGHT";
                case RM_ENTER:
                        return "ENTER";
                case RM_L1:
                        return "L1";
                case RM_L2:
                        return "L2";
                case RM_L3:
                        return "L3";
                case RM_R1:
                        return "R1";
                case RM_R2:
                        return "R3";
                case RM_START:
                        return "START";
                case RM_SELECT:
                        return "SELECT";
                case RM_EJECT:
                        return "EJECT";
                case RM_RESET:
                        return "RESET";
                case RM_NONE:
                        return "---";
                default:
                        return "UNKNOWN";
        }
}

References RM_ANGLE, RM_ATOB, RM_AUDIO, RM_CIRCLE, RM_CLEAR, RM_CROSS, RM_DISPLAY, RM_DOWN, RM_EIGHT, RM_EJECT, RM_ENTER, RM_FIVE, RM_FOUR, RM_L1, RM_L2, RM_L3, RM_LEFT, RM_MENU, RM_NEXT, RM_NINE, RM_NONE, RM_ONE, RM_PAUSE, RM_PLAY, RM_PREV, RM_PROGRAM, RM_R1, RM_R2, RM_REPEAT, RM_RESET, RM_RETURN, RM_RIGHT, RM_SCAN_BACK, RM_SCAN_FORW, RM_SELECT, RM_SEVEN, RM_SHUFFLE, RM_SIX, RM_SLOW_BACK, RM_SLOW_FORW, RM_SQUARE, RM_START, RM_STOP, RM_SUBTITLE, RM_THREE, RM_TIME, RM_TITLE, RM_TRIANGLE, RM_TWO, RM_UP, and RM_ZERO.

Referenced by main().

getRmStatus()

static const char* getRmStatus ( u32  status )

static

Definition at line 53 of file remote.c.

{
        switch(status)
        {
                case RM_INIT:
                        return "INITIALIZING";
                case RM_READY:
                        return "READY";
                case RM_KEYPRESSED:
                        return "PRESSED";
                case RM_NOREMOTE:
                        return "DISCONNECTED";
                default:
                        return "UNKNOWN";
        }
}

References RM_INIT, RM_KEYPRESSED, RM_NOREMOTE, and RM_READY.

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 181 of file remote.c.

{
        /*      Buffers for receiving input from remote controllers. A 256-byte region is required for each possible remote.
                Buffers must be each aligned to a 64-byte boundary due to how the EE data cache works. */
        static u8 rmData[256] __attribute__((aligned(64)));
        struct remote_data data, olddata;
        int startY, wrap;
        ee_sema_t sema;
 
        //Initialize RPC services
        SifInitRpc(0);
        SifIopReset(NULL, 0);
        while(!SifIopSync()){};
        SifInitRpc(0);
 
        //Initialize graphics library
        init_scr();
 
        scr_printf(     "Welcome to the RMMAN sample!\n");
        scr_printf(     "For this demo, the remote should be plugged into port 2.\n");
        scr_printf(     "Loading modules...\n");
 
        //Load modules
        SifLoadFileInit();
 
#ifdef USE_ROM_MODULES
        if(SifLoadModule("rom0:ADDDRV", 0, NULL) < 0)
        {
                scr_printf("Failed to load ADDDRV!\n");
                SleepThread();
        }
 
        if(SifLoadModule("rom1:SIO2MAN", 0, NULL) < 0)
        {
                scr_printf("Failed to load SIO2MAN!\n");
                SleepThread();
        }
 
        if(SifLoadModule("rom1:RMMAN", 0, NULL) < 0)
        {
                scr_printf("Failed to load RMMAN!\n");
                SleepThread();
        }
#else
        sbv_patch_enable_lmb();
 
        if(SifExecModuleBuffer(SIO2MAN_irx, size_SIO2MAN_irx, 0, NULL, NULL) < 0)
        {
                scr_printf("Failed to load SIO2MAN!\n");
                SleepThread();
        }
        if(SifExecModuleBuffer(RMMAN_irx, size_RMMAN_irx, 0, NULL, NULL) < 0)
        {
                scr_printf("Failed to load RMMAN!\n");
                SleepThread();
        }
#endif
 
        SifLoadFileExit();
 
        scr_printf(     "Initializing...\n");
 
        //Prepare semaphores, for detecting Vertical-Blanking events.
        sema.count = 0;
        sema.max_count = 1;
        sema.attr = 0;
 
        VblankStartSema = CreateSema(&sema);
        VblankEndSema = CreateSema(&sema);
 
        //Register VBlank start and end interrupt handlers.
        AddIntcHandler(INTC_VBLANK_S, &VblankStartHandler, 0);
        AddIntcHandler(INTC_VBLANK_E, &VblankEndHandler, 0);
 
        //Initialize the RMMAN RPC service
        RMMan_Init();
        scr_printf(     "Module version: 0x%04x\n", RMMan_GetModuleVersion());
 
        scr_printf(     "Opening ports...");
 
        /*      The remote can only be connected to slot 0 of any port (multitaps are not supported).
                For this demo, assume that the remote controller dongle is connected to
                controller port 2 (port = 1).   */
        RMMan_Open(1, 0, rmData);
 
        scr_printf(     "done!\n");
        scr_printf(     "New input will be displayed here:\n");
 
        //Enable interrupt handlers
        _EnableIntc(INTC_VBLANK_S);
        _EnableIntc(INTC_VBLANK_E);
 
        //In order to preserve the messages above, preserve the current Y coordinate.
        startY = scr_getY();
        wrap = 0;
 
        //Erase old remote state
        memset(&olddata, 0, sizeof(olddata));
 
        //Enter the main loop
        while(1)
        {       //Like with PADMAN, RMMAN only sends updates once every 1/60th (NTSC) or 1/50th (PAL) second.
                //Hence, wait for a VBlank cycle (1/50th or 1/60th second).
                WaitSema(VblankStartSema);
                WaitSema(VblankEndSema);
 
                //Read data that RMMAN has sent.
                RMMan_Read(1, 0, &data);
 
                //If there was a difference, print it.
                if((olddata.status != data.status) || (olddata.button != data.button))
                {
                        olddata = data;
 
                        /*      Do not draw past the end of the screen. If this is the last line, prepare to wrap around. */
                        if(scr_getY() + 1 >= 27)
                                wrap = 1;
 
                        scr_printf("\t%08x (%s)\t%08x (%s)\n", data.status, getRmStatus(data.status), data.button, getRmButton(data.button));
 
                        if(wrap)        //From libdebug itself
                        {
                                scr_setXY(0, startY);
                                wrap = 0;
                        }
                }
        }
        
        scr_printf("Shutting down...\n");
 
        //Prepare for shutdown
 
        //Disable interrupts
        _DisableIntc(INTC_VBLANK_S);
        _DisableIntc(INTC_VBLANK_S);
 
        //Unregister interrupt handlers
 
        //Delete semaphores
        DeleteSema(VblankStartSema);
        DeleteSema(VblankEndSema);
 
        //Close opened ports
        RMMan_Close(1, 0);
 
        //Terminate RPC services
        RMMan_End();
        SifExitRpc();
 
        return 0;
}

References _DisableIntc(), _EnableIntc(), AddIntcHandler(), ee_sema_t::attr, remote_data::button, ee_sema_t::count, CreateSema(), data, DeleteSema(), getRmButton(), getRmStatus(), init_scr(), INTC_VBLANK_E, INTC_VBLANK_S, ee_sema_t::max_count, NULL, RMMan_Close(), RMMan_End(), RMMan_GetModuleVersion(), RMMan_Init(), RMMAN_irx, RMMan_Open(), RMMan_Read(), sbv_patch_enable_lmb(), scr_getY(), scr_printf(), scr_setXY(), SifExecModuleBuffer(), SifExitRpc(), SifInitRpc(), SifIopReset(), SifIopSync(), SifLoadFileExit(), SifLoadFileInit(), SifLoadModule(), SIO2MAN_irx, size_RMMAN_irx, size_SIO2MAN_irx, SleepThread(), remote_data::status, VblankEndHandler(), VblankEndSema, VblankStartHandler(), VblankStartSema, and WaitSema().

VblankEndHandler()

static s32 VblankEndHandler ( s32  cause )

static

Definition at line 44 of file remote.c.

{
        iSignalSema(VblankEndSema);
 
        //As per the SONY documentation, call ExitHandler() at the very end of your interrupt handler.
        ExitHandler();
        return 0;
}

References ExitHandler, iSignalSema(), and VblankEndSema.

Referenced by main().

VblankStartHandler()

static s32 VblankStartHandler ( s32  cause )

static

Definition at line 35 of file remote.c.

{
        iSignalSema(VblankStartSema);
 
        //As per the SONY documentation, call ExitHandler() at the very end of your interrupt handler.
        ExitHandler();
        return 0;
}

References ExitHandler, iSignalSema(), and VblankStartSema.

Referenced by main().

Variable Documentation

RMMAN_irx

unsigned char RMMAN_irx[]

extern

Referenced by main().

SIO2MAN_irx

unsigned char SIO2MAN_irx[]

extern

Referenced by main().

size_RMMAN_irx

unsigned int size_RMMAN_irx

extern

Referenced by main().

size_SIO2MAN_irx

unsigned int size_SIO2MAN_irx

extern

Referenced by main().

VblankEndSema

int VblankEndSema

static

Definition at line 33 of file remote.c.

Referenced by main(), and VblankEndHandler().

VblankStartSema

int VblankStartSema

static

Definition at line 33 of file remote.c.

Referenced by main(), and VblankStartHandler().