⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 juicebox.c.bak

📁 An complete pmp solution for mattel juicebox player. Using crossworks for arm.
💻 BAK
📖 第 1 页 / 共 2 页
字号:
    u08 *addr2 = addr0;
    u32 ix, iy, x, y, i, a;
    xTRectangle xFirstLine;
	xFirstLine.x1 = 70;
	xFirstLine.x2 = 107;
    xFirstLine.y1 = 0;
    xFirstLine.y2 = 8;
    
	//while ((*pdatg)== _ATREST);

			  
    while (1) {
        switch (*pdatg)
        {
        case _FORWARD:
          {
          sector++;
          if (sector>260000) sector=0;
          addr = addr0;
          addr2 = addr0;
          for (i = 0; i<512; i++) 
            {
            *addr = 0x00;
             addr++;
             }
          addr = addr0;
          addr2 = addr0;
          
          
          if (wMMCReset()!=0) 
		     {wClear (xLCD, 0x0F00);
              wDrawString(xLCD, xFont, "Init Failed",xRLCD, dwShift(0, 0), 0x0FF);}
            else
            {
            a=wMMCReadSector(sector,addr);
            if (a!=0) 
              {
              wClear (xLCD, 0x0000);
              wDrawString(xLCD, xFont, "Got error",xRLCD, dwShift(0, 0), 0x0FF);
              wDrawHex8(xLCD, xFont, a, xRLCD, dwShift(100, 7), 0x0FF);
              }
              else
              {
			  //wClear (xLCD, 0x0000);
			  if ((sector&0x000000FF) == 0x00000000)
			    {
		         wFloodFill (xLCD, &xFirstLine, 0, 0x0000);
                 wDrawNumber(xLCD, xFont, sector,6, xRLCD, dwShift(100, 0), 0x0FF);
			    }
              y = 10;
              for (iy = 0; iy<16; iy++)
                {
                x=0;
                wDrawStringL(xLCD, xFont, (addr2),xRLCD, dwShift(0, y),32, 0x0FF);
                addr2+= 32;
                y+=8;
                }
              }
            }
          
          
          
          
          break;
          }
		case _REVERSE:
          {
          if (sector>0) sector--;
          addr = addr0;
          addr2 = addr0;
          for (i = 0; i<512; i++) 
            {
            *addr = 0x00;
             addr++;
             }
          addr = addr0;
          addr2 = addr0;
          
          
          if (wMMCReset()!=0) 
		     {wClear (xLCD, 0x0F00);
              wDrawString(xLCD, xFont, "Init Failed",xRLCD, dwShift(0, 0), 0x0FF);}
            else
            {
            a=wMMCReadSector(sector,addr);
            if (a!=0) 
              {
              wClear (xLCD, 0x0F00);
              wDrawString(xLCD, xFont, "Got error",xRLCD, dwShift(0, 0), 0x0FF);
              wDrawHex8(xLCD, xFont, a, xRLCD, dwShift(100, 7), 0x0FF);
              }
              else
              {
			  wClear (xLCD, 0x0000);
		      
              wDrawNumber(xLCD, xFont, sector,6, xRLCD, dwShift(100, 0), 0x0FF);
              y = 10;
              for (iy = 0; iy<16; iy++)
                {
                x=0;
                wDrawStringL(xLCD, xFont, (addr2),xRLCD, dwShift(0, y),32, 0x0FF);
                addr2+= 32;
                y+=8;
                }
              }
            }
          
          
          
          
          break;
          }
        }
	  }/*
        case _REVERSE:
          {
          if (sector==0) sector=1;
          sector--;
          
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          for (i = 0; i<512; i++) 
            {
            *addr = 0x00;
             addr++;
             }
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          
          
          if (mmc_reset()!=0) {wDrawString("init failed", 0, 0, 0xFF);}
            else
            {
            a=mmc_read_sector(sector,addr);
            if (a!=0) 
              {
              wDrawString("got error ", 0, 0, 0xFF); 
              draw_hex8(a , 60, 0, 0xFF);
              }
              else
              {
              wDrawString("sector ", 0, 0, 0xFF);
              wDrawNumber(sector, 6, 40, 0, 0x1C);
              y = 10;
              for (iy = 0; iy<16; iy++)
                {
                x=0;
                wDrawString_l((addr2),x, y, 32, 0x1C);
                addr2+= 32;
                y+=8;
                }
              }
            }
          
          break;
          }
        case _STAR:
          {
          sector+=10;
          if (sector>260000) sector=0;
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          for (i = 0; i<512; i++) 
            {
            *addr = 0x00;
             addr++;
             }
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          
          
          if (mmc_reset()!=0) {wDrawString("init failed", 0, 0, 0xFF);}
            else
            {
            a=mmc_read_sector(sector,addr);
            if (a!=0) 
              {
              wDrawString("got error ", 0, 0, 0xFF); 
              draw_hex8(a , 60, 0, 0xFF);
              }
              else
              {
              wDrawString("sector ", 0, 0, 0xFF);
              wDrawNumber(sector, 6, 40, 0, 0x1C);
              y = 10;
              for (iy = 0; iy<16; iy++)
                {
                x=0;
                wDrawString_l((addr2),x, y, 32, 0x1C);
                addr2+= 32;
                y+=8;
                }
              }
            }
          
          
          
          
          break;
          }

        case _RETURN:
          {
          if (sector<10) sector=10;
          sector-=10;
          
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          for (i = 0; i<512; i++) 
            {
            *addr = 0x00;
             addr++;
             }
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          
          
          if (mmc_reset()!=0) {wDrawString("init failed", 0, 0, 0xFF);}
            else
            {
            a=mmc_read_sector(sector,addr);
            if (a!=0) 
              {
              wDrawString("got error ", 0, 0, 0xFF); 
              draw_hex8(a , 60, 0, 0xFF);
              }
              else
              {
              wDrawString("sector ", 0, 0, 0xFF);
              wDrawNumber(sector, 6, 40, 0, 0x1C);
              y = 10;
              for (iy = 0; iy<16; iy++)
                {
                x=0;
                wDrawString_l((addr2),x, y, 32, 0x1C);
                addr2+= 32;
                y+=8;
                }
              }
            }
          
          break;
          }
         case _PLAY:
          {
          
          
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          for (i = 0; i<512; i++) 
            {
            *addr = 0x00;
             addr++;
             }
          addr = 0x0C10A000;
          addr2 = 0x0C10A000;
          
          
          if (mmc_reset()!=0) {wDrawString("init failed", 0, 0, 0xFF);}
            else
            {
            u32 x = 0;
            while (x == 0)
              {
              sector++;
              a=mmc_read_sector(sector,addr);
              if (a!=0) 
                {
                wDrawString("got error ", 0, 0, 0xFF); 
                draw_hex8(a , 60, 0, 0xFF);
                x = 1;
                }
                else
                {
                wDrawString("sector ", 0, 0, 0xFF);
                wDrawNumber(sector, 6, 40, 0, 0x1C);
                if ( *(u32*)addr2 != 0)
                  {
                  y = 10;
                  for (iy = 0; iy<16; iy++)
                  {
                    x=0;
                    wDrawString_l((addr2),x, y, 32, 0x1C);
                    addr2+= 32;
                    y+=8;
                  }
                  x = 1;
                  }
                
                }
              }
            }
          
          break;
          }
        default: break;
        }
      
      }
   /* while(1) 
      {
      
      iz++; if (iz>4) iz = 0;
      ix+= 10;
      iy+= 11;
      if(ix>160) ix -= 160;
      if(iy>160) iy -= 160;
      wDrawString("O", ix, iy, color_lookup[iz]);
       //set_pixel (ix, iy, 0x0F);
      }/**/
   /* iis_init();
    while (1)
      {
      *iisfif = 0x00;
       *iisfif = 0x02;
       *iisfif = 0x04;
       *iisfif = 0x08;
       *iisfif = 0x2F;
       *iisfif = 0x40;
       *iisfif = 0x80;
       *iisfif = 0xF0;
       delay16();
       }
    /*while (1) {
        *iisfif = 0x00;
        *iisfif = 0x02;
        *iisfif = 0x04;
        *iisfif = 0x08;
        *iisfif = 0x2F;
        *iisfif = 0x40;
        *iisfif = 0x80;
        *iisfif = 0xF0;
        switch ((*pdatg)) {
            case JB_PLAY:
                wClearLCD();
                wDrawString("Play button.", 10, 10, color_lookup[1]);
                break;
            case JB_RETURN:
                wClearLCD();
                wDrawString("Return button.", 10, 10, color_lookup[2]);
                break;
            case JB_STAR:
                wClearLCD();
                wDrawString("Star button.", 10, 10, color_lookup[3]);
                break;
            case JB_REVERSE:
                wClearLCD();
                wDrawString("Reverse button.", 10, 10, color_lookup[4]);
                break;
            case JB_FORWARD:
                wClearLCD();
                wDrawString("Forward button.", 10, 10, color_lookup[5]);
                break;
            default:
                break;
        }
        delay_ms(1);
        
    }
/**/
    return 0;
}

/*
  Juicebox SDRAM Address Space:
  GENERAL: 0x0C000000-0x0C200000

  USED:
  0x0C000000 - 0x0C010000: code & variables & consts
  0x0C100000 - 0x0C109600: LCD screen (160x240 bytes)
  0x0C10A000 - 0x0C10A400: SIO data buffer (to be transmitted)
  0x0C10A400 - 0x0C10A800: SIO data buffet (received)

  MEMORY MAP:
  
  x - used
  0 - free
  4kB
  
       0123456789ABCDEF
      |________________|
0x0C00|xxxxxxxxxxxxxxxx|
0x0C01|0000000000000000|
0x0C02|0000000000000000|
0x0C03|0000000000000000|
0x0C04|0000000000000000|
0x0C05|0000000000000000|
0x0C06|0000000000000000|
0x0C07|0000000000000000|
0x0C08|0000000000000000|
0x0C09|0000000000000000|
0x0C0A|0000000000000000|
0x0C0B|0000000000000000|
0x0C0C|0000000000000000|
0x0C0D|0000000000000000|
0x0C0E|0000000000000000|
0x0C0F|0000000000000000|
1MB--------------------
0x0C10|xxxxxxxxxxx00000|
0x0C11|0000000000000000|
0x0C12|0000000000000000|
0x0C13|0000000000000000|
0x0C14|0000000000000000|
0x0C15|0000000000000000|
0x0C16|0000000000000000|
0x0C17|0000000000000000|
0x0C18|0000000000000000|
0x0C19|0000000000000000|
0x0C1A|0000000000000000|
0x0C1B|0000000000000000|
0x0C1C|0000000000000000|
0x0C1D|0000000000000000|
0x0C1E|0000000000000000|
0x0C1F|0000000000000000|
2MB--------------------




  */

/*  Malloc test ===============================================

	int *pxPtrs[100];

	int size = 1234;
	
	int i = 0;

	for (i=0; i< 100; i++) {
	  pxPtrs[i] = wMalloc(size&0x1FF);
	  size += 10245;
	  }
	i = 0;
	while (1) {
	   wClear(xLCD, 0x000);
	  wFree(pxPtrs[i]);
	  pxPtrs[i] = wMalloc(size&0x1FC);
	  wDrawHex32 (xLCD, xFont,(size+3)&0x1FC,xRLCD, dwShift(73, 55), 0x0FF); 
	  wDrawHex32 (xLCD, xFont,pxPtrs[i],xRLCD, dwShift(73, 80), 0x0FF); 
	  size += 10245;
	  wDelayMs(15);
	  i++;
	  if (i==100) i = 0;
	  }
*/

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -