晒设计方案+马里奥大叔--听我指挥【实战】

sjtitr

晒设计方案+马里奥大叔--听我指挥【实战】 [复制链接]

依然，首先回顾构想贴：
晒设计方案+马里奥大叔--听我指挥

本辑内容，核心内容是讲述如何使用鸡腿，以及少量的I2C的使用。到此为止，算是实现了NES模拟器的基本目标。不能玩的游戏机那还算不上游戏机。能控制了，才有点游戏机的模样。

但是截至本辑结束，这个模拟器也没有发出声音……事实上，声音一部分，已经在上一辑里通过吊丝听音乐的方式大概讲解了，模拟器这部分就不再讨论有关声音的问题啦。
之所以如此热衷于马里奥大叔系列，不仅因为作为一个忠诚的吊丝，要随时把技术和玩捏在一起，更是因为，大叔他肩负着我童年的美好回忆。

废话少说，节目开始。

我们接着NES模拟器继续，有了前面的基础，模拟器已经可以正常运转，只是还没有接受用户输入信息。

这里，我们使用wii的左手手柄来作为输入设备，我们通常称呼这个家伙为鸡腿。


鸡腿连接我们的板子，需要接四根线，两根电源，两根I2C通信线。

在F4上，恰好触摸屏也是I2C通信的，所以我们可以借用这部分内容。在示例工程中，我们选择Touch_Panel工程进行初步的调试。

I2C，这个就不多说了，尤其是STM32的I2C，更是坑人不浅呢。不过在这里我仍然坚持使用硬件I2C。

参考关于触摸屏接口的I2C，我们来实现鸡腿的I2C通信。

首先要了解如何利用鸡腿来工作。

到网络上找资料，于是找到如下的内容，请重点观赏后者
http://wiibrew.org/wiki/Wiimote/Extension_Controllers
http://wiibrew.org/wiki/Wiimote/Extension_Controllers/Nunchuck

为了懒得啃E文的童鞋，我来总结一下吧。
1.鸡腿的8位Slave地址（包括读写标志位），是0xA4。
2.鸡腿需要初始化，方法是先向0xF0写0x55，然后再向0xFB写0x00。
3.读取鸡腿的信息，是从0x00处读取6个字节，这6个字节，我们现在只需要前两个和最后一个。前两个分别表示x轴和y轴，最后一个的低两位表示鸡腿上的两个按键状态。

然后把鸡腿连在板子上，接线规则是，-+dc四根线分别接在GND、3V、PC9、PA8。

于是可以开始写代码啦。

初始化：

1. static void delay(volatile uint32_t nCount)
   
2. {
   
3.   volatile uint32_t index = 0;
   
4.   for(index = nCount; index != 0; index--)
   
5.   {
   
6.   }
   
7. }
   
8. 
   
9. uint8_t IOE_Chuck_Set(uint8_t reg, uint8_t val)
   
10. {
    
11.   I2C_GenerateSTART(IOE_I2C, ENABLE);
    
12. 
    
13.   /* Test on EV5 and clear it */
    
14.   IOE_TimeOut = TIMEOUT_MAX;
    
15.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_SB))
    
16.   {
    
17.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
18.   }
    
19. 
    
20.   /* Transmit the slave address and enable writing operation */
    
21.   I2C_Send7bitAddress(IOE_I2C, NUNCHUCK_ADDR, I2C_Direction_Transmitter);
    
22.   
    
23.   /* Test on EV6 and clear it */
    
24.   IOE_TimeOut = TIMEOUT_MAX;
    
25.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_ADDR))
    
26.   {
    
27.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
28.   }
    
29.   
    
30.   /* Read status register 2 to clear ADDR flag */
    
31.   IOE_I2C->SR2;
    
32.   
    
33.   /* Test on EV8_1 and clear it */
    
34.   IOE_TimeOut = TIMEOUT_MAX;
    
35.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_TXE))
    
36.   {
    
37.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
38.   }
    
39.   
    
40.   /* Transmit the first address for r/w operations */
    
41.   I2C_SendData(IOE_I2C, reg);
    
42.   
    
43.   /* Test on EV8 and clear it */
    
44.   IOE_TimeOut = TIMEOUT_MAX;
    
45.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_TXE))
    
46.   {
    
47.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
48.   }
    
49.   
    
50.   /* Prepare the register value to be sent */
    
51.   I2C_SendData(IOE_I2C, val);
    
52.   
    
53.   /* Test on EV8_2 and clear it */
    
54.   IOE_TimeOut = TIMEOUT_MAX;
    
55.   while ((!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_TXE)) || (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_BTF)))
    
56.   {
    
57.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
58.   }
    
59.   
    
60.   /* End the configuration sequence */
    
61.   I2C_GenerateSTOP(IOE_I2C, ENABLE);
    
62.   
    
63.   /* All configuration done */
    
64.   return IOE_OK;  
    
65. }
    
66.    
    
67. void IOE_Chuck_Init(void)
    
68. {
    
69.   delay(50000);
    
70.   ioe_err = IOE_Chuck_Set(0xf0, 0x55);
    
71.   delay(50000);
    
72.   ioe_err = IOE_Chuck_Set(0xfb, 0x00);
    
73.   delay(50000);
    
74. }
    

复制代码

以上代码，我自己写的比较少，基本都是找示例扒过来的。注意到里面有许多的delay，这个东西不是鸡腿控制说明里面提的，而是我根据实验，发现我手里的破鸡腿，需要“慢”一点来访问，才能正常工作，最后加上的延时操作，否则，可能初始化就会不成功，进而从鸡腿得到的数据都是0xFF。事实上，我还有另外一个鸡腿，不需要这样那样的延时，也可以工作得很好，所以我觉得是破鸡腿的问题，但是作为分享，我把这些延时也拿出来，提醒各位控制鸡腿的时候可能需要“慢”一点哦。

接下来就是读取鸡腿数据啦：

1. uint8_t IOE_Chuck_Seek(uint8_t reg)
   
2. {
   
3.   I2C_GenerateSTART(IOE_I2C, ENABLE);
   
4. 
   
5.   /* Test on EV5 and clear it */
   
6.   IOE_TimeOut = TIMEOUT_MAX;
   
7.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_SB))
   
8.   {
   
9.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
   
10.   }
    
11. 
    
12.   /* Transmit the slave address and enable writing operation */
    
13.   I2C_Send7bitAddress(IOE_I2C, NUNCHUCK_ADDR, I2C_Direction_Transmitter);
    
14.   
    
15.   /* Test on EV6 and clear it */
    
16.   IOE_TimeOut = TIMEOUT_MAX;
    
17.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_ADDR))
    
18.   {
    
19.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
20.   }
    
21.   
    
22.   /* Read status register 2 to clear ADDR flag */
    
23.   IOE_I2C->SR2;
    
24.   
    
25.   /* Test on EV8_1 and clear it */
    
26.   IOE_TimeOut = TIMEOUT_MAX;
    
27.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_TXE))
    
28.   {
    
29.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
30.   }
    
31.   
    
32.   /* Transmit the first address for r/w operations */
    
33.   I2C_SendData(IOE_I2C, reg);
    
34.   
    
35.   /* Test on EV8 and clear it */
    
36.   IOE_TimeOut = TIMEOUT_MAX;
    
37.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_TXE))
    
38.   {
    
39.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
40.   }
    
41.   
    
42.   /* End the configuration sequence */
    
43.   I2C_GenerateSTOP(IOE_I2C, ENABLE);
    
44.   
    
45.   /* All configuration done */
    
46.   return IOE_OK;  
    
47. }
    
48. 
    
49. uint8_t IOE_Chuck_Read(uint8_t *buf)
    
50. {
    
51.   /* Send START condition a second time */  
    
52.   I2C_GenerateSTART(IOE_I2C, ENABLE);
    
53.   
    
54.   /* Test on EV5 and clear it */
    
55.   IOE_TimeOut = TIMEOUT_MAX;
    
56.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_SB))
    
57.   {
    
58.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
59.   }
    
60.   
    
61.   /* Send IO Expander address for read */
    
62.   I2C_Send7bitAddress(IOE_I2C, NUNCHUCK_ADDR, I2C_Direction_Receiver);
    
63.   
    
64.   /* Test on EV6 and clear it */
    
65.   IOE_TimeOut = TIMEOUT_MAX;
    
66.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_ADDR))
    
67.   {
    
68.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
69.   }
    
70. 
    
71.   /* Disable Acknowledgement and set Pos bit */
    
72.   I2C_AcknowledgeConfig(IOE_I2C, DISABLE);      
    
73.   I2C_NACKPositionConfig(IOE_I2C, I2C_NACKPosition_Next);
    
74.   
    
75.   /* Read status register 2 to clear ADDR flag */
    
76.   IOE_I2C->SR2;
    
77. 
    
78.   /* Test on EV7 and clear it */
    
79.   IOE_TimeOut = TIMEOUT_MAX;
    
80.   while (!I2C_GetFlagStatus(IOE_I2C, I2C_FLAG_BTF))
    
81.   {
    
82.     if (IOE_TimeOut-- == 0) return(IOE_FAILURE);
    
83.   }
    
84.    
    
85.   /* Send STOP Condition */
    
86.   I2C_GenerateSTOP(IOE_I2C, ENABLE);
    
87.    
    
88.   /* Read the first byte from the IO Expander */
    
89.   buf[0] = I2C_ReceiveData(IOE_I2C);
    
90.    
    
91.   /* Read the second byte from the IO Expander */
    
92.   buf[1] = I2C_ReceiveData(IOE_I2C);
    
93.                                          
    
94.   /* Enable Acknowledgement and reset POS bit to be ready for another reception */
    
95.   I2C_AcknowledgeConfig(IOE_I2C, ENABLE);
    
96.   I2C_NACKPositionConfig(IOE_I2C, I2C_NACKPosition_Current);
    
97.    
    
98.   /* All read done */
    
99.   return IOE_OK;  
    
100. }

复制代码

1. ……
   
2.     ioe_err = IOE_Chuck_Seek(0);
   
3.     delay(50000);
   
4.     ioe_err = IOE_Chuck_Read(chuck_buf);
   
5.     delay(1000);
   
6.     ioe_err = IOE_Chuck_Read(&chuck_buf[2]);
   
7.     delay(1000);
   
8.     ioe_err = IOE_Chuck_Read(&chuck_buf[4]);
   
9.     delay(1000);

复制代码

有童鞋可能会问，不是说从0读取6个字节么……是啊，可是，实践是检验真理的唯一标准。我发现结合STM32的I2C，还有我的破鸡腿，直接连续读6个字节真的是噩梦。恰示例读取触摸屏是每次2字节，于是我也就模仿着，然后自己每次去读两个字节，定好地址，连续读3次，反正都差不多嘛，最后我的代码也奏效了，哦呵呵

补充一点，如果你读到鸡腿的返回值都是0xFF，说明鸡腿初始化不正确哦，就需要在初始化部分做文章了，切记。

以上代码，在触摸屏的工程上，测试通过了，然后移到NES工程里。
为了能“慢”一点访问鸡腿，我不得不在每一帧的4条不同扫描线里去做读鸡腿的动作，先定好地址，之后3次每次都两个字节……搞出这样的处理，郁闷啊。

所幸的是，InfoNES已经预留了这样的位置，InfoNES_Wait函数，就是为了在高速环境里拖慢模拟器运行速度到真实速度，在每个扫描线都会调用一次，如果你想降低模拟器运行速度，就再这里写一些耽误时间的操作，例如Sleep。我们在这里，判断当前扫描线，在适当的时机进行动作。

1. /* Wait */
   
2. void InfoNES_Wait()
   
3. {
   
4.   switch(PPU_Scanline)
   
5.   {
   
6. //    case 9:
   
7. //      ioe_err = IOE_Chuck_Seek(0);
   
8. //      delay(50000);
   
9. //      ioe_err = IOE_Chuck_Read(chuck_buf);
   
10. //      delay(1000);
    
11. //      ioe_err = IOE_Chuck_Read(&chuck_buf[2]);
    
12. //      delay(1000);
    
13. //      ioe_err = IOE_Chuck_Read(&chuck_buf[4]);
    
14. //      delay(1000);
    
15. //      break;
    
16.     case 10:
    
17.       ioe_err = IOE_Chuck_Seek(0);
    
18.       break;
    
19.     case 240:
    
20.       ioe_err = IOE_Chuck_Read(chuck_buf);
    
21.       break;
    
22.     case 245:
    
23.       ioe_err = IOE_Chuck_Read(&chuck_buf[2]);
    
24.       break;
    
25.     case 250:
    
26.       ioe_err = IOE_Chuck_Read(&chuck_buf[4]);
    
27.       break;
    
28.     default:
    
29.       break;
    
30.   }
    
31. }

复制代码

最后，在定期调用的InfoNES_PadState函数中，分析chuck_buf的内容，并填充pad键状态。

1. /* Get a joypad state */
   
2. void InfoNES_PadState( DWORD *pdwPad1, DWORD *pdwPad2, DWORD *pdwSystem )
   
3. {
   
4.   {
   
5.     *pdwPad1 = 0;
   
6.     if(chuck_buf[0]<0x60)
   
7.     {
   
8.       *pdwPad1 |= PAD_JOY_LEFT;
   
9.     }
   
10.     else if(chuck_buf[0]>0x90)
    
11.     {
    
12.       *pdwPad1 |= PAD_JOY_RIGHT;
    
13.     }
    
14.     else
    
15.     {
    
16.     }
    
17. 
    
18.     if(chuck_buf[1]<0x60)
    
19.     {
    
20.       *pdwPad1 |= PAD_JOY_DOWN;
    
21.     }
    
22.     else if(chuck_buf[1]>0x90)
    
23.     {
    
24.       *pdwPad1 |= PAD_JOY_UP;
    
25.     }
    
26.     else
    
27.     {
    
28.     }
    
29.    
    
30.     if(chuck_buf[5]&0x01)
    
31.     {
    
32.     }
    
33.     else
    
34.     {
    
35.       *pdwPad1 |= PAD_JOY_A;
    
36.     }
    
37.     if(chuck_buf[5]&0x02)
    
38.     {
    
39.     }
    
40.     else
    
41.     {
    
42.       *pdwPad1 |= PAD_JOY_B;
    
43.     }
    
44.     if(STM_EVAL_PBGetState(BUTTON_USER) == Bit_RESET)
    
45.     {
    
46.     }
    
47.     else
    
48.     {
    
49.       *pdwPad1 |= PAD_JOY_START;
    
50.     }
    
51.   }
    
52. }

复制代码

需要注意到一点，鸡腿上只有两个按键，要想玩游戏，除了方向需要3个按键，所以用板子上的User按键顶个包。

当然，我把I2C和鸡腿的初始化放在读取ROM的后面了。

download!运行！

翻滚吧，大叔。


其实，稍有风吹草动，I2C就挂了，然后大叔就不受控制了。I2C的稳定性，暂时不在讨论范围内，追求稳定的童鞋，去用软件模拟吧。

仍然，最后把可以运行的工程，分享给大家。不过也隐隐的觉得，有可能直接烧写我的原版，也不能100%驱动你的鸡腿……桑心！
Nes.zip (2.36 MB, 下载次数: 34)

2014-2-20 00:28 上传

点击文件名下载附件

（7z压缩，体积更小）

本辑完。

sacq

翻滚吧，鸡腿~~

jaccopa

没赶上活动，昨天淘了个429discovery，，这会儿可以用上啦

wangxb2555

不错的东西

soso

带着回忆就把板子给用上了，赞 。

话说马里奥是从某一集爱情公寓里看到的，嘿嘿  看来我太缺少童年了