//fillRectangle(poX+i*size, poY+f*size, size, size, fgcolor);
void TFT::fillRectangle(INT16U poX, INT16U poY, INT16U length, INT16U width, INT16U color)
{
fillScreen(poX, poX+length, poY, poY+width, color);
}
void _entryPoint()
{
/****************************> Get Handles <****************************/
//Get a handle to coreinit.rpl
unsigned int coreinit_handle;
OSDynLoad_Acquire("coreinit.rpl", &coreinit_handle);
//Get a handle to vpad.rpl */
unsigned int vpad_handle;
OSDynLoad_Acquire("vpad.rpl", &vpad_handle);
/****************************> External Prototypes <****************************/
//VPAD functions
int(*VPADRead)(int controller, VPADData *buffer, unsigned int num, int *error);
//OS functions
void(*_Exit)();
/****************************> Exports <****************************/
//VPAD functions
OSDynLoad_FindExport(vpad_handle, 0, "VPADRead", &VPADRead);
//OS functions
OSDynLoad_FindExport(coreinit_handle, 0, "_Exit", &_Exit);
/****************************> Function <****************************/
int error;
VPADData vpad_data;
int xpos, ypos;
int q = 1;
int r = 128;
int g = 128;
int b = 255;
int color = 2;
/* enum colors {
color_white;
color_grey;
color_lightblue;
color_lightgreen;
color_lightred;
}; all available choices */
while (1)
{
VPADRead(0, &vpad_data, 1, &error);
if (vpad_data.tpdata.touched == 1)
{
xpos = ((vpad_data.tpdata.x / 9) - 11);
ypos = ((3930 - vpad_data.tpdata.y) / 16);
drawPixel(xpos, ypos, r, g, b, 255);
flipBuffers();
drawPixel(xpos, ypos, r, g, b, 255);
flipBuffers();
}
if (vpad_data.btn_trigger & BUTTON_LEFT) //seems to pick random one, no idea why
{
if (color == 0) //white
{
color = 4; //light red
} else {
color -= 1; //go down one
}
if (color == 0){ //white
r = 255;
g = 255;
b = 255;
}
if (color == 1){ //grey
r = 128;
g = 128;
b = 128;
}
if (color == 2){ //light blue
r = 128;
g = 128;
b = 255;
}
if (color == 3){ //light green
r = 128;
g = 255;
b = 128;
}
if (color == 4){ //light red
r = 255;
g = 128;
b = 128;
}
}
if (vpad_data.btn_trigger & BUTTON_RIGHT) //seems to pick random one, no idea why
{
if (color == 4) //light red
{
color = 0; //white
} else {
color += 1; //go up one
}
if (color == 0){ //white
r = 255;
g = 255;
b = 255;
}
if (color == 1){ //grey
r = 128;
g = 128;
b = 128;
}
if (color == 2){ //light blue
r = 128;
g = 128;
b = 255;
}
if (color == 3){ //light green
r = 128;
g = 255;
b = 128;
}
if (color == 4){ //light red
r = 255;
g = 128;
b = 128;
}
}
if (vpad_data.btn_hold & BUTTON_PLUS)
{
fillScreen(0, 0, 0, 255); // black
flipBuffers();
fillScreen(0, 0, 0, 255); // second buffer
flipBuffers();
}
if (vpad_data.btn_trigger & BUTTON_HOME)
{
break; //pls exit
}
}
//WARNING: DO NOT CHANGE THIS. YOU MUST CLEAR THE FRAMEBUFFERS AND IMMEDIATELY CALL EXIT FROM THIS FUNCTION. RETURNING TO LOADER CAUSES FREEZE.
int ii=0;
for(ii;ii<2;ii++)
{
fillScreen(0,0,0,0);
flipBuffers();
}
_Exit();
}
void TFT::TFTinit (void)
{
SPI.begin();
TFT_CS_HIGH;
TFT_DC_HIGH;
INT8U i=0, TFTDriver=0;
for(i=0;i<3;i++)
{
TFTDriver = readID();
}
delay(500);
sendCMD(0x01);
delay(200);
sendCMD(0xCF);
WRITE_DATA(0x00);
WRITE_DATA(0x8B);
WRITE_DATA(0X30);
sendCMD(0xED);
WRITE_DATA(0x67);
WRITE_DATA(0x03);
WRITE_DATA(0X12);
WRITE_DATA(0X81);
sendCMD(0xE8);
WRITE_DATA(0x85);
WRITE_DATA(0x10);
WRITE_DATA(0x7A);
sendCMD(0xCB);
WRITE_DATA(0x39);
WRITE_DATA(0x2C);
WRITE_DATA(0x00);
WRITE_DATA(0x34);
WRITE_DATA(0x02);
sendCMD(0xF7);
WRITE_DATA(0x20);
sendCMD(0xEA);
WRITE_DATA(0x00);
WRITE_DATA(0x00);
sendCMD(0xC0); /* Power control */
WRITE_DATA(0x1B); /* VRH[5:0] */
sendCMD(0xC1); /* Power control */
WRITE_DATA(0x10); /* SAP[2:0];BT[3:0] */
sendCMD(0xC5); /* VCM control */
WRITE_DATA(0x3F);
WRITE_DATA(0x3C);
sendCMD(0xC7); /* VCM control2 */
WRITE_DATA(0XB7);
sendCMD(0x36); /* Memory Access Control */
WRITE_DATA(0x08);
sendCMD(0x3A);
WRITE_DATA(0x55);
sendCMD(0xB1);
WRITE_DATA(0x00);
WRITE_DATA(0x1B);
sendCMD(0xB6); /* Display Function Control */
WRITE_DATA(0x0A);
WRITE_DATA(0xA2);
sendCMD(0xF2); /* 3Gamma Function Disable */
WRITE_DATA(0x00);
sendCMD(0x26); /* Gamma curve selected */
WRITE_DATA(0x01);
sendCMD(0xE0); /* Set Gamma */
WRITE_DATA(0x0F);
WRITE_DATA(0x2A);
WRITE_DATA(0x28);
WRITE_DATA(0x08);
WRITE_DATA(0x0E);
WRITE_DATA(0x08);
WRITE_DATA(0x54);
WRITE_DATA(0XA9);
WRITE_DATA(0x43);
WRITE_DATA(0x0A);
WRITE_DATA(0x0F);
WRITE_DATA(0x00);
WRITE_DATA(0x00);
WRITE_DATA(0x00);
WRITE_DATA(0x00);
sendCMD(0XE1); /* Set Gamma */
WRITE_DATA(0x00);
WRITE_DATA(0x15);
WRITE_DATA(0x17);
WRITE_DATA(0x07);
WRITE_DATA(0x11);
WRITE_DATA(0x06);
WRITE_DATA(0x2B);
WRITE_DATA(0x56);
WRITE_DATA(0x3C);
WRITE_DATA(0x05);
WRITE_DATA(0x10);
WRITE_DATA(0x0F);
WRITE_DATA(0x3F);
WRITE_DATA(0x3F);
WRITE_DATA(0x0F);
sendCMD(0x11); /* Exit Sleep */
delay(120);
sendCMD(0x29); /* Display on */
fillScreen();
}
void clearScreen(void){
fillScreen(backgroundColor);
}
int main()
{
REG_DISPCTL = MODE3 | BG2_ENABLE;
int scene = 0;
int frameCounter = 0;
int timer = 0;
int winCondition = 0;
int pressed = 0;
int pressedLF = 0;
int next = 0;
//int timeBuffer[41];
//int d = 0;
//int count = 0;
MOVOBJ ballon = {80, 60, 0, 0, 10, RED};
while(1) // game loop
{
waitForVblank();
frameCounter++;
pressedLF = 0;
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
fillScreen(BLACK);
scene = 0;
ballon.size = 10;
}
if (scene == 0) {
titleScreen();
drawString(145, 50, "Press <ENTER> to Start", RED);
if (KEY_DOWN_NOW(BUTTON_START)) {
scene = 1;
timer = 1;
fillScreen(BLACK);
}
}
if (scene == 1) {
drawRect(ballon.row, ballon.col, ballon.size, ballon.size, RED);
drawString(130,80, "Press A!!!", RED);
drawString(20, 50, "Blow up the balloon!", RED);
if (timer % 3 == 0) {
if (winCondition == 0) {
scene = 500;
fillScreen(BLACK);
gameOver();
timer = 1;
winCondition = 0;
}
}
if (KEY_DOWN_NOW(BUTTON_A) && pressedLF == 0) {
ballon.size = ballon.size + 1;
pressedLF = 1;
}
if (ballon.size == 50) {
winCondition = 0;
scene = 700;
fillScreen(BLACK);
scene = 2;
}
}
if (scene == 2) {
drawString(10, 80, "Eat the cake!", WHITE);
if (timer == 2) {
//drawCake();
}
next = playLevel2();
if (timer % 4 == 0) {
if (winCondition == 0) {
scene = 500;
drawRect(0,0,240, 160, BLACK);
gameOver();
timer = 1;
}
}
if (next == 1) {
scene = 700;
fillScreen(BLACK);
winScreen();
}
}
if (scene == 500) {
//gameOver();
drawString(145, 50, "Better Luck Next Time!", RED);
pressed = 0;
}
if (scene == 700) {
drawString(30, 50, "Fine! You beat me...", RED);
pressed = 0;
}
if (frameCounter % 160 == 0) {
timer++;
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
uint8_t currentLED=0,idx;
uint16_t xx,yy;
uint16_t testWord;
uint8_t shifter=0;
/* Initialize LEDs on STM32F4-Discovery --------------------*/
__IO uint32_t i = 0;
uint8_t buf[255];
uint8_t len;
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED3);
// You can use these for LEDs if you use the upper 8 bits of the 16b FSMC bus to talk to the ILI9238.
// STM_EVAL_LEDInit(LED5); //GPIOD 14 -> FSMC D0. Do not use for LED, we need them to talk to the ILI9238
// STM_EVAL_LEDInit(LED6); //GPIOD 14 -> FSMC D1.
// flash the LEDs in a circle to test delayMillis(uint32_t timedelay)
STM_EVAL_LEDToggle(currentLED);
for (idx=0;idx<8;idx++)
{
STM_EVAL_LEDToggle(currentLED);
currentLED=(currentLED+1)%2;
STM_EVAL_LEDToggle(currentLED);
delayMillis(250);
}
//
// USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, &USR_cb);
// init the printf
init_printf(0,tft_putc);
// init_tft_printf(NULL,tft_putc);
// Get the 32F4 ready to talk to the TFTLCD using FSMC
initGPIO();
initFSMC();
uDelay(1000); // probably don't need this
reset();
initDisplay();
// ** Do the adafruit Demo **
// fillScreen(BLACK);
// setCursor(0, 0);
// setTextColor(CYAN);
// setTextSize(1);
// setRotation(1);
// tft_printf("Please connect to virtual COM port...");
delayMillis(2000);
testlines(CYAN);
delayMillis(2500);
testfastlines(RED, BLUE);
delayMillis(2500);
testdrawrects(GREEN);
delayMillis(2500);
testfillrects(YELLOW, MAGENTA);
delayMillis(2500);
fillScreen(BLACK);
testfillcircles(10, MAGENTA);
testdrawcircles(10, WHITE);
delayMillis(2500);
testtriangles();
delayMillis(2500);
testfilltriangles();
delayMillis(2500);
testRoundRect();
delayMillis(2500);
testFillRoundRect();
delayMillis(2500);
fillScreen(GREEN);
delayMillis(2500);
// fsmcData = 0x60020000; // sets a16
// fsmcRegister = 0x60000000; // clears a16
// printf("fsmcData:\t0x%08X\r\n",fsmcData);
// printf("fsmcRegister:\t0x%08X\r\n",fsmcRegister);
// fillScreen(BLACK);
// setCursor(0, 20);
// setTextColor(color);
// setTextSize(1);
// write("Hello World!");
// setTextSize(2);
// write(1234.56);
// setTextSize(3);
//
// println(0xDEADBEEF, HEX);
// printf("0xFF00>>8 0x%04X\r\n",0xff00>>8);
// VCP_send_str(&buf[0]);
// printf("SysTick_Config(SystemCoreClock/1000)\t %d\r\n",SysTick_Config(SystemCoreClock/1000));
// millisecondCounter=0;
// for (idx=0;idx<100;idx++)
// {
// printf("millisecondCounter:\t%d",millisecondCounter);
// }
// void delayMillis(uint32_t millis)
// {
// uint32_t target;
//
// target=millisecondCounter+millis;
// while(millisecondCounter<target);
// }
// From stm32f4_discovery.h:
// typedef enum
// {
// LED4 = 0,
// LED3 = 1,
// LED5 = 2,
// LED6 = 3
// } Led_TypeDef;
while(1)
{
for (idx=0;idx<8;idx++)
{
setRotation(idx%4);
testtext(RED);
delayMillis(1500);
}
}
}
// Game mode.
int game(){
int row = 80;
int col = 5;
int oldrow = row;
int oldcol = col;
char buffer[41];
char buffer1[41];
int distance = 0;
int oldDistance = 0;
int move[] = {-4,-3,-2,-1,0,1,2,3,4};
int numObj = 47;
int check1;
int check2;
int color = 0x33cc; // color of walls
// Initializing obstacles.
fillScreen(BLACK);
WALL obst[numObj];
for(int j=0; j<numObj; j++){
obst[j].row = 5;
obst[j].col = 5 + 5*j;
obst[j].size = 3*REDCAR_HEIGHT;
obst[j].color = color;
obst[j].gapStart = 70;
}
// Initial drawing.
for(int l=0; l<numObj; l++){
drawRect(obst[l].row, obst[l].col, obst[l].gapStart - 5, 5, obst[l].color);
drawRect(obst[l].gapStart + 3*REDCAR_HEIGHT, obst[l].col, 150-obst[l].gapStart - 3*REDCAR_HEIGHT, 5, obst[l].color);
drawRect(obst[l].gapStart, obst[l].col, 3*REDCAR_HEIGHT, 5, BLACK);
}
// Game loop
while(1){
// Decreases the gap every 50 points.
if(distance % 50 == 0){
obst[numObj-1].size = obst[numObj-1].size - 1;
}
if(KEY_DOWN_NOW(BUTTON_UP)){
row--;
if(row < 5){
row = 5;
}
}
if(KEY_DOWN_NOW(BUTTON_DOWN)){
row++;
if(row > (155 - REDCAR_HEIGHT)){
row = 155 - REDCAR_HEIGHT;
}
}
if(KEY_DOWN_NOW(BUTTON_LEFT)){
col--;
if(col < 5){
col = 5;
}
}
if(KEY_DOWN_NOW(BUTTON_RIGHT)){
col++;
if(col > (235 - REDCAR_WIDTH)){
col = 235 - REDCAR_WIDTH;
}
}
// Draws helicopter.
drawRect(oldrow, oldcol, REDCAR_HEIGHT, REDCAR_WIDTH, BLACK);
drawImage3(row, col, REDCAR_WIDTH, REDCAR_HEIGHT, redcar);
oldrow = row;
oldcol = col;
// Updates and draws the score to the screen.
distance++;
drawString(150, 5, "Distance: ", BLUE);
sprintf(buffer, "%d", distance);
sprintf(buffer1, "%d", oldDistance);
drawString(150, 60, buffer1, BLACK);
drawString(150, 60, buffer, BLUE);
oldDistance = distance;
// Moves the last obstacle up or down some random amount then moves all obstacles forward.
obst[numObj-1].gapStart = obst[numObj-1].gapStart+move[rand()%9];
if(obst[numObj-1].gapStart + obst[numObj-1].size > 150){
obst[numObj-1].gapStart = 150 - obst[numObj-1].size;
}
if(obst[numObj-1].gapStart < 5){
obst[numObj-1].gapStart = 5;
}
for(int k=0; k<numObj-1; k++){
obst[k].gapStart = obst[k+1].gapStart;
obst[k].size = obst[k+1].size;
}
// Redraws updated obstacles.
waitForVblank();
for(int l=0; l<numObj; l++){
drawRect(obst[l].row, obst[l].col, obst[l].gapStart - 5, 5, obst[l].color);
drawRect(obst[l].gapStart + obst[l].size, obst[l].col, 150-obst[l].gapStart - obst[l].size, 5, obst[l].color);
drawRect(obst[l].gapStart, obst[l].col, obst[l].size, 5, BLACK);
drawImage3(row, col, REDCAR_WIDTH, REDCAR_HEIGHT, redcar);
}
// You've won!
if(distance >= 500){
return WIN;
}
// Quitter...
if(KEY_DOWN_NOW(BUTTON_SELECT)){
return LOSE;
}
// Better luck next time!
for(int m = col/5; m<=6 + col/5; m++){
check1 = row - obst[m].gapStart;
check2 = (obst[m].gapStart + obst[m].size)-(row+REDCAR_HEIGHT);
if(check1<0 || check2<0){
return LOSE;
}
}
}
return 0;
}
int main(void) {
char str_buffer[16];
SystemCoreClockUpdate();
gpioInit();
interruptInit();
adcInit();
Chip_PMU_GetSleepFlags(LPC_PMU);
Chip_PMU_ClearSleepFlags(LPC_PMU, PMU_PCON_DPDFLAG);
Chip_SPI_Init(SPI_PORT);
SysTick_Config(Chip_Clock_GetSystemClockRate() / TICKRATE_HZ);
//StuckI2CHack();
delayms(10);
MoonLander_I2C_Init(SENSOR_I2C, MOONLANDER_I2C_100K);
delayms(100);
// Initialize sensors:
HTU21D_Init(&g_HTU21D, SENSOR_I2C);
delayms(10);
HMC5883L_Init(&g_HMC5883L, SENSOR_I2C);
delayms(10);
HMC5883L_SetRange(&g_HMC5883L, HMC5883L_RANGE_2_5);
eGFX_InitDriver();
C12832A_Init(&g_C12832A, SPI_PORT, LCD_A0_PIN, LCD_RST_PIN, LCD_SSEL);
delayms(10);
Plot_Init(&g_plot_temp, -10, 40, "Temp (C)", 0);
Plot_Init(&g_plot_rh, 0, 100, "RH", 0);
Plot_Init(&g_plot_mag, -400, 300, "uTesla", 1);
Plot_SetSpecialValue(&g_plot_mag, 9000, "OL");
Compass_Init(&g_compass);
g_left_display = DISPLAY_TEMP;
g_right_display = DISPLAY_COMPASS;
// Straight to sleep on boot:
g_go_to_sleep = 1;
// Or not:
//g_go_to_sleep = 0;
//wakeup();
while(1) {
fillScreen(0x0);
if (g_go_to_sleep) {
// Write the empty back buffer to the screen:
eGFX_Dump(&eGFX_BackBuffer, &g_C12832A);
g_ignore_switches = 1;
// Sleep!
goToSleep();
// Processor has been woken up, restart clocks, etc.:
wakeup();
delayms(SW_DEBOUNCE_MS);
g_ignore_switches = 0;
}
switch (g_left_display) {
case DISPLAY_TEMP:
Plot_Draw(&eGFX_BackBuffer, &g_plot_temp, PLOT_LEFT);
break;
case DISPLAY_RH:
Plot_Draw(&eGFX_BackBuffer, &g_plot_rh, PLOT_LEFT);
break;
case DISPLAY_MAG:
Plot_Draw(&eGFX_BackBuffer, &g_plot_mag, PLOT_LEFT);
break;
case DISPLAY_COMPASS:
Compass_Draw(&eGFX_BackBuffer, &g_compass, COMPASS_LEFT);
break;
case DISPLAY_RANGE:
eGFX_DrawString(&eGFX_BackBuffer, "Range", 24, 1, &FONT_3_5_1BPP);
sprintf(str_buffer, "%0.2f cm", getRangeCentimeters());
eGFX_DrawString(&eGFX_BackBuffer, str_buffer, 24, 13, &FONT_3_5_1BPP);
break;
default:
break;
}
switch (g_right_display) {
case DISPLAY_TEMP:
Plot_Draw(&eGFX_BackBuffer, &g_plot_temp, PLOT_RIGHT);
break;
case DISPLAY_RH:
Plot_Draw(&eGFX_BackBuffer, &g_plot_rh, PLOT_RIGHT);
break;
case DISPLAY_MAG:
Plot_Draw(&eGFX_BackBuffer, &g_plot_mag, PLOT_RIGHT);
break;
case DISPLAY_COMPASS:
Compass_Draw(&eGFX_BackBuffer, &g_compass, COMPASS_RIGHT);
break;
case DISPLAY_RANGE:
eGFX_DrawString(&eGFX_BackBuffer, "Range", 88, 1, &FONT_3_5_1BPP);
sprintf(str_buffer, "%0.2f cm", getRangeCentimeters());
eGFX_DrawString(&eGFX_BackBuffer, str_buffer, 88, 13, &FONT_3_5_1BPP);
break;
default:
break;
}
eGFX_Dump(&eGFX_BackBuffer, &g_C12832A);
}
return 0 ;
}
int main(void) {
SetMode(MODE_3 | BG2_ENABLE);
fillScreen(BLACK);
drawImage3(0, 0, STARTSCREEN_WIDTH, STARTSCREEN_HEIGHT, &startScreen[0]);
int i = 1;
while(i) {
if(keyDown(KEY_START)) {
i = 0;
}
}
fillScreen(BLACK);
int x = 120;
int y = 60;
int d = 0;
int t = 20;
int m = 10;
int s = 0;
int p = 0;
int c = 1;
u16 color = WHITE;
drawHollowRect(0,0,SCREEN_WIDTH-1, SCREEN_HEIGHT-10, color);
setPixel(x,y,color);
while(c) {
// Reset
if(keyDown(KEY_SELECT)) {
c = 0;
main();
}
// Set Direction
if(keyDown(KEY_DOWN) && (d != 2)){
d = 0;
} else if(keyDown(KEY_RIGHT) && (d != 3)) {
d = 1;
} else if(keyDown(KEY_UP) && (d != 0)) {
d = 2;
} else if(keyDown(KEY_LEFT) && (d != 1)) {
d = 3;
}
// Move snake
if(d==0) {
y++;
} else if(d==1) {
x++;
} else if(d==2) {
y--;
} else if(d==3) {
x--;
}
// Check for collisions
if(videoBuffer[OFFSET(x,y)] != BLACK) {
fillScreen(BLACK);
drawImage3(0, 0, GAMEOVER_WIDTH, GAMEOVER_HEIGHT, &gameOver[0]);
drawImage3(100, 70, RETRY_WIDTH, RETRY_HEIGHT, &retry[0]);
int i = 1;
while(i) {
if(keyDown(KEY_START)) {
while(keyDown(KEY_START)) {
}
i = 0;
}
}
c = 0;
main();
}
// Draw snake
setPixel(x,y,color);
delay(t);
// Increase score
s++;
s = s%m;
// Set Speed
if(s == 0) {
t--;
m = m + m/3;
drawRect(1 + p,152,2,6,WHITE);
p = p + 4;
}
// Wait for V blank
waitForVblank();
}
return 0;
}
void _start()
{
/****************************> Fix Stack <****************************/
//Load a good stack
asm(
"lis %r1, 0x1ab5 ;"
"ori %r1, %r1, 0xd138 ;"
);
/****************************> Get Handles <****************************/
//Get a handle to coreinit.rpl
unsigned int coreinit_handle;
OSDynLoad_Acquire("coreinit.rpl", &coreinit_handle);
/****************************> External Prototypes <****************************/
//OSScreen functions
void(*OSScreenInit)();
unsigned int(*OSScreenGetBufferSizeEx)(unsigned int bufferNum);
unsigned int(*OSScreenSetBufferEx)(unsigned int bufferNum, void * addr);
//OS Thread functions
long(*OSCheckActiveThreads)();
//Misc OS functions
void(*OSRestartGame)();
//OS Memory functions
void(*DCFlushRange)(void *buffer, uint32_t length);
/****************************> Exports <****************************/
//OSScreen functions
OSDynLoad_FindExport(coreinit_handle, 0, "OSScreenInit", &OSScreenInit);
OSDynLoad_FindExport(coreinit_handle, 0, "OSScreenGetBufferSizeEx", &OSScreenGetBufferSizeEx);
OSDynLoad_FindExport(coreinit_handle, 0, "OSScreenSetBufferEx", &OSScreenSetBufferEx);
//OSThread functions
OSDynLoad_FindExport(coreinit_handle, 0, "OSCheckActiveThreads", &OSCheckActiveThreads);
//Misc OS functions
OSDynLoad_FindExport(coreinit_handle, 0, "OSRestartGame", &OSRestartGame);
//OS Memory functions
OSDynLoad_FindExport(coreinit_handle, 0, "DCFlushRange", &DCFlushRange);
/****************************> Initial Setup <****************************/
//Restart the web browser. This stops active threads for browser. Browser GUI thread runs on CPU0.
OSRestartGame();
//Wait for the web browser to start closing by observing the total number of threads.
long initialNumberOfThreads = OSCheckActiveThreads();
long currentNumberOfThreads = OSCheckActiveThreads();
while (initialNumberOfThreads - currentNumberOfThreads < 3)
{
currentNumberOfThreads = OSCheckActiveThreads();
}
//Call the Screen initilzation function.
OSScreenInit();
//Grab the buffer size for each screen (TV and gamepad)
int buf0_size = OSScreenGetBufferSizeEx(0);
int buf1_size = OSScreenGetBufferSizeEx(1);
//Set the buffer area.
OSScreenSetBufferEx(0, (void *)0xF4000000);
OSScreenSetBufferEx(1, (void *)0xF4000000 + buf0_size);
//Clear both framebuffers.
int ii = 0;
for (ii; ii < 2; ii++)
{
fillScreen(0,0,0,0);
flipBuffers();
}
//Jump to entry point.
_entryPoint();
}
int main_prog(void) { // This thread is statically created (as configured in the kernel configuration) and has priority 0 (This is the highest possible)
int ret;
print("-- Entering main() --\r\n");
initTFT();
xil_printf("Finish initializing TFT\r\n");
fillScreen();
// initialize the semaphore
if( sem_init(&sem, 1, 2) < 0 ) {
print("Error while initializing semaphore sem.\r\n");
}
//start thread 1
ret = pthread_create (&tid1, NULL, (void*)thread_func_1, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_1...\r\n", ret);
}
else {
xil_printf ("Thread 1 launched with ID %d \r\n",tid1);
}
//start thread 2
ret = pthread_create (&tid2, NULL, (void*)thread_func_2, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_2...\r\n", ret);
}
else {
xil_printf ("Thread 2 launched with ID %d \r\n",tid2);
}
//start thread 3
ret = pthread_create (&tid3, NULL, (void*)thread_func_3, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_3...\r\n", ret);
}
else {
xil_printf ("Thread 3 launched with ID %d \r\n",tid3);
}
//start thread 4
ret = pthread_create (&tid4, NULL, (void*)thread_func_4, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_4...\r\n", ret);
}
else {
xil_printf ("Thread 4 launched with ID %d \r\n",tid4);
}
//start thread 5
ret = pthread_create (&tid5, NULL, (void*)thread_func_5, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_5...\r\n", ret);
}
else {
xil_printf ("Thread 5 launched with ID %d \r\n",tid5);
}
ret = pthread_create (&tid6, NULL, (void*)thread_func_6, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_6...\r\n", ret);
}
else {
xil_printf ("Thread 6 launched with ID %d \r\n",tid6);
}
ret = pthread_create (&tid7, NULL, (void*)thread_func_7, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_7...\r\n", ret);
}
else {
xil_printf ("Thread 7 launched with ID %d \r\n",tid7);
}
ret = pthread_create (&tid8, NULL, (void*)thread_func_8, NULL);
if (ret != 0) {
xil_printf ("-- ERROR (%d) launching thread_func_8...\r\n", ret);
}
else {
xil_printf ("Thread 8 launched with ID %d \r\n",tid8);
}
}
int main(int argc, char *argv[])
{
#ifdef __XENO__
struct sched_param param = { 99 };
mlockall(MCL_CURRENT | MCL_FUTURE);
pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
#endif
if (!raspi_map_hw()) {
perror("Could not map hardware registers");
exit(1);
}
#ifdef __XENO__
pthread_set_mode_np(0, PTHREAD_WARNSW|PTHREAD_PRIMARY);
#endif
// ILI9341(int8_t _CS, int8_t _DC, int8_t _RST, int8_t _BL, int8_t _MOSI, int8_t _SCLK, int8_t _MISO);
ILI9341 tft = ILI9341(PIN_CS, PIN_DC, PIN_RESET, PIN_BL, PIN_MOSI, PIN_SCLK, PIN_MISO);
printf("Setting up TFT...\n");
tft.begin();
g_HWSPI=0;
if (argc > 1)
{
g_HWSPI=1;
}
if (g_HWSPI)
{
printf("Setup HW SPI parameters...\n");
}
else
{
printf("Setup SW SPI (Bit-Banger) parameters...\n");
}
printf("HWReset done, initializing display\n") ;
int i, colors[8] = { ILI9341_BLACK, ILI9341_BLUE, ILI9341_RED, ILI9341_GREEN, ILI9341_CYAN, ILI9341_MAGENTA, ILI9341_WHITE, ILI9341_YELLOW };
begin();
printf("Done intializing, now fill screens...\n");
for (i=0;i<8 ;i++ )
{
fillScreen(ILI9341_BLACK);
//sleep(1);
fillScreen(colors[i]);
//sleep (2);
}
printf("Setting up for HWreset\n");
printf("Benchmark\tTime (microseconds)\n");
printf("Screen fill\t%f\n", testFillScreen());
sl_delay(500);
printf("Text\t%f\n",testText());
sl_delay(3000);
printf("Lines\t%f\n",testLines(ILI9341_CYAN));
sl_delay(500);
printf("Horiz/Vert Lines\t%f\n", testFastLines(ILI9341_RED, ILI9341_BLUE));
sl_delay(500);
printf("Rectangles (outline)\t%f",testRects(ILI9341_GREEN));
sl_delay(500);
printf("Rectangles (filled)\t%f\n", testFilledRects(ILI9341_YELLOW, ILI9341_MAGENTA));
sl_delay(500);
printf("Circles (filled)\t%f\n", testFilledCircles(10, ILI9341_MAGENTA));
printf("Circles (outline)\t%f\n", testCircles(10, ILI9341_WHITE));
sl_delay(500);
printf("Triangles (outline)\t%f\n", testTriangles());
sl_delay(500);
printf("Triangles (filled)\t%f\n", testFilledTriangles());
sl_delay(500);
printf("Rounded rects (outline)\t%f\n", testRoundRects());
sl_delay(500);
printf("Rounded rects (filled)\t%f\n", testFilledRoundRects());
sl_delay(500);
printf("Done!\n");
for(uint8_t rotation=0; rotation<4; rotation++)
{
tft.setRotation(rotation);
testText();
sl_delay(1000);
}
#ifdef __XENO__
pthread_set_mode_np(PTHREAD_WARNSW, 0);
#endif
return 1;
}
void TFT_ILI9163C::chipInit() {
uint8_t i;
#if defined(__GAMMASET1)
const uint8_t pGammaSet[15]= {0x36,0x29,0x12,0x22,0x1C,0x15,0x42,0xB7,0x2F,0x13,0x12,0x0A,0x11,0x0B,0x06};
const uint8_t nGammaSet[15]= {0x09,0x16,0x2D,0x0D,0x13,0x15,0x40,0x48,0x53,0x0C,0x1D,0x25,0x2E,0x34,0x39};
#elif defined(__GAMMASET2)
const uint8_t pGammaSet[15]= {0x3F,0x21,0x12,0x22,0x1C,0x15,0x42,0xB7,0x2F,0x13,0x02,0x0A,0x01,0x00,0x00};
const uint8_t nGammaSet[15]= {0x09,0x18,0x2D,0x0D,0x13,0x15,0x40,0x48,0x53,0x0C,0x1D,0x25,0x2E,0x24,0x29};
#elif defined(__GAMMASET3)
const uint8_t pGammaSet[15]= {0x3F,0x26,0x23,0x30,0x28,0x10,0x55,0xB7,0x40,0x19,0x10,0x1E,0x02,0x01,0x00};
//&const uint8_t nGammaSet[15]= {0x00,0x19,0x1C,0x0F,0x14,0x0F,0x2A,0x48,0x3F,0x06,0x1D,0x21,0x3D,0x3F,0x3F};
const uint8_t nGammaSet[15]= {0x09,0x18,0x2D,0x0D,0x13,0x15,0x40,0x48,0x53,0x0C,0x1D,0x25,0x2E,0x24,0x29};
#else
const uint8_t pGammaSet[15]= {0x3F,0x25,0x1C,0x1E,0x20,0x12,0x2A,0x90,0x24,0x11,0x00,0x00,0x00,0x00,0x00};
const uint8_t nGammaSet[15]= {0x20,0x20,0x20,0x20,0x05,0x15,0x00,0xA7,0x3D,0x18,0x25,0x2A,0x2B,0x2B,0x3A};
#endif
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_cont(CMD_SWRESET);//software reset
delay(500);
writecommand_cont(CMD_SLPOUT);//exit sleep
delay(5);
writecommand_cont(CMD_PIXFMT);//Set Color Format 16bit
writedata8_cont(0x05);
delay(5);
writecommand_cont(CMD_GAMMASET);//default gamma curve 3
writedata8_cont(0x08);//0x04
delay(1);
writecommand_cont(CMD_GAMRSEL);//Enable Gamma adj
writedata8_cont(0x01);
delay(1);
writecommand_cont(CMD_NORML);
writecommand_cont(CMD_DFUNCTR);
writedata8_cont(0b11111111);//
writedata8_cont(0b00000110);//
writecommand_cont(CMD_PGAMMAC);//Positive Gamma Correction Setting
for (i=0;i<15;i++){
writedata8_cont(pGammaSet[i]);
}
writecommand_cont(CMD_NGAMMAC);//Negative Gamma Correction Setting
for (i=0;i<15;i++){
writedata8_cont(nGammaSet[i]);
}
writecommand_cont(CMD_FRMCTR1);//Frame Rate Control (In normal mode/Full colors)
writedata8_cont(0x08);//0x0C//0x08
writedata8_cont(0x02);//0x14//0x08
delay(1);
writecommand_cont(CMD_DINVCTR);//display inversion
writedata8_cont(0x07);
delay(1);
writecommand_cont(CMD_PWCTR1);//Set VRH1[4:0] & VC[2:0] for VCI1 & GVDD
writedata8_cont(0x0A);//4.30 - 0x0A
writedata8_cont(0x02);//0x05
delay(1);
writecommand_cont(CMD_PWCTR2);//Set BT[2:0] for AVDD & VCL & VGH & VGL
writedata8_cont(0x02);
delay(1);
writecommand_cont(CMD_VCOMCTR1);//Set VMH[6:0] & VML[6:0] for VOMH & VCOML
writedata8_cont(0x50);//0x50
writedata8_cont(99);//0x5b
delay(1);
writecommand_cont(CMD_VCOMOFFS);
writedata8_cont(0);//0x40
delay(1);
writecommand_cont(CMD_CLMADRS);//Set Column Address
/*
writedata8_cont(0x00);
writedata8_cont(0X00);
writedata8_cont(0X00);
writedata8_cont(_GRAMWIDTH);
*/
writedata16_cont(0x00);
writedata16_cont(_GRAMWIDTH);
writecommand_cont(CMD_PGEADRS);//Set Page Address
/*
writedata8_cont(0x00);
writedata8_cont(0X00);
writedata8_cont(0X00);
writedata8_last(_GRAMHEIGH);
*/
writedata16_cont(0x00);
writedata16_last(_GRAMHEIGH);
endProc();
colorSpace(_colorspaceData);
setRotation(0);
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_cont(CMD_DISPON);//display ON
delay(1);
writecommand_last(CMD_RAMWR);//Memory Write
SPI.endTransaction();
delay(1);
#else
writecommand(CMD_SWRESET);//software reset
delay(500);
writecommand(CMD_SLPOUT);//exit sleep
delay(5);
writecommand(CMD_PIXFMT);//Set Color Format 16bit
writedata(0x05);
delay(5);
writecommand(CMD_GAMMASET);//default gamma curve 3
writedata(0x04);//0x04
delay(1);
writecommand(CMD_GAMRSEL);//Enable Gamma adj
writedata(0x01);
delay(1);
writecommand(CMD_NORML);
writecommand(CMD_DFUNCTR);
writedata(0b11111111);//
writedata(0b00000110);//
writecommand(CMD_PGAMMAC);//Positive Gamma Correction Setting
for (i=0;i<15;i++){
writedata(pGammaSet[i]);
}
writecommand(CMD_NGAMMAC);//Negative Gamma Correction Setting
for (i=0;i<15;i++){
writedata(nGammaSet[i]);
}
writecommand(CMD_FRMCTR1);//Frame Rate Control (In normal mode/Full colors)
writedata(0x08);//0x0C//0x08
writedata(0x02);//0x14//0x08
delay(1);
writecommand(CMD_DINVCTR);//display inversion
writedata(0x07);
delay(1);
writecommand(CMD_PWCTR1);//Set VRH1[4:0] & VC[2:0] for VCI1 & GVDD
writedata(0x0A);//4.30 - 0x0A
writedata(0x02);//0x05
delay(1);
writecommand(CMD_PWCTR2);//Set BT[2:0] for AVDD & VCL & VGH & VGL
writedata(0x02);
delay(1);
writecommand(CMD_VCOMCTR1);//Set VMH[6:0] & VML[6:0] for VOMH & VCOML
writedata(0x50);//0x50
writedata(99);//0x5b
delay(1);
writecommand(CMD_VCOMOFFS);
writedata(0);//0x40
delay(1);
writecommand(CMD_CLMADRS);//Set Column Address
//writedata(0x00);
//writedata(0X00);
//writedata(0X00);
//writedata(_GRAMWIDTH);
writedata16(0x00);
writedata16(_GRAMWIDTH);
writecommand(CMD_PGEADRS);//Set Page Address
//writedata(0x00);
//writedata(0X00);
//writedata(0X00);
//writedata(_GRAMHEIGH);
writedata16(0X00);
writedata16(_GRAMHEIGH);
colorSpace(_colorspaceData);
setRotation(0);
writecommand(CMD_DISPON);//display ON
delay(1);
writecommand(CMD_RAMWR);//Memory Write
delay(1);
#endif
fillScreen(BLACK);
}
void ArduRCT_Graphics::_executeMacroCommand(ardurct_graphicsMacroCommand_t *mc, int16_t x, int16_t y, uint16_t scaleMul, uint16_t scaleDiv) {
uint8_t group = mc->cmd & GRAPHICS_MACRO_CMD_GROUP_MASK;
// presets
if (group == GRAPHICS_MACRO_CMD_GROUP_PRESET) {
if (mc->cmd == GRAPHICS_MACRO_CMD_PRESET_FOREGROUND) _mForegroundColor = mc->color;
else if (mc->cmd == GRAPHICS_MACRO_CMD_PRESET_BACKGROUND) _mBackgroundColor = mc->color;
else if (mc->cmd == GRAPHICS_MACRO_CMD_PRESET_THICKNESS) {
_mThickness = mc->param[GRAPHICS_MACRO_PARAM_THICKNESS];
_mIsThicknessScalable = mc->param[GRAPHICS_MACRO_PARAM_THICKNESS_IS_SCALABLE] != 0;
} else if (mc->cmd == GRAPHICS_MACRO_CMD_PRESET_ERASE) fillScreen(_mBackgroundColor);
else if (mc->cmd == GRAPHICS_MACRO_CMD_PRESET_FONT) {
_mFontSize = mc->param[GRAPHICS_MACRO_PARAM_FONT_SIZE];
_mIsFontBold = (mc->param[GRAPHICS_MACRO_PARAM_FONT_IS_BOLD] != 0);
_mIsFontOverlay = (mc->param[GRAPHICS_MACRO_PARAM_FONT_IS_OVERLAY] != 0);
} else if (mc->cmd == GRAPHICS_MACRO_CMD_PRESET_SCALE) {
_mScaleMul = mc->param[GRAPHICS_MACRO_PARAM_SCALE_MUL];
_mScaleDiv = 1;
if ((mc->nbParams > 1) && (mc->param[GRAPHICS_MACRO_PARAM_SCALE_DIV] != 0)) _mScaleDiv = mc->param[GRAPHICS_MACRO_PARAM_SCALE_DIV];
}
#ifdef GRAPHICS_MACRO_DEBUG
Serial.println("preset");
#endif
return;
}
int32_t sMul = _mScaleMul;
sMul = sMul * (scaleMul == 0 ? 1 : scaleMul);
int32_t sDiv = _mScaleDiv;
sDiv = sDiv * (scaleDiv == 0 ? 1 : scaleDiv);
int32_t sX = mc->param[GRAPHICS_MACRO_PARAM_X1];
sX = sX * sMul/sDiv + x;
int32_t sY = mc->param[GRAPHICS_MACRO_PARAM_Y1];
sY = sY * sMul/sDiv + y;
int32_t sThickness = _mThickness;
if (_mIsThicknessScalable) sThickness = sThickness * sMul/sDiv;
// lines
if (group == GRAPHICS_MACRO_CMD_GROUP_LINE) {
int32_t sX2, sY2;
if (mc->nbParams < 2) return;
if (mc->cmd == GRAPHICS_MACRO_CMD_LINE) {
if (mc->nbParams > 2) {
sX2 = mc->param[GRAPHICS_MACRO_PARAM_X2];
sX2 = x + sX2 * sMul/sDiv;
sY2 = mc->param[GRAPHICS_MACRO_PARAM_Y2];
sY2 = y + sY2 * sMul/sDiv;
// p2 becomes the end point
_mX = mc->param[GRAPHICS_MACRO_PARAM_X2];
_mY = mc->param[GRAPHICS_MACRO_PARAM_Y2];
} else {
sX2 = sX;
sY2 = sY;
sX = _mX;
sX = x + sX * sMul/sDiv;
sY = _mY;
sY = y + sY * sMul/sDiv;
// p1 becomes the end point
_mX = mc->param[GRAPHICS_MACRO_PARAM_X1];
_mY = mc->param[GRAPHICS_MACRO_PARAM_Y1];
}
} else {
// delta values
if (mc->nbParams > 2) {
// p2 = p1+delta
sX2 = mc->param[GRAPHICS_MACRO_PARAM_X1] + mc->param[GRAPHICS_MACRO_PARAM_X2];
sX2 = x + sX2 * sMul/sDiv;
sY2 = mc->param[GRAPHICS_MACRO_PARAM_Y1] + mc->param[GRAPHICS_MACRO_PARAM_Y2];
sY2 = y + sY2 * sMul/sDiv;
// p1+delta becomes the end point
_mX = mc->param[GRAPHICS_MACRO_PARAM_X1] + mc->param[GRAPHICS_MACRO_PARAM_X2];
_mY = mc->param[GRAPHICS_MACRO_PARAM_Y1] + mc->param[GRAPHICS_MACRO_PARAM_Y2];
} else {
// p2 = old_point+delta
sX2 = _mX + mc->param[GRAPHICS_MACRO_PARAM_X1];
sX2 = x + sX2 * sMul/sDiv;
sY2 = _mY + mc->param[GRAPHICS_MACRO_PARAM_Y1];
sY2 = y + sY2 * sMul/sDiv;
sX = _mX;
sX = x + sX * sMul/sDiv;
sY = _mY;
sY = y + sY * sMul/sDiv;
// old_point+delta becomes the end point
_mX += mc->param[GRAPHICS_MACRO_PARAM_X1];
_mY += mc->param[GRAPHICS_MACRO_PARAM_Y1];
}
}
#ifdef GRAPHICS_MACRO_DEBUG
Serial.print("line "); Serial.print(sX); Serial.print(" "); Serial.print(sY); Serial.print(" ");
Serial.print(sX2); Serial.print(" "); Serial.println(sY2);
#endif
drawLine(sX, sY, sX2, sY2, _mForegroundColor, sThickness, false);
return;
}
// arcs
if (group == GRAPHICS_MACRO_CMD_GROUP_ARC) {
if (mc->nbParams < 1) return;
boolean reversed = (mc->cmd == GRAPHICS_MACRO_CMD_ARC_REVERSED) || (mc->cmd == GRAPHICS_MACRO_CMD_ARC_FILLED_REVERSED);
int32_t sRadius = 0;
if (mc->nbParams == 1) {
sRadius = mc->param[GRAPHICS_MACRO_PARAM_ARC_1];
sRadius = sRadius * sMul/sDiv;
int32_t sArcStartX = _getArcEnd(sRadius, mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], !reversed, true);
int32_t sArcStartY = _getArcEnd(sRadius, mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], !reversed, false);
int32_t sArcEndX = _getArcEnd(sRadius, mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], reversed, true);
int32_t sArcEndY = _getArcEnd(sRadius, mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], reversed, false);
sX = _mX;
sX = x + sX * sMul/sDiv - sArcStartX;
sY = _mY;
sY = y + sY * sMul/sDiv - sArcStartY;
_mX += sArcEndX - sArcStartX;
_mY += sArcEndY - sArcStartY;
} else if (mc->nbParams == 3) {
sRadius = mc->param[GRAPHICS_MACRO_PARAM_ARC_3];
sRadius = sRadius * sMul/sDiv;
_mX = mc->param[GRAPHICS_MACRO_PARAM_X1] + _getArcEnd(mc->param[GRAPHICS_MACRO_PARAM_ARC_3], mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], reversed, true);
_mY = mc->param[GRAPHICS_MACRO_PARAM_Y1] + _getArcEnd(mc->param[GRAPHICS_MACRO_PARAM_ARC_3], mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], reversed, false);
} else return;
if ((mc->cmd == GRAPHICS_MACRO_CMD_ARC_REVERSED) || (mc->cmd == GRAPHICS_MACRO_CMD_ARC))
drawArc(sX, sY, sRadius, mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], _mForegroundColor, sThickness, false);
else fillArc(sX, sY, sRadius, mc->param[GRAPHICS_MACRO_PARAM_ARC_OCTANT], _mForegroundColor, false);
#ifdef GRAPHICS_MACRO_DEBUG
Serial.print("arc "); Serial.print(sX); Serial.print(" "); Serial.print(sY); Serial.print(" "); Serial.println(sRadius);
#endif
return;
}
// circles
if (group == GRAPHICS_MACRO_CMD_GROUP_CIRCLE) {
// we need at least 3 parameters
if (mc->nbParams < 3) return;
int32_t sRadius = mc->param[GRAPHICS_MACRO_PARAM_RADIUS];
sRadius = sRadius * sMul/sDiv;
if (mc->cmd == GRAPHICS_MACRO_CMD_CIRCLE) drawCircle(sX, sY, sRadius, _mForegroundColor, sThickness, false);
else fillCircle(sX, sY, sRadius, _mForegroundColor, false);
#ifdef GRAPHICS_MACRO_DEBUG
Serial.print("circle "); Serial.print(sX); Serial.print(" "); Serial.print(sY); Serial.print(" "); Serial.println(sRadius);
#endif
return;
}
// rectangles
if (group == GRAPHICS_MACRO_CMD_GROUP_RECTANGLE) {
// we need at least 4 parameters
if (mc->nbParams < 4) return;
int32_t sWidth = mc->param[GRAPHICS_MACRO_PARAM_WIDTH];
sWidth = sWidth * sMul/sDiv;
int32_t sHeight = mc->param[GRAPHICS_MACRO_PARAM_HEIGHT];
sHeight = sHeight * sMul/sDiv;
if (mc->cmd == GRAPHICS_MACRO_CMD_RECTANGLE) drawRectangle(sX, sY, sWidth, sHeight, _mForegroundColor, sThickness, false);
else if (mc->cmd == GRAPHICS_MACRO_CMD_RECTANGLE_FILLED) fillRectangle(sX, sY, sWidth, sHeight, _mForegroundColor, false);
#ifdef GRAPHICS_MACRO_DEBUG
Serial.print("rectangle "); Serial.print(sX); Serial.print(" "); Serial.print(sY); Serial.print(" "); Serial.print(sWidth); Serial.print(" "); Serial.println(sHeight);
#endif
// we need at least 1 more parameter to display the rounded rectangle
if (mc->nbParams < 5) return;
int32_t sRadius = mc->param[GRAPHICS_MACRO_PARAM_ROUNDING];
sRadius = sRadius * sMul/sDiv;
if (mc->cmd == GRAPHICS_MACRO_CMD_RECTANGLE_ROUNDED) drawRoundedRectangle(sX, sY, sWidth, sHeight, sRadius, _mForegroundColor, sThickness, false);
else if (mc->cmd == GRAPHICS_MACRO_CMD_RECTANGLE_ROUNDED_FILLED) fillRoundedRectangle(sX, sY, sWidth, sHeight, sRadius, _mForegroundColor, false);
return;
}
// triangles
if (group == GRAPHICS_MACRO_CMD_GROUP_TRIANGLE) {
// we need at least 6 parameters
if (mc->nbParams < 6) return;
int32_t sX2 = mc->param[GRAPHICS_MACRO_PARAM_X2];
sX2 = x + sX2 * sMul/sDiv;
int32_t sY2 = mc->param[GRAPHICS_MACRO_PARAM_Y2];
sY2 = y + sY2 * sMul/sDiv;
int32_t sX3 = mc->param[GRAPHICS_MACRO_PARAM_X3];
sX3 = x + sX3 * sMul/sDiv;
int32_t sY3 = mc->param[GRAPHICS_MACRO_PARAM_Y3];
sY3 = y + sY3 * sMul/sDiv;
if (mc->cmd == GRAPHICS_MACRO_CMD_TRIANGLE) drawTriangle(sX, sY, sX2, sY2, sX3, sY3, _mForegroundColor, sThickness, false);
else if (mc->cmd == GRAPHICS_MACRO_CMD_TRIANGLE_FILLED) fillTriangle(sX, sY, sX2, sY2, sX3, sY3, _mForegroundColor, false);
#ifdef GRAPHICS_MACRO_DEBUG
Serial.print("triangle "); Serial.print(sX); Serial.print(" "); Serial.print(sY); Serial.print(" "); Serial.print(sX2); Serial.print(" "); Serial.print(sY2);
Serial.print(" "); Serial.print(sX3); Serial.print(" "); Serial.println(sY3);
#endif
return;
}
// strings
if (mc->cmd == GRAPHICS_MACRO_CMD_STRING) {
if (mc->nbParams < 2) return;
int bc = _backgroundColor;
if (!_mIsFontOverlay) setBackgroundColor(_mBackgroundColor);
drawString((char *)mc->text, sX, sY, _mForegroundColor, _mFontSize, _mIsFontBold, _mIsFontOverlay, false);
if (!_mIsFontOverlay) setBackgroundColor(bc);
#ifdef GRAPHICS_MACRO_DEBUG
Serial.print("text "); Serial.println((char *)mc->text);
#endif
return;
}
// executes
if (group == GRAPHICS_MACRO_CMD_GROUP_EXECUTE) {
if (mc->param[GRAPHICS_MACRO_PARAM_MACRO_NUMBER] >= GRAPHICS_MACRO_MAX_NUMBER) return;
// read the length in the EEPROM allocation table
int length = eeprom_read_uint8_t(mc->param[GRAPHICS_MACRO_PARAM_MACRO_NUMBER]);
if (length == 0xFF) return;
// read the EEPROM pointers table to get the start
int start = GRAPHICS_MACRO_MAX_NUMBER + mc->param[GRAPHICS_MACRO_PARAM_MACRO_NUMBER] * GRAPHICS_MACRO_MAX_SIZE;
// get the compressed macro
uint8_t buffer[GRAPHICS_MACRO_MAX_SIZE];
uint8_t i=0;
while (i < length) {
buffer[i] = eeprom_read_uint8_t(start+i);
i++;
}
buffer[i] = 0;
ardurct_graphicsMacroCommand_t emc;
// uncompress the macro commands and execute them
if (mc->cmd == GRAPHICS_MACRO_CMD_EXECUTE_WITH_RESET) _initializeMacros();
i = 0;
while (i < length) {
int8_t len = _uncompressMacroCommand(buffer, i, &emc);
if (len == GRAPHICS_MACRO_FORMAT_ERROR) return;
_executeMacroCommand(&emc, x, y, scaleMul, scaleDiv);
i = len;
}
}
}
/* Main Function */
int main( int argc, char *argv[] )
{
//Color constants' initilizations
BLACK = makeColour( 0, 0, 0 );
WHITE = makeColour(63,63,63 );
RED = makeColour(63, 0, 0 );
GREEN = makeColour( 0,63, 0 );
BLUE = makeColour( 0, 0,63 );
//Initializations
initInterrupts();
initScreen();
initChars();
//Enable Interrupts
enableBalloonIRQ(1000*ONE_MS, balloonISR );
int keys_to_watch = 0x04 | 0x02 ;
enableKeyIRQ( keys_to_watch, keyISR );
// fillScreen(BLACK);
int i = 0;
welcomeMessage();
mouse_status = resetPS2();
int left, right;
int lastTime;
while(1)
{
//in case of losing (past 20 misses)
if(missed >= MAX_MISS)
{
disableInterrupt(IRQ_COUNTER);
fillScreen(RED);
emptyScreen();
printStr(10, 10, "Too many misses...");
printStr(14, 13, "GAME OVER!");
printStr(8, 16, "Press KEY2 to restart");
for(i = 0; i < 30000000; i++);
// while(missed >= 20);
// printStr(8, 20, "HOOOOOORAY");
enableInterrupt(IRQ_COUNTER);
printStr(10, 10, " ");
printStr(14, 13, " ");
printStr(8, 16, " ");
}
drawChar (1, 6, ' ');
disableInterrupt(IRQ_COUNTER);
if (*pSWITCH != 0)
{
if (*pSWITCH&1)
{
increment = 1;
circleRad = 30;
}
else if (*pSWITCH&2)
{
increment = 2;
circleRad = 20;
}
else if (*pSWITCH&4)
{
increment = 3;
circleRad = 15;
}
}
else
{
increment = 1;
circleRad = 30;
}
enableInterrupt(IRQ_COUNTER);
/// MUSIC PLAYER ///
// drawChar (1, 5, 16);
if(musicCounter == 0)
{
left = 0;
right = 1;
}
if(musicCounter < musicLength/4)
{
i = musicCounter;
for(i; i<musicCounter+200; i++)
{
playMusic(music[left], music[right]);
left+=2;
right+=2;
}
musicCounter += 200;
}
else
{
musicCounter = 0;
left = 0;
right = 1;
}
/// MUSIC ///
if ( mouse_status == PS2_MOUSE )
{
// drawChar (1, 5, 22);
if( getMouseMotion( &dxMouse, &dyMouse, &mouse_button ) )
{
if( mouse_button & MOUSE_BUTTON1 )
{
if(getColor(xMouse+1, yMouse) == RED)
{
score += increment;
drawCircle(xCircle, yCircle, 30, BLACK);
/// SOUND EFFECT ///
int sleft = 0;
int sright = 1;
int i;
for(i=0; i<effectLength/4; i++)
{
playMusic(effect[sleft], effect[sright]);
sleft+=2;
sright+=2;
}
sleft = 0;
sright = 1;
/// SOUND EFFECT ///
}
else
{
if(time != lastTime)
{
missed++;
time = lastTime;
}
}
}
/* if( mouse_button & MOUSE_BUTTON2 )
fillScreen( BLACK );
if( mouse_button & MOUSE_BUTTON3 )
{
printStr(17, 13, "PAUSED!");
disableInterrupts(IRQ_COUNTER);
while( 1 )
{
if( mouse_button & MOUSE_BUTTON2 )
{
enableInterrupts(IRQ_COUNTER);
printStr(17, 13, " ");
break;
}
}
}
*/
if(getColor(xMouse+1, yMouse) == RED)
dragColor = RED;
else
dragColor = BLACK;
drawPixel( xMouse, yMouse, dragColor );
xMouse += dxMouse;
yMouse -= dyMouse;
xMouse = max( 0, min( xMouse, MAX_X_PIXELS-1 ) );
yMouse = max( 0, min( yMouse, MAX_Y_PIXELS-1 ) );
drawPixel( xMouse, yMouse, WHITE );
//drawCursor(xMouse, yMouse);
}
}
}
return 0;
}
/* This ISR gets called whenever a KEY is pressed down:
KEY1 restarts the program
KEY2 starts a new game after a GAME OVER
*/
void keyISR()
{
/* remember: no waiting in an ISR */
int keypress = *pKEY_EDGECAPTURE;
int i = 0;
int x, y;
//Reset Key
if( keypress & 0x02 )
{
score = 0;
missed = 0;
time = 0;
emptyScreen();
fillScreen(BLUE);
printStr(12, 15, "GAME RESTARTED!");
for(i = 0; i < 30000000; i++);
printStr(12, 15, " ");
}
//New game key
if( keypress & 0x04 && missed >= MAX_MISS)
{
score = 0;
missed = 0;
time = 0;
emptyScreen();
fillScreen(BLUE);
printStr(7, 15, "Good Luck in the new game!");
for(i = 0; i < 30000000; i++);
printStr(7, 15, " ");
}
/* clear source of KEY interrupt before returning */
*pKEY_EDGECAPTURE = 0;
}
