xavi
/
Airport
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
Airport/Source/System.c

1218 lines
33 KiB
C
Raw Permalink Blame History

/* *************************************
* Includes
* *************************************/
#include "System.h"
#include "Pad.h"
#include "Menu.h"
#include "Gfx.h"
#include "MemCard.h"
#include "EndAnimation.h"
#include "Timer.h"
/* *************************************
* Defines
* *************************************/
#define FILE_BUFFER_SIZE (128 << 10) // 128 KB
#define END_STACK_PATTERN (uint32_t) 0x18022015
#define BEGIN_STACK_ADDRESS (uint32_t*) 0x801FFF00
#define STACK_SIZE (6 << 10) // 6 KiB
#define I_MASK (*(volatile unsigned int*)0x1F801074)
#define I_STAT (*(volatile unsigned int*)0x1F801070)
/* *************************************
* Local Prototypes
* *************************************/
static void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step);
static void SystemSetStackPattern(void);
static void ISR_RootCounter2(void);
/* *************************************
* Local Variables
* *************************************/
//Buffer to store any kind of files. It supports files up to 128 kB
static uint8_t file_buffer[FILE_BUFFER_SIZE];
//Global timer (called by interrupt)
static volatile uint64_t global_timer;
//Tells whether rand seed has been set
static bool rand_seed;
//Screen refresh flag (called by interrupt)
static volatile bool refresh_needed;
// Frames per second measurement
static volatile uint8_t fps;
static volatile uint8_t temp_fps;
//Timers
static bool one_second_timer;
static bool hundred_ms_timer;
static bool five_hundred_ms_timer;
//Emergency mode flag. Toggled on pad connected/disconnected
static bool emergency_mode;
//Critical section is entered (i.e.: when accessing fopen() or other BIOS functions
static volatile bool system_busy;
// When true, it draws a rectangle on top of all primitives with
// information for development purposes.
static bool devmenu_flag;
// Used for sine-like effect.
static unsigned char sine_counter;
/* *******************************************************************
*
* @name: void SystemInit(void)
*
* @author: Xavier Del Campo
*
* @brief: Calls main intialization routines.
*
* @remarks: To be called before main loop.
*
* *******************************************************************/
void SystemInit(void)
{
enum
{
RCNT2_100US_TICK_COUNTER = 0xA560
};
//Reset global timer
global_timer = 0;
//Reset 1 second timer
one_second_timer = 0;
//PSXSDK init
PSX_InitEx(0);
// SIO init
SerialInit();
//Graphics init
GsInit();
//Clear VRAM
GsClearMem();
//Set Video Resolution
#ifdef _PAL_MODE_
GsSetVideoMode(X_SCREEN_RESOLUTION, Y_SCREEN_RESOLUTION, VMODE_PAL);
#else
GsSetVideoMode(X_SCREEN_RESOLUTION, Y_SCREEN_RESOLUTION, VMODE_NTSC);
#endif //_PAL_MODE_
//SPU init
SsInit();
//Reset all user-handled timers
TimerReset();
//Pads init
PadInit();
//Set Drawing Environment
GfxInitDrawEnv();
//Set Display Environment
GfxInitDispEnv();
//Set VBlank Handler for screen refresh
SetVBlankHandler(&ISR_SystemDefaultVBlank);
//Set Primitive List
GfxSetDefaultPrimitiveList();
// Init memory card
MemCardInit();
//Initial value for system_busy
system_busy = false;
//Development menu flag
devmenu_flag = false;
//Emergency mode flag
emergency_mode = false;
GfxSetGlobalLuminance(NORMAL_LUMINANCE);
SystemSetStackPattern();
// Configure root counter 2 so that ISR_RootCounter2
// is executed every 100 us.
SetRCntHandler(&ISR_RootCounter2, 2, RCNT2_100US_TICK_COUNTER);
SystemEnableRCnt2Interrupt();
}
static volatile uint16_t u16_0_01seconds_cnt;
static volatile uint16_t u16_0_01seconds_cnt_prev;
/* *******************************************************************
*
* @name: void ISR_RootCounter2(void)
*
* @author: Xavier Del Campo
*
* @brief:
* Executed on RCnt2 ISR every 100 us.
*
* *******************************************************************/
void ISR_RootCounter2(void)
{
u16_0_01seconds_cnt++;
if ((int16_t)(u16_0_01seconds_cnt - 1000) >= (int16_t)(u16_0_01seconds_cnt_prev))
{
u16_0_01seconds_cnt_prev = u16_0_01seconds_cnt;
//~ DEBUG_PRINT_VAR(u16_0_01seconds_cnt_prev);
}
}
/* *******************************************************************
*
* @name: void SystemSetRandSeed(void)
*
* @author: Xavier Del Campo
*
* @brief:
* Calls srand() while avoiding multiple calls by setting internal
* variable rand_seed to true. Internal variable "global_timer" is
* used to generate the new seed.
*
* @remarks:
* It is recommended to call it once user has pressed any key.
*
* *******************************************************************/
void SystemSetRandSeed(void)
{
if (rand_seed == false)
{
rand_seed = true;
//Set random seed using global timer as reference
srand((unsigned int)global_timer ^ GetRCnt(2));
Serial_printf("Seed used: %d\n",(unsigned int)global_timer);
}
}
/* *******************************************************************
*
* @name: bool SystemIsRandSeedSet(void)
*
* @author: Xavier Del Campo
*
* @brief:
* Reportedly, returns whether rand seed has already been set.
*
* @remarks:
*
* @return:
* Reportedly, returns whether rand seed has already been set.
*
* *******************************************************************/
bool SystemIsRandSeedSet(void)
{
return rand_seed;
}
/* *******************************************************************
*
* @name: bool SystemRefreshNeeded(void)
*
* @author: Xavier Del Campo
*
* @brief:
*
* @remarks:
*
* @return:
* Returns whether VSync flag has been enabled.
*
* *******************************************************************/
bool SystemRefreshNeeded(void)
{
return refresh_needed;
}
/* *******************************************************************
*
* @name: void ISR_SystemDefaultVBlank(void)
*
* @author: Xavier Del Campo
*
* @brief:
*
* @remarks:
* Called from VSync interrupt. Called 50 times a second in PAL mode,
* 60 times a second in NTSC mode.
*
* *******************************************************************/
void ISR_SystemDefaultVBlank(void)
{
if (System1SecondTick())
{
fps = temp_fps;
temp_fps = 0;
}
refresh_needed = true;
}
/* *******************************************************************
*
* @name: void SystemAcknowledgeFrame(void)
*
* @author: Xavier Del Campo
*
* @brief:
*
* @remarks:
* Called by Game module in order to calculate frames per second.
*
* *******************************************************************/
void SystemAcknowledgeFrame(void)
{
temp_fps++;
}
/* *******************************************************************
*
* @name: void SystemAcknowledgeFrame(void)
*
* @author: Xavier Del Campo
*
* @brief:
* Creates a sine-like (more exactly, a sawtooth-like) effect and
* stores its value into a variable.
*
* @remarks:
* To be called only once, preferibly on SystemCyclic().
*
* *******************************************************************/
void SystemCalculateSine(void)
{
enum
{
SINE_EFFECT_STEP = 24,
SINE_EFFECT_MAX = 240
};
static bool sine_decrease = false;
if (sine_decrease == false)
{
if (sine_counter < SINE_EFFECT_MAX)
{
sine_counter += SINE_EFFECT_STEP;
}
else
{
sine_decrease = true;
}
}
else
{
if (sine_counter > SINE_EFFECT_STEP)
{
sine_counter -= SINE_EFFECT_STEP;
}
else
{
sine_decrease = false;
}
}
}
/* *******************************************************************
*
* @name: unsigned char SystemGetSineValue(void)
*
* @author: Xavier Del Campo
*
* @return:
* Returns a value which oscillates like a sine (more exactly, like
* a parabola) function to be used wherever you want.
*
* *******************************************************************/
unsigned char SystemGetSineValue(void)
{
return sine_counter;
}
/* *******************************************************************
*
* @name: void SystemIncreaseGlobalTimer(void)
*
* @author: Xavier Del Campo
*
* @brief:
* Increases internal variable responsible for time handling.
*
* @remarks:
* Usually called from ISR_SystemDefaultVBlank().
*
* *******************************************************************/
void SystemIncreaseGlobalTimer(void)
{
global_timer++;
}
/* *******************************************************************
*
* @name: volatile uint64_t SystemGetGlobalTimer(void)
*
* @author: Xavier Del Campo
*
* @brief: Returns internal global timer value.
*
* *******************************************************************/
volatile uint64_t SystemGetGlobalTimer(void)
{
return global_timer;
}
/* *******************************************************************
*
* @name: void SystemDisableScreenRefresh(void)
*
* @author: Xavier Del Campo
*
* @brief: Resets VBlank IRQ flag.
*
* *******************************************************************/
void SystemDisableScreenRefresh(void)
{
refresh_needed = false;
}
/* *******************************************************************
*
* @name: bool System1SecondTick(void)
*
* @author: Xavier Del Campo
*
* @return: bool variable with a 1-cycle-length pulse that gets
* set each second.
*
* *******************************************************************/
bool System1SecondTick(void)
{
return one_second_timer;
}
/* *******************************************************************
*
* @name: bool System100msTick(void)
*
* @author: Xavier Del Campo
*
* @return: bool variable with a 1-cycle-length pulse that gets
* set every 100 milliseconds.
*
* *******************************************************************/
bool System100msTick(void)
{
return hundred_ms_timer;
}
/* *******************************************************************
*
* @name bool System500msTick(void)
*
* @author: Xavier Del Campo
*
* @return: bool variable with a 1-cycle-length pulse that gets
* set every 500 milliseconds.
*
* *******************************************************************/
bool System500msTick(void)
{
return five_hundred_ms_timer;
}
/* *******************************************************************
*
* @name void SystemRunTimers(void)
*
* @author: Xavier Del Campo
*
* @brief: general timer handler
*
* @remarks: 1 second, 500 ms and 100 ms ticks get updated here.
*
* *******************************************************************/
void SystemRunTimers(void)
{
static uint64_t last_one_second_tick;
static uint64_t last_100_ms_tick;
static uint64_t last_500_ms_tick;
SystemCheckTimer(&one_second_timer, &last_one_second_tick, REFRESH_FREQUENCY);
#ifdef _PAL_MODE_
SystemCheckTimer(&hundred_ms_timer, &last_100_ms_tick, 2 /* 2 * 50 ms = 100 ms */);
SystemCheckTimer(&five_hundred_ms_timer, &last_500_ms_tick, 10 /* 10 * 50 ms = 500 ms */);
#else // _PAL_MODE_
SystemCheckTimer(&hundred_ms_timer, &last_100_ms_tick, 3);
#endif // _PAL_MODE_
}
/* ********************************************************************************
*
* @name void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step)
*
* @author: Xavier Del Campo
*
* @brief: Checks if needed time step has been elapsed. If true, flag gets set.
*
* *******************************************************************************/
void SystemCheckTimer(bool* timer, uint64_t* last_timer, uint8_t step)
{
if (*timer)
{
*timer = false;
}
if (global_timer >= (*last_timer + step) )
{
*timer = true;
*last_timer = global_timer;
}
}
/* ****************************************************************************************
*
* @name bool SystemLoadFileToBuffer(char* fname, uint8_t* buffer, uint32_t szBuffer)
*
* @author: Xavier Del Campo
*
* @brief: Given an input path, it fills a buffer pointed to by "buffer" with
* maximum size "szBuffer" with data from CD-ROM.
*
* @return: true if file has been loaded successfully, false otherwise.
*
* ****************************************************************************************/
bool SystemLoadFileToBuffer(const char* fname, uint8_t* buffer, uint32_t szBuffer)
{
#ifdef SERIAL_INTERFACE
uint8_t fileSizeBuffer[sizeof (uint32_t)] = {0};
uint32_t i;
#else // SERIAL_INTERFACE
FILE *f;
#endif // SERIAL_INTERFACE
int32_t size = 0;
// Wait for possible previous operation from the GPU before entering this section.
while ( (SystemIsBusy()) || (GfxIsGPUBusy()) );
SystemDisableRCnt2Interrupt();
if (fname == NULL)
{
Serial_printf("SystemLoadFile: NULL fname!\n");
return false;
}
memset(buffer,0,szBuffer);
static char completeFileName[256];
snprintf(completeFileName, sizeof (completeFileName), "cdrom:\\%s;1", fname);
#ifdef SERIAL_INTERFACE
Serial_printf("#%s@", completeFileName);
SerialRead(fileSizeBuffer, sizeof (uint32_t) );
for (i = 0; i < sizeof (uint32_t); i++)
{
size |= fileSizeBuffer[i] << (i << 3); // (i << 3) == (i * 8)
}
SerialWrite(ACK_BYTE_STRING, 1);
for (i = 0; i < size; i += SERIAL_DATA_PACKET_SIZE)
{
uint32_t bytes_to_read;
// Read actual EXE data into proper RAM address.
if ( (i + SERIAL_DATA_PACKET_SIZE) >= size)
{
bytes_to_read = size - i;
}
else
{
bytes_to_read = SERIAL_DATA_PACKET_SIZE;
}
SerialRead(file_buffer + i, bytes_to_read);
SerialWrite(ACK_BYTE_STRING, sizeof (uint8_t)); // Write ACK
}
#else // SERIAL_INTERFACE
system_busy = true;
SystemDisableVBlankInterrupt();
Serial_printf("Opening %s...\n", completeFileName);
f = fopen((char*)completeFileName, "r");
if (f == NULL)
{
Serial_printf("SystemLoadFile: file could not be found!\n");
//File couldn't be found
return false;
}
fseek(f, 0, SEEK_END);
size = ftell(f);
if (size > szBuffer)
{
Serial_printf("SystemLoadFile: Exceeds file buffer size (%d bytes)\n",size);
//Bigger than 128 kB (buffer's max size)
return false;
}
fseek(f, 0, SEEK_SET); //f->pos = 0;
fread(buffer, sizeof (char), size, f);
fclose(f);
SystemEnableVBlankInterrupt();
SystemEnableRCnt2Interrupt();
system_busy = false;
#endif // SERIAL_INTERFACE
Serial_printf("File \"%s\" loaded successfully!\n",completeFileName);
return true;
}
/* ****************************************************************************************
*
* @name bool SystemLoadFile(char*fname)
*
* @author: Xavier Del Campo
*
* @brief: Given an input file name, it loads its conents into internal buffer.
*
* @return: true if file has been loaded successfully, false otherwise.
*
* ****************************************************************************************/
bool SystemLoadFile(const char* fname)
{
return SystemLoadFileToBuffer(fname,file_buffer,sizeof (file_buffer));
}
/* ******************************************************************
*
* @name uint8_t* SystemGetBufferAddress(void)
*
* @author: Xavier Del Campo
*
* @return: Reportedly, returns internal buffer initial address.
*
* *****************************************************************/
uint8_t* SystemGetBufferAddress(void)
{
return file_buffer;
}
/* ******************************************************************
*
* @name void SystemClearFileBuffer(void)
*
* @author: Xavier Del Campo
*
* @return: Fills internal buffer with zeros
*
* *****************************************************************/
void SystemClearFileBuffer(void)
{
memset(file_buffer, 0, sizeof (file_buffer));
}
/* ******************************************************************
*
* @name uint32_t SystemRand(uint32_t min, uint32_t max)
*
* @author: Xavier Del Campo
*
* @return: random number between "min" and "max".
*
* @remarks: rand seed must be set before using this function, or
* you will predictable values otherwise!
*
* *****************************************************************/
uint32_t SystemRand(uint32_t min, uint32_t max)
{
if (rand_seed == false)
{
//~ Serial_printf("Warning: calling rand() before srand()\n");
}
return rand() % (max - min + 1) + min;
}
/* ***********************************************************************
*
* @name void SystemSetEmergencyMode(bool value)
*
* @author: Xavier Del Campo
*
* @brief: Sets emergency mode flag.
*
* @remarks: emergency mode is set once that a controller is unplugged.
*
* ***********************************************************************/
void SystemSetEmergencyMode(bool value)
{
emergency_mode = value;
}
/* ***********************************************************************
*
* @name bool SystemGetEmergencyMode(void)
*
* @author: Xavier Del Campo
*
* @return: returns emergency mode flag.
*
* ***********************************************************************/
bool SystemGetEmergencyMode(void)
{
return emergency_mode;
}
/* ***********************************************************************
*
* @name volatile bool SystemIsBusy(void)
*
* @author: Xavier Del Campo
*
* @return: returns system busy flag.
*
* ***********************************************************************/
volatile bool SystemIsBusy(void)
{
return system_busy;
}
/* ****************************************************************************
*
* @name bool SystemContains_u8(uint8_t value, uint8_t* buffer, size_t sz)
*
* @author: Xavier Del Campo
*
* @brief: checks if a certain value is contained in a buffer with size "sz".
*
* @return: true if value is contained inside buffer, false otherwise.
*
* ****************************************************************************/
bool SystemContains_u8(const uint8_t value, const uint8_t* const buffer, const size_t sz)
{
size_t i = 0;
for (i = 0; i < sz; i++)
{
if (buffer[i] == value)
{
return true;
}
}
return false;
}
/* ****************************************************************************
*
* @name bool SystemContains_u16(uint16_t value, uint16_t* buffer, size_t sz)
*
* @author: Xavier Del Campo
*
* @brief: checks if a certain value is contained in a buffer with size "sz".
* Variant for u16 variables.
*
* @return: true if value is contained inside buffer, false otherwise.
*
* ****************************************************************************/
bool SystemContains_u16(const uint16_t value, const uint16_t* const buffer, const size_t sz)
{
size_t i = 0;
for (i = 0; i < sz; i++)
{
if (buffer[i] == value)
{
return true;
}
}
return false;
}
/* ****************************************************************************************
*
* @name bool SystemArrayCompare(unsigned short* arr1, unsigned short* arr2, size_t sz)
*
* @author: Xavier Del Campo
*
* @brief: Reportedly, it compares two arrays "arr1" and "arr2", with size "sz".
*
* @return: true if they are equal, false otherwise.
*
* ****************************************************************************************/
bool SystemArrayCompare(const unsigned short* const arr1, const unsigned short* const arr2, const size_t sz)
{
size_t i;
for (i = 0; i < sz; i++)
{
if (arr1[i] != arr2[i])
{
return false;
}
}
return true;
}
/* ****************************************************************************************
*
* @name void SystemPrintStackPointerAddress(void)
*
* @author: Xavier Del Campo
*
* @brief: Prints stack usage in percentage via dprintf calls.
*
* ****************************************************************************************/
void SystemPrintStackPointerAddress(void)
{
#ifdef PSXSDK_DEBUG // Used to avoid unused variable warning
void* ptr = NULL;
fix16_t used_bytes = fix16_from_int((int)((void*)BEGIN_STACK_ADDRESS - (void*)&ptr));
fix16_t stackPercent = fix16_sdiv(used_bytes,fix16_from_int((int)STACK_SIZE));
stackPercent = fix16_smul(stackPercent, fix16_from_int((int)100));
Serial_printf("stackPercent: %d\n", stackPercent);
Serial_printf("Stack begin pointer: 0x%08X\n"
"Stack pointer address: 0x%08X\n"
"Used %d%% of stack size.\n"
"\tUsed bytes: %d\n",
(void*)BEGIN_STACK_ADDRESS,
(void*)&ptr,
fix16_to_int(stackPercent),
fix16_to_int(used_bytes) );
#endif // PSXSDK_DEBUG
}
/* ****************************************************************************************
*
* @name void SystemCheckStack(void)
*
* @author: Xavier Del Campo
*
* @brief: Compares stack top with expected byte pattern. If does not match, a stack
* overflow has been caused, and application returns to a safe state.
*
* ****************************************************************************************/
void SystemCheckStack(void)
{
const uint32_t* const ptrStack = BEGIN_STACK_ADDRESS - STACK_SIZE;
const uint32_t data = *ptrStack;
if (data != END_STACK_PATTERN)
{
Serial_printf("Stack overflow?\n");
while (1);
}
}
/* ****************************************************************************************
*
* @name void SystemSetStackPattern(void)
*
* @author: Xavier Del Campo
*
* @brief: Sets a determined byte pattern on stack top to detect possible stack
* overflow during execution.
*
* ****************************************************************************************/
void SystemSetStackPattern(void)
{
uint32_t* const ptrStack = BEGIN_STACK_ADDRESS - STACK_SIZE;
*ptrStack = END_STACK_PATTERN;
}
/* ****************************************************************************************
*
* @name int32_t SystemIndexOfStringArray(char* str, char** array)
*
* @author: Xavier Del Campo
*
* @brief: Finds string "str" inside an array of strings "array".
*
* @return Index for a string "str" inside "array". -1 if it could not be found.
*
* ****************************************************************************************/
int32_t SystemIndexOfStringArray(const char* str, const char* const* array)
{
int32_t i;
for (i = 0; array[i] != NULL; i++)
{
Serial_printf("String to find: %s\nEntry: %s\n", str, array[i]);
if (strcmp(str, array[i]) == 0)
{
Serial_printf("Match! Returning index %d...\n", i);
return i;
}
}
return -1;
}
/* ****************************************************************************************
*
* @name int32_t SystemIndexOf_U16(uint16_t value, uint16_t* array, uint32_t sz)
*
* @author: Xavier Del Campo
*
* @brief: For a uint16_t array, it returns index of a variable "value" inside an array.
*
* @return Index for a variable "value" inside "array". -1 if it could not be found.
*
* ****************************************************************************************/
int32_t SystemIndexOf_U16(const uint16_t value, const uint16_t* const array, const uint32_t sz)
{
int32_t i;
for (i = 0; i < sz; i++)
{
if (value == array[i])
{
return i;
}
}
return -1;
}
/* ****************************************************************************************
*
* @name int32_t SystemIndexOf_U8(uint8_t value, uint8_t* array, uint32_t from, uint32_t sz)
*
* @author: Xavier Del Campo
*
* @brief: For a uint8_t array, it returns index of a variable "value" inside an array.
* "from" and "size_t" can be used to determine initial/ending positions.
*
* @return Index for a variable "value" inside "array". -1 if it could not be found.
*
* ****************************************************************************************/
int32_t SystemIndexOf_U8(const uint8_t value, const uint8_t* const array, const uint32_t from, const uint32_t sz)
{
int32_t i;
for (i = from; i < sz; i++)
{
if (value == array[i])
{
return i;
}
}
return -1;
}
/* ****************************************************************************************
*
* @name volatile uint8_t SystemGetFPS(void)
*
* @author: Xavier Del Campo
*
* @return: Frames per second
*
* ****************************************************************************************/
volatile uint8_t SystemGetFPS(void)
{
return fps;
}
/* ****************************************************************************************
*
* @name void SystemCyclicHandler(void)
*
* @author: Xavier Del Campo
*
* @brief: It calls system handlers once an execution cycle has finished.
*
*
* ****************************************************************************************/
void SystemCyclicHandler(void)
{
UpdatePads();
SystemIncreaseGlobalTimer();
SystemRunTimers();
TimerHandler();
SystemDisableScreenRefresh();
MemCardHandler();
SystemCalculateSine();
SystemCheckStack();
}
/* ****************************************************************************************
*
* @name void SystemDisableVBlankInterrupt(void)
*
* @author: Xavier Del Campo
*
* @brief: Reportedly, this routine enables VBLANK interrupt flag.
*
* @remark: Used when critical timing is needed or GPU activity is not desired
* e.g.: when reading files from CD-ROM.
*
* ****************************************************************************************/
void SystemDisableVBlankInterrupt(void)
{
I_MASK &= ~1;
}
/* ****************************************************************************************
*
* @name void SystemEnableVBlankInterrupt(void)
*
* @author: Xavier Del Campo
*
* @brief: Reportedly, this routine enables VBLANK interrupt flag.
*
*
* ****************************************************************************************/
void SystemEnableVBlankInterrupt(void)
{
I_MASK |= 1;
}
/* ****************************************************************************************
*
* @name void SystemReturnToLoader(void)
*
* @author: Xavier Del Campo
*
* @brief: Deinitializes PSXSDK library and returns to OpenSend loader,
* located at memory address 0x801A0000
*
* ****************************************************************************************/
void SystemReturnToLoader(void)
{
Serial_printf("Returning to loader...\n");
EndAnimation();
PSX_DeInit();
__asm__("j 0x801A0000");
}
/* ****************************************************************************************
*
* @name void SystemDevMenuToggle(void)
*
* @author: Xavier Del Campo
*
* @brief: It toggles a flag called "devmenu_flag" which, if true, shows information on
* top of all drawn primitives for debugging/development purposes.
*
* ****************************************************************************************/
void SystemDevMenuToggle(void)
{
devmenu_flag = devmenu_flag? false: true;
}
/* ****************************************************************************************
*
* @name void SystemEnableRCnt2Interrupt(void)
*
* @author: Xavier Del Campo
*
* @brief: Enables bit 6 from I_MASK (0x1F801074)/IRQ6 RCNT2 (System clock / 8)
*
* ****************************************************************************************/
void SystemEnableRCnt2Interrupt(void)
{
I_MASK |= 1<<6;
}
/* ****************************************************************************************
*
* @name void SystemDisableRCnt2Interrupt(void)
*
* @author: Xavier Del Campo
*
* @brief: Disables bit 6 from I_MASK (0x1F801074)/IRQ6 RCNT2 (System clock / 8)
*
* ****************************************************************************************/
void SystemDisableRCnt2Interrupt(void)
{
I_MASK &= ~(1 << 6);
}
/* ****************************************************************************************
*
* @name void SystemDevMenu(void)
*
* @author: Xavier Del Campo
*
* @brief: Shows information on top of all drawn primitives for debugging/development purposes.
*
* ****************************************************************************************/
void SystemDevMenu(void)
{
enum
{
DEVMENU_BG_W = 256,
DEVMENU_BG_X = (X_SCREEN_RESOLUTION >> 1) - (DEVMENU_BG_W >> 1),
DEVMENU_BG_Y = 32,
DEVMENU_BG_H = 128,
DEVMENU_BG_R = 0,
DEVMENU_BG_G = 128,
DEVMENU_BG_B = 32,
};
enum
{
DEVMENU_TEXT_GAP = 8,
DEVMENU_PAD1_STATUS_TEXT_X = DEVMENU_BG_X + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_STATUS_TEXT_Y = DEVMENU_BG_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_TYPE_TEXT_X = DEVMENU_PAD1_STATUS_TEXT_X,
DEVMENU_PAD1_TYPE_TEXT_Y = DEVMENU_PAD1_STATUS_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_ID_TEXT_X = DEVMENU_PAD1_STATUS_TEXT_X,
DEVMENU_PAD1_ID_TEXT_Y = DEVMENU_PAD1_TYPE_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD1_RAW_DATA_TEXT_X = DEVMENU_PAD1_ID_TEXT_X,
DEVMENU_PAD1_RAW_DATA_TEXT_Y = DEVMENU_PAD1_ID_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD2_STATUS_TEXT_X = DEVMENU_PAD1_RAW_DATA_TEXT_X,
DEVMENU_PAD2_STATUS_TEXT_Y = DEVMENU_PAD1_RAW_DATA_TEXT_Y + (DEVMENU_TEXT_GAP << 1), // Leave a bigger gap here
DEVMENU_PAD2_TYPE_TEXT_X = DEVMENU_PAD2_STATUS_TEXT_X,
DEVMENU_PAD2_TYPE_TEXT_Y = DEVMENU_PAD2_STATUS_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD2_ID_TEXT_X = DEVMENU_PAD2_TYPE_TEXT_X,
DEVMENU_PAD2_ID_TEXT_Y = DEVMENU_PAD2_TYPE_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_PAD2_RAW_DATA_TEXT_X = DEVMENU_PAD2_ID_TEXT_X,
DEVMENU_PAD2_RAW_DATA_TEXT_Y = DEVMENU_PAD2_ID_TEXT_Y + DEVMENU_TEXT_GAP,
DEVMENU_ROOTCNT2_TEXT_X = DEVMENU_PAD2_RAW_DATA_TEXT_X,
DEVMENU_ROOTCNT2_TEXT_Y = DEVMENU_PAD2_RAW_DATA_TEXT_Y + DEVMENU_TEXT_GAP,
};
if (devmenu_flag)
{
static const GsRectangle devMenuBg =
{
.x = DEVMENU_BG_X,
.y = DEVMENU_BG_Y,
.w = DEVMENU_BG_W,
.h = DEVMENU_BG_H,
.r = DEVMENU_BG_R,
.g = DEVMENU_BG_G,
.b = DEVMENU_BG_B,
.attribute = ENABLE_TRANS | TRANS_MODE(0)
};
GsSortRectangle((GsRectangle*)&devMenuBg);
FontPrintText( &SmallFont,
DEVMENU_PAD1_STATUS_TEXT_X,
DEVMENU_PAD1_STATUS_TEXT_Y,
"Pad1 connected = %d",
PadOneConnected() );
FontPrintText( &SmallFont,
DEVMENU_PAD1_TYPE_TEXT_X,
DEVMENU_PAD1_TYPE_TEXT_Y,
"Pad1 type = 0x%02X",
PadOneGetType() );
FontPrintText( &SmallFont,
DEVMENU_PAD1_ID_TEXT_X,
DEVMENU_PAD1_ID_TEXT_Y,
"Pad1 ID = 0x%02X",
PadOneGetID() );
FontPrintText( &SmallFont,
DEVMENU_PAD1_RAW_DATA_TEXT_X,
DEVMENU_PAD1_RAW_DATA_TEXT_Y,
"Pad1 raw data = 0x%04X",
PadOneGetRawData() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_STATUS_TEXT_X,
DEVMENU_PAD2_STATUS_TEXT_Y,
"Pad2 connected = %d",
PadTwoConnected() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_TYPE_TEXT_X,
DEVMENU_PAD2_TYPE_TEXT_Y,
"Pad2 type = 0x%02X",
PadTwoGetType() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_ID_TEXT_X,
DEVMENU_PAD2_ID_TEXT_Y,
"Pad2 ID = 0x%02X",
PadTwoGetID() );
FontPrintText( &SmallFont,
DEVMENU_PAD2_RAW_DATA_TEXT_X,
DEVMENU_PAD2_RAW_DATA_TEXT_Y,
"Pad2 raw data = 0x%04X",
PadTwoGetRawData() );
/*FontPrintText( &SmallFont,
DEVMENU_ROOTCNT2_TEXT_X,
DEVMENU_ROOTCNT2_TEXT_Y,
"Timer2 = 0x%04X",
GetRCnt(2) );*/
FontPrintText( &SmallFont,
DEVMENU_ROOTCNT2_TEXT_X,
DEVMENU_ROOTCNT2_TEXT_Y,
"Timer2 = 0x%04X, timer2 = 0x%04X",
u16_0_01seconds_cnt, GetRCnt(2) );
}
}
void SystemGetFileBasename(const char* fileName, char* str, const size_t sz)
{
size_t i;
size_t j = 0;
const size_t len = strlen(fileName);
memset(str, 0, sz);
for (i = (len - 1); fileName[i] != '\\'; i--);
i++; // Skip '\\' character.
for (; fileName[i]; i++)
{
str[j++] = fileName[i];
}
}
Reference in New Issue View Git Blame Copy Permalink