【MSP430F5529测评】7. TFT彩屏贪吃蛇

wuguangtao · 2020-12-23 22:33 上传

【MSP430F5529测评】7. TFT彩屏贪吃蛇 [复制链接]

<i class="pstatus"> 本帖最后由 wuguangtao 于 2020-12-24 08:41 编辑 </i>

# MSP430F5529 驱动2.2英寸 TFT彩屏 并实现贪吃蛇

**贪吃蛇**，经久不衰的小游戏，我在本科的时候，使用C8051F120写过一个贪吃蛇游戏，用的屏幕就是今天讲的2.2inch TFT全彩屏。

这次测评计划中有提到要移植这个游戏，但是最近加班严重，一直断断续续，直到今天才有时间整理。好啦，言归正传。

## 游戏框架

这个游戏涉及的外设主要是4*4键盘和2.2 inch TFT，配合串口（打印log），定时器（定时更新贪吃蛇蛇身），LED指示灯（指示定时器状态）。

涉及的主要功能有：

- TFT 驱动
  - SPI驱动
  - ILI9341驱动
- TFT 密码登录动画
- TFT 密码认证
- 贪吃蛇
  - 定时器更新
  - 等级设置，涉及速度，障碍物
  - 游戏暂停、恢复
  - 重启回登录页面
  - 页面展示分数、蛇长、等级、logo等信息
  - 吃到苹果后更新
  - 一定时间后出现大型食物 （tomato) ，规定时间没吃到会消息
  - 更新时间
- LED指示，定时器达到1秒更新一次
- 4*4 键盘驱动，行扫描，防抖动
- 串口调试，输出状态信息

由于是移植，所以大部分功能模块已经有了，但是很多细节部分需要斟酌修改，比如之前51单片机与MSP430的寄存器配置不一样，时钟配置、定时器配置、SPI配置、GPIO配置等等都需要重新写过。但是业务逻辑的主体部分还是保持一致的，不过之前使用的是蓝牙控制，这次没加蓝牙，所以有些中断程序也要修改。

本文主要给个大体思路和关键的驱动、初始化代码。

## 时钟配置

凡是配置，首先都得考虑时钟，由于TFT所需主频较高，同时也是为了保证帧率，我们将SMCLK，MCLK调整至`16MHz`, 之前WS2812B用的也是这个频率，不多说了。

```c
void UCS_Init()
{
    UCSCTL3 |= SELREF_2;                      // Set DCO FLL reference = REFO

__bis_SR_register(SCG0);                  // Disable the FLL control loop
    UCSCTL0 = 0x0000;                         // Set lowest possible DCOx, MODx
    UCSCTL1 = DCORSEL_5;                      // Select DCO range 24MHz operation
    UCSCTL2 = FLLD_1 + 499;                   // Set DCO Multiplier for 12MHz
                                              // (N + 1) * FLLRef = Fdco
                                              // (499 + 1) * 32768 = 16MHz
                                              // Set FLL Div = fDCOCLK/2
    UCSCTL4 |= SELA_2;                        // Set ACLK = REFO
    __bic_SR_register(SCG0);                  // Enable the FLL control loop

// Worst-case settling time for the DCO when the DCO range bits have been
    // changed is n x 32 x 32 x f_MCLK / f_FLL_reference. See UCS chapter in 5xx
    // UG for optimization.
    // 32 x 32 x 16 MHz / 32,768 Hz = 500000 = MCLK cycles for DCO to settle
    __delay_cycles(500000);
}
```

## 串口配置

串口用来打印log信息简直再方便不过了。我将其单独写到serial.c中，然后封装API到serial.h, 也方便其它项目复用。

```c
void Serial_Init()
{
    // USCI_A1 UART
    P4SEL |= BIT4+BIT5;                       // P4.4,5 = USCI_A1 TXD/RXD
    UCA1CTL1 |= UCSWRST;                      // **Put state machine in reset**
    UCA1CTL1 |= UCSSEL_2;                     // SMCLK
    UCA1BR0 = 145;                            // 16MHz 115200 (see User's Guide)
    UCA1BR1 = 0;                              // 16MHz 115200
    UCA1MCTL |= UCBRS_1 + UCBRF_0;            // Modulation UCBRSx=1, UCBRFx=0
    UCA1CTL1 &= ~UCSWRST;                     // **Initialize USCI state machine**
    UCA1IE |= UCRXIE;                         // Enable USCI_A1 RX interrupt
}

```

上面是初始化函数，设置波特率为`115200`,下面编写了两个API

- serial_send_char: 发送单个字符
- serial_send_strings: 发送字符串

```c
void serial_send_char(char c)
{
    while (!(UCA1IFG&UCTXIFG));             // USCI_A1 TX buffer ready?
    UCA1TXBUF = c;
}

void serial_send_strings(char *str)
{
    unsigned int i = 0;
    while(str<i> != '\0') {
        serial_send_char(str<i>);
        i++;
    }
}
```

至于中断处理函数呢，可有可无，加上也无妨，会将接收到的数据，回传，当是测试用吧。

```c
volatile uint8_t chr;               // set a invalid value

// Echo back RXed character, confirm TX buffer is ready first
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=USCI_A1_VECTOR
__interrupt void USCI_A1_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_A1_VECTOR))) USCI_A1_ISR (void)
#else
#error Compiler not supported!
#endif
{
    switch(__even_in_range(UCA1IV,4))
    {
        case 0:break;                             // Vector 0 - no interrupt
        case 2:                                   // Vector 2 - RXIFG
            while (!(UCA1IFG&UCTXIFG));           // USCI_A1 TX buffer ready?
            chr = UCA1RXBUF;
            UCA1TXBUF = chr;                      // TX -> RXed character
            break;
        case 4:break;                             // Vector 4 - TXIFG
        default: break;
    }
}
```

## 键盘驱动

说键盘驱动前，来看看键盘长啥样，没错，就是这样的4*4经典键盘。

<ignore_js_op>

</ignore_js_op>

4行4列，行扫描即可。这里有个坑就是MSP430F5529LP给出的IO口没有完全连续的，比如P2都是分散的，而键盘的管脚就是并排直插，没办法，只能选择一排不相连的IO，然后软件配置下。

```c
 /*  key map as below:
    P4.0 ROW-1
    P4.3 ROW-2
    P1.2 ROW-3
    P1.3 ROW-4
    P1.4 COL-1
    P1.5 COL-2
    P2.4 COL-3
    P2.5 COL-4
 */
void KEY_Init(void)
{
    // ROWS
    P4DIR |= BIT0 + BIT3;
    P1DIR |= BIT2 + BIT3;

// COLS
    P1DIR &= ~(BIT4 + BIT5);
    P2DIR &= ~(BIT4 + BIT5);
    P1REN |= BIT4 + BIT5; /* pull up to keep input stable */
    P2REN |= BIT4 + BIT5; /* pull up to keep input stable */
}

void key_set(uint8_t val)
{
    if (val & 0x80)
        P4OUT |= BIT0;
    else
        P4OUT &= ~BIT0;

if (val & 0x40)
        P4OUT |= BIT3;
    else
        P4OUT &= ~BIT3;

if (val & 0x20)
        P1OUT |= BIT2;
    else
        P1OUT &= ~BIT2;

if (val & 0x10)
        P1OUT |= BIT3;
    else
        P1OUT &= ~BIT3;

if (val & 0x08)
        P1OUT |= BIT4;
    else
        P1OUT &= ~BIT4;

if (val & 0x04)
        P1OUT |= BIT5;
    else
        P1OUT &= ~BIT5;

if (val & 0x02)
        P2OUT |= BIT4;
    else
        P2OUT &= ~BIT4;

if (val & 0x01)
        P2OUT |= BIT5;
    else
        P2OUT &= ~BIT5;
}

uint8_t key_get(void)
{
    uint8_t key = 0x00;
    key += (P4IN & BIT0)?0x80:0x00;
    key += (P4IN & BIT3)?0x40:0x00;
    key += (P1IN & BIT2)?0x20:0x00;
    key += (P1IN & BIT3)?0x10:0x00;
    key += (P1IN & BIT4)?0x08:0x00;
    key += (P1IN & BIT5)?0x04:0x00;
    key += (P2IN & BIT4)?0x02:0x00;
    key += (P2IN & BIT5)?0x01:0x00;
    return key;
}

```

三个函数分别是

- Key_Init, 初始化行列键盘IO，注意行扫描，所以行方向IO为输出模式，列方向为输入模式，而且输入默认是浮空的，**一定要配置上拉电阻**，否则读取的数据都是随机的。
- key_set： 修改行方向输出
- key_get:  获取键盘IO值

行列扫描都可以，不懂的可以网上找找更详细的教程，我这直接贴代码。

```c
#define ROWS 4
#define COLS 4

char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};

/* Return Key
 * @return: 0 - 15, -1 if no key push */
int keyscan(void)
{
    uint8_t mask[4] = {0x7F, 0xBF, 0xDF, 0xEF};
    uint8_t key = 0x00;
    uint8_t i, j;

key_set(0x0F);
    if ((key_get() & 0x0F) != 0x0F) {
        __delay_cycles(1000000);  /* 100ms */
        if ((key_get() & 0x0F) == 0x0F)
            return -1;

for (i = 0; i < 4; i++){
            key_set(mask<i>); /* scan every row */
            key = key_get();
            key = (key & 0x0F) ^ 0x0F;

if (key == 0x00)
                continue;

switch (key) {
                case 0x08: j = 0; break;
                case 0x04: j = 1; break;
                case 0x02: j = 2; break;
                case 0x01: j = 3; break;
            }
            return (i*4 + j);
        }
    }
    return -1;
}

char getkey()
{
    int key = keyscan();
    return (key>=0 ? keys[key / 4][key % 4] : 0x00);
}
```

注意有个防抖动延时判断。还有，其实keyscan可以直接返回`keys<i>[j]`, 但是这样就不便其它程序获取键值，所以我这用了getkey()来做个转换，得到的是16个字符之一。当然觉得不需要的也可以整合下。效果没啥差。

## TFT驱动

TFT驱动是耗时最长的部分，因为要配置的比较多。主要是时序问题。

<ignore_js_op>

</ignore_js_op>

首先是初始化部分,SPI 初始化，用来给TFT发送数据，之前C8051f120用的是IO模拟，还不一样。

```c
void SPI_Init()
{
    LCD_GPIO_SEL |= LCD_SDI + LCD_SCK;   // P3.0 SPI MOSI option select
    LCD_GPIO_DIR |= LCD_DC + LCD_RST + LCD_CS;

UCB0CTL1 |= UCSWRST;                         // **Put state machine in reset**
    UCB0CTL0 |= UCMST + UCCKPH + UCMSB + UCSYNC; // 3-pin, 8-bit SPI master, MSB
    UCB0CTL1 |= UCSSEL_2; // SMCLK source (16 MHz)

UCB0BR0 = 0x02;       // 16 MHz / 2 = 8MHz
    UCB0BR1 = 0;          //
    UCB0CTL1 &= ~UCSWRST; // Initialize USCI state machine
}

void SPI_WriteByte(uint8_t val)
{
    while (!(UCB0IFG & UCTXIFG));              // USCI_A0 TX buffer ready?
    UCB0TXBUF = val;
}
```

下面是主要的驱动代码，根据参考文档写的。

<ignore_js_op>

<a href="http://bbs.eeworld.com.cn/forum.php?mod=attachment&aid=NTE4MzU4fDRmM2YwNGY1fDE2MTA4Mjk2OTZ8MHwxMTUyODk0" target="_blank">ILI9341_Datasheet.pdf</a>

<em class="xg1">(3.41 MB, 下载次数: 1)</em>
</span>
<div class="tip tip_4" id="attach_518358_menu" style="position: absolute; display: none" disautofocus="true">
<div class="tip_c xs0">
<div class="y">2020-12-23 22:32 上传</div>
点击文件名下载附件

</ignore_js_op>

```c
void LCD_RESET(void)
{
    LCD_RST_CLR;
    __delay_cycles(100000); // 100ms
    LCD_RST_SET;
    __delay_cycles(500000);  // 50ms
}

void LCD_WR_REG(uint8_t data)
{
    LCD_DC_CLR;
    SPI_WriteByte(data);
}

void LCD_WR_DATA8(uint8_t data)
{
   LCD_DC_SET;
   SPI_WriteByte(data);
}

void LCD_WR_DATA(uint16_t data)
{
   LCD_DC_SET;
   SPI_WriteByte(data>>8);
   SPI_WriteByte(data & 0xFF);
}

void LCD_WR_REG_DATA(uint8_t LCD_Reg, uint16_t LCD_RegValue)
{
    LCD_WR_REG(LCD_Reg);
    LCD_WR_DATA(LCD_RegValue);
}

void LCD_Init(void)
{
    SPI_Init();
    LCD_CS_SET;
    LCD_RESET();
    LCD_CS_CLR;

LCD_WR_REG(0xCB);
    LCD_WR_DATA8(0x39);
    LCD_WR_DATA8(0x2C);
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0x34);
    LCD_WR_DATA8(0x02);

LCD_WR_REG(0xCF);
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0XC1);
    LCD_WR_DATA8(0X30);

LCD_WR_REG(0xE8);
    LCD_WR_DATA8(0x85);
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0x78);

LCD_WR_REG(0xEA);
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0x00);

LCD_WR_REG(0xED);
    LCD_WR_DATA8(0x64);
    LCD_WR_DATA8(0x03);
    LCD_WR_DATA8(0X12);
    LCD_WR_DATA8(0X81);

LCD_WR_REG(0xF7);
    LCD_WR_DATA8(0x20);

LCD_WR_REG(0xC0);    //Power control
    LCD_WR_DATA8(0x23);   //VRH[5:0]

LCD_WR_REG(0xC1);    //Power control
    LCD_WR_DATA8(0x10);   //SAP[2:0];BT[3:0]

LCD_WR_REG(0xC5);    //VCM control
    LCD_WR_DATA8(0x3e);  // Contrast
    LCD_WR_DATA8(0x28);

LCD_WR_REG(0xC7);    //VCM control2
    LCD_WR_DATA8(0x86);  //--

LCD_WR_REG(0x36);    // Memory Access Control
    LCD_WR_DATA8(0x48);  //C8  //48 68 vertical screen //28 E8 Horizontal screen

LCD_WR_REG(0x3A);
    LCD_WR_DATA8(0x55);

LCD_WR_REG(0xB1);
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0x18);

LCD_WR_REG(0xB6);    // Display Function Control
    LCD_WR_DATA8(0x08);
    LCD_WR_DATA8(0x82);
    LCD_WR_DATA8(0x27);

LCD_WR_REG(0xF2);    // 3Gamma Function Disable
    LCD_WR_DATA8(0x00);

LCD_WR_REG(0x26);    //Gamma curve selected
    LCD_WR_DATA8(0x01);

LCD_WR_REG(0xE0);    //Set Gamma
    LCD_WR_DATA8(0x0F);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0x2B);
    LCD_WR_DATA8(0x0C);
    LCD_WR_DATA8(0x0E);
    LCD_WR_DATA8(0x08);
    LCD_WR_DATA8(0x4E);
    LCD_WR_DATA8(0xF1);
    LCD_WR_DATA8(0x37);
    LCD_WR_DATA8(0x07);
    LCD_WR_DATA8(0x10);
    LCD_WR_DATA8(0x03);
    LCD_WR_DATA8(0x0E);
    LCD_WR_DATA8(0x09);
    LCD_WR_DATA8(0x00);

LCD_WR_REG(0XE1);    //Set Gamma
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0x0E);
    LCD_WR_DATA8(0x14);
    LCD_WR_DATA8(0x03);
    LCD_WR_DATA8(0x11);
    LCD_WR_DATA8(0x07);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0xC1);
    LCD_WR_DATA8(0x48);
    LCD_WR_DATA8(0x08);
    LCD_WR_DATA8(0x0F);
    LCD_WR_DATA8(0x0C);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0x36);
    LCD_WR_DATA8(0x0F);

LCD_WR_REG(0x11);    //Exit Sleep
    __delay_cycles(120000); // 120ms

LCD_WR_REG(0x29);    //Display on
    LCD_WR_REG(0x2c);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
   LCD_WR_REG(0x2a);
   LCD_WR_DATA8(x1>>8);
   LCD_WR_DATA8(x1);
   LCD_WR_DATA8(x2>>8);
   LCD_WR_DATA8(x2);

LCD_WR_REG(0x2b);
   LCD_WR_DATA8(y1>>8);
   LCD_WR_DATA8(y1);
   LCD_WR_DATA8(y2>>8);
   LCD_WR_DATA8(y2);

LCD_WR_REG(0x2C);

}

void LCD_Clear(uint16_t Color)
{
    uint8_t VH,VL;
    uint16_t i,j;
    VH=Color>>8;
    VL=Color;
    Address_set(0,0,LCD_W-1,LCD_H-1);
    for(i=0;i<LCD_W;i++)
     {
      for (j=0;j<LCD_H;j++)
        {
             LCD_WR_DATA8(VH);
             LCD_WR_DATA8(VL);

}

}
}
```

其它驱动代码就略过了，太多了，包括绘制图形、汉字、英文、图片等等。给个头文件感受下就是了。

```c
/*
 * tft2.2.h
 *
 *  Created on: 2020-12-
 *      Author: Litreily
 */

#ifndef LCD_H_
#define LCD_H_

#include <msp430.h>
#include <stdint.h>

#define LCD_GPIO_OUT P3OUT
#define LCD_GPIO_DIR P3DIR
#define LCD_GPIO_SEL P3SEL

//#define LCD_SDO           /* MISO */
//#define LCD_LED           /* connect to 3.3v */
#define LCD_SCK     BIT2
#define LCD_SDI     BIT0    /* MOSI */
#define LCD_DC      BIT5
#define LCD_RST     BIT6
#define LCD_CS      BIT7
//#define LCD_GND
//#define LCD_VCC

#define LCD_W 240
#define LCD_H 320

// GPIO Set
#define LCD_DC_SET (LCD_GPIO_OUT |= LCD_DC)
#define LCD_RST_SET (LCD_GPIO_OUT |= LCD_RST)
#define LCD_CS_SET (LCD_GPIO_OUT |= LCD_CS)

// GPIO Reset
#define LCD_DC_CLR (LCD_GPIO_OUT &= ~LCD_DC)
#define LCD_RST_CLR (LCD_GPIO_OUT &= ~LCD_RST)
#define LCD_CS_CLR (LCD_GPIO_OUT &= ~LCD_CS)

extern uint16_t BACK_COLOR, POINT_COLOR;

void LCD_Init(void);
void LCD_Clear(uint16_t Color);
void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2);
void LCD_WR_REG(uint8_t data);
void LCD_WR_DATA8(uint8_t da);
void LCD_WR_DATA(uint16_t da);

void LCD_DrawPoint(uint16_t x,uint16_t y);
void LCD_DrawPoint_big(uint16_t x,uint16_t y);
uint16_t  LCD_ReadPoint(uint16_t x,uint16_t y);
void Draw_Circle(uint16_t x0,uint16_t y0,uint8_t r);
void LCD_DrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2);
void LCD_DrawRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2);
void LCD_Fill(uint16_t xsta,uint16_t ysta,uint16_t xend,uint16_t yend,uint16_t color);
void LCD_ShowChar(uint16_t x,uint16_t y,uint8_t num,uint8_t mode);
void LCD_ShowNum(uint16_t x,uint16_t y,uint32_t num,uint8_t len);
void LCD_Show2Num(uint16_t x,uint16_t y,uint16_t num,uint8_t len);
void LCD_ShowString(uint16_t x,uint16_t y,const uint8_t *p);

void hanzi_8x8(unsigned int x,unsigned int y,unsigned char index);
void hanzi_8x16(unsigned int x,unsigned int y,unsigned char index);
void hanzi_16x8(unsigned int x,unsigned int y,unsigned char index);
void hanzi_16x24(unsigned int x,unsigned int y,unsigned char index);
void hanzi_16x16(unsigned int x,unsigned int y,unsigned char index);
void hanzi_16x33(unsigned int x,unsigned int y,unsigned char index);
void hanzi_32x33(unsigned int x,unsigned int y,unsigned char index);

#define WHITE            0xFFFF
#define BLACK            0x0000
#define BLUE             0x001F
#define BRED             0XF81F
#define GRED             0XFFE0
#define GBLUE            0X07FF
#define RED              0xF800
#define MAGENTA          0xF81F
#define GREEN            0x07E0
#define CYAN             0x7FFF
#define YELLOW           0xFFE0
#define BROWN            0XBC40
#define BRRED            0XFC07
#define GRAY             0X8430

#define DARKBLUE         0X01CF
#define LIGHTBLUE        0X7D7C
#define GRAYBLUE         0X5458
#define LIGHTGREEN       0X841F
#define LGRAY            0XC618
#define LGRAYBLUE        0XA651
#define LBBLUE           0X2B12
#define SNAKE            0XB184

#endif /* LCD_H_ */
```

而且还要配置字库，对应单独的font.c font.h, 字库可以网上下载，或者使用软件生成，这个彩屏驱动芯片官方就有工具，叫做 **8X8点阵取模软件**。

## 定时器配置

使用TimerA0. 使用32768Hz REFO为时钟源，在中断中修改状态，每到1s更新flag_time, 同时更新指示灯状态。level_uint 对应贪吃蛇的移动速度，其值越大速度越慢。而且每到一定时间会给出一个大型食物tomato, 迟到可以加更多分，当然时间范围内没有吃到就会消失。

```c
void TimerA0_Init()
{
    TA0CCTL0 = CCIE;                          // CCR0 interrupt enabled
    TA0CCR0 = 1024;
    TA0CTL = TASSEL_1 + MC_1 + TACLR;         // ACLK, upmode, clear TAR

flag_time = 0;
    P1DIR = BIT0;
    __bis_SR_register(GIE);                   // interrupts enabled
}

// Timer0 A0 interrupt service routine
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(TIMER0_A0_VECTOR))) TIMER0_A0_ISR (void)
#else
#error Compiler not supported!
#endif
{
    static uint8_t  i=1,j=1;
    static uint16_t k=1;

if(j==level_unit)
    {
        flag_move=1;
        j=0;
    }
    if(i==32)
    {
        time++;
        i=0;
        flag_time=1;
        P1OUT ^= BIT0;
    }
    if(k==2000)
    {
        flag_tomato=1;
    }
    else if(k==3000)
    {
        if(!flag_clear_image)
        {
            flag_clear_image=1;
        }
        k=0;
    }
    i++;j++;k++;

}
```

## 密码登录

### 彩屏动画

```c
void start()
{
    uint16_t i,j;

LCD_Clear(BLACK);
    BACK_COLOR=BLACK;
    POINT_COLOR=GREEN;

for(i=1;i<95;i++)
    {
        POINT_COLOR=BLACK;
        LCD_DrawLine(i-1,160-13,i-1,160+13);
        LCD_DrawLine(241-i,160-13,241-i,160+13);
        POINT_COLOR=GREEN;
        LCD_DrawLine(i,160-13,i,160+13);
        LCD_DrawLine(240-i,160-13,240-i,160+13);
    }
    for(i=1;i<147;i++)
    {
        POINT_COLOR=BLACK;
        LCD_DrawLine(120-25,i-1,120+25,i-1);
        LCD_DrawLine(120-25,321-i,120+25,321-i);
        POINT_COLOR=GREEN;
        LCD_DrawLine(120-25,i,120+25,i);
        LCD_DrawLine(120-25,320-i,120+25,320-i);
    }

for(i=1;i<80;i++)
    {

POINT_COLOR=RED;
        hanzi_16x33(i,100,14);
        __delay_cycles(2000);
        if(i==79)break;
        POINT_COLOR=BLACK;
        hanzi_16x33(i,100,14);
     }
    for(i=1;i<80;i++)
    {
        POINT_COLOR=GREEN;
        hanzi_16x33(224-i,100,16);
        __delay_cycles(2000);
        if(i==79)break;
        POINT_COLOR=BLACK;
        hanzi_16x33(224-i,100,16);
     }
    for(i=1;i<100;i++)
    {

POINT_COLOR=BLUE;
        hanzi_16x33(110,i,15);
        __delay_cycles(2000);
        if(i==99)break;
        POINT_COLOR=BLACK;
        hanzi_16x33(110,i,15);
     }
    for(i=1;i<172;i++)
    {
        POINT_COLOR=BRRED;
        for(j=0;j<4;j++)
        hanzi_16x24(j*16+30,320-i,j);
        __delay_cycles(2000);
        if(i==171)break;
        POINT_COLOR=BLACK;
        for(j=0;j<4;j++)
        hanzi_16x24(j*16+30,320-i,j);
     }
    POINT_COLOR=RED;
    for(i=1;i<20;i++){Draw_Circle(i,i,i);__delay_cycles(10000);}
    POINT_COLOR=GREEN;
    __delay_cycles(100000);
    for(i=1;i<30;i++){Draw_Circle(i,320-i,i);__delay_cycles(10000);}
    POINT_COLOR=BLUE;
    __delay_cycles(100000);
    for(i=1;i<40;i++){Draw_Circle(240-i,i,i);__delay_cycles(10000);}
    POINT_COLOR=MAGENTA;
    __delay_cycles(100000);
    for(i=1;i<50;i++){Draw_Circle(240-i,320-i,i);__delay_cycles(10000);}

LCD_Fill(120-24,160-12,120+24,160+12,WHITE);

check_key();
}
```

以上代码是用来展示一段开机动画，动画结束需要使用键盘输入密码。

<ignore_js_op>

</ignore_js_op>

### 密码认证

```c
void check_key()
{
    uint16_t num_key=0;
    uint16_t right_key=1234;
    char flag_key=0;
    int i=0;
    int key=0;
    BACK_COLOR =WHITE;
    POINT_COLOR=BLACK;
    while(!flag_key)
    {
        LCD_ShowChar(8*i+104,152,'-',1);
        key = getkey();
        if(i<4&&key!=0)
        {
            key -= '0';
            num_key = num_key*10+key;
            key=0;
            LCD_ShowChar(8*i+104,152,'*',0);
            i++;
        }
        if(i==4)
        {
            if(num_key==right_key)
            {
                BACK_COLOR =BLACK;
                POINT_COLOR=WHITE;
                hanzi_32x33(160,146,0);
                BACK_COLOR =GREEN;
                flag_key=1;
                break;
            }
            else
            {
                num_key=0;key=0;i=0;
                LCD_Fill(120-24,160-12,120+24,160+12,WHITE);
                BACK_COLOR =BLACK;
                POINT_COLOR=WHITE;
                hanzi_32x33(160,146,1);
                BACK_COLOR =WHITE;
                POINT_COLOR=BLACK;
            }
        }
        __delay_cycles(300000);
        LCD_ShowChar(8*i+104,152,' ',0);
        __delay_cycles(300000);
    }
}
```

<ignore_js_op>

</ignore_js_op>

循环检测输入密码，其实就是1234，输错会情空，重新输入直到正确为止。输出正确后就进入到了游戏页面。

## 贪吃蛇游戏

一切准备就绪，就剩游戏部分了，也是直接移植的，删掉了51的某些寄存器配置。

### 游戏界面

```c
void interface()
{
    uint8_t i;
    POINT_COLOR=BLUE;
    BACK_COLOR=GREEN;

for(i=1;i<11;i++)
    {
        hanzi_8x16(i*16,0,1);
        hanzi_8x16(i*16,296,1);
    }
    for(i=1;i<18;i++)
    {
        hanzi_16x8(0,i*16,1);
        hanzi_16x8(184,i*16,0);
    }
    hanzi_16x16(0,288,0);
    hanzi_16x16(176,288,1);
    hanzi_16x16(176,0,2);
    hanzi_16x16(0,0,3);

//  BACK_COLOR=WHITE;
    POINT_COLOR=RED;
    hanzi_16x16(192,10,4);    
    hanzi_16x16(208,10,5);
    LCD_ShowChar(224,10,':',0);
    hanzi_16x16(192,58,6);     
    hanzi_16x16(208,58,7);
    LCD_ShowChar(224,58,':',0);
    hanzi_16x16(192,106,8);    
    hanzi_16x16(208,106,9);
    LCD_ShowChar(224,106,':',0);
    hanzi_16x16(192,154,10);    
    hanzi_16x16(208,154,11);
    LCD_ShowChar(224,154,':',0);
    hanzi_16x16(192,202,12);   
    hanzi_16x16(208,202,13);
    LCD_ShowChar(224,202,':',0);

POINT_COLOR=BLACK;
    LCD_ShowNum(192,34,score,5);
    LCD_Show2Num(192,82,time/60,2);
    LCD_ShowChar(208,82,':',0);
    LCD_Show2Num(216,82,time%60,2);
    LCD_ShowNum(192,130,level,3);
    LCD_ShowNum(192,178,snake_len,3);
    LCD_ShowNum(192,226,record,5);
    showimage_32x32(200,250);
    LCD_ShowString(192,282,"Snake");
    LCD_ShowString(192,304,"V1.0");
    LCD_ShowString(20,304,"Start with any key!");

}
```

<ignore_js_op>

</ignore_js_op>

### 启动游戏

```c
void TCS_start()
{
    int i;
    LCD_Clear(GREEN); //ÇåÆá
    interface();
    for(i=0;i<snake_len;i++)
    {
        snake_x<i>=40-8*i;
        snake_y<i>=40;
    }
    POINT_COLOR=SNAKE;
    hanzi_8x8(16,40,right_end);
    hanzi_8x8(24,40,body);
    hanzi_8x8(32,40,body);
    hanzi_8x8(40,40,right_sta);
    LCD_Fill(0,304,176,320,GREEN);
    POINT_COLOR=BLACK;
    LCD_ShowString(60,304,"chose level");
    key=0;
    while(getkey()!=RIGHT)
    {
        if(getkey()==UP){if(level<=6){level++;level_unit-=2;}}
        else if(getkey()==DOWN){if(level>1){level--;level_unit+=2;}}
        key=0;
        LCD_ShowNum(192,130,level,3);
    }
    display_block();
    LCD_Fill(0,304,176,320,GREEN);
    LCD_ShowString(40,304,"are you ready?");
    display_food();
    key=0;
    while(!getkey());
    if(getkey()!=UP&&getkey()!=DOWN)key=RIGHT;
    LCD_Fill(0,304,176,320,GREEN);
    POINT_COLOR=BLACK;
    LCD_ShowString(60,304,"Running...");
//    timer2_int();
    display_food();
}
```

启动游戏后，可以通过上下按键(上下左右对应键盘的2,5,4,6)修改游戏等级，共1-7级，对应不同的速度和障碍物。确认后按右方向(6)键开始游戏，同时后面会启动定时器，开始定时更新蛇身和食物。

### 更新状态

根据不同的状态响应对应的动作。由几个标志位决定。

```c
void display_state()
{
    uint8_t i;
    LCD_Fill(0,304,176,320,GREEN);
    POINT_COLOR=BLACK;
    if(flag_pause)
    {
        LCD_ShowString(60,304,"PAUSE!");
        for(i=9;i<14;i++)
        {
            POINT_COLOR=BLACK+100*(i-6);
            hanzi_16x33(20+16*(i-7),150,i);
        }
    }
    else if(flag_gameover)
    {
        LCD_ShowString(8,304,"Restart with any key!");
        for(i=0;i<9;i++)
        {
            POINT_COLOR=BLACK+100*i;
            hanzi_16x33(20+16*i,150,i);
        }
    }
    else if(flag_levelup)
    {
        LCD_ShowString(50,304,"LEVEL UP!");
        for(i=0;i<8;i++)
        {
            POINT_COLOR=BLACK+100*i;
            hanzi_16x33(40+16*i,150,i+17);
        }
    }
    else
    {
        LCD_ShowString(60,304,"Running...!");
        LCD_Fill(20,150,176,190,GREEN);
        POINT_COLOR=SNAKE;
        hanzi_8x8(food_x,food_y,body);
        //if()
        showimage_16x16(tomato_x,tomato_y,tomato);
        for(i=1;i<snake_len-1;i++)
        hanzi_8x8(snake_x<i>,snake_y<i>,body);
        for(i=0;i<num_block;i++)
        hanzi_8x8(block_x<i>,block_y<i>,block);
    }
}
```

主要的函数就这些了，其它显示函数就不放了，主函数在下面，可以相对清楚的说明整体运行流程。

## main函数

```c
int main(void)
{
        WDTCTL = WDTPW | WDTHOLD;        // stop watchdog timer
        UCS_Init();
        LCD_Init();
        KEY_Init();
        Serial_Init();

run();
        while(1);
}

void run()
{
    start();
    TCS_start();
    TimerA0_Init();

while(1)
    {
        check_DIR();
        if(flag_time)
        {
            display_time();
            flag_time=0;
            serial_send_strings("flag_time is 1\n");
        }
        if(flag_tomato)
        {
            display_tomato();
            flag_tomato=0;
            flag_clear_image=0;
            serial_send_strings("flag_tomato is 1\n");
        }
        if(flag_clear_image)
        {
            LCD_Fill(tomato_x,tomato_y,tomato_x+15,tomato_y+15,GREEN);
            tomato_x=240;tomato_y=320;
            flag_clear_image=0;
            serial_send_strings("flag_clear_image is 1\n");
        }
        if(flag_move)
        {
            serial_send_strings("flag_move is 1\n");
            flag_move=0;
            if (directory == 0) {
                serial_send_strings("directory is 0\n");
                continue;
            }

check_collision();
            if(!flag_gameover)
            {
                clear_old();
                setup_new();
            }
            if(flag_food||eat_tomato)update();
        }
        if(flag_levelup)levelup();
        if(flag_gameover)TCS_restart();
        if(flag_exit){start();TCS_restart();}
    }
}
```

## 测试

<ignore_js_op>

</ignore_js_op>

<ignore_js_op>

</ignore_js_op>

<ignore_js_op>

</ignore_js_op>

## 说明

- 由于代码是很久之前写的，移植也懒得去改了，但是还好没什么毛病，能正常驱动显示和玩耍，哈哈，还不错。
- MSP430产生随机数还没研究过，rand srand函数在MSP430不能用，所以目前也是伪随机。
- 这是该系列最后一篇测评了，算是善始善终吧，哈哈，如果有帮到你就更开心了。

## 参考文档

- [2.2inch SPI Module ILI9341 SKU:MSP2202](http://www.lcdwiki.com/2.2inch_SPI_Module_ILI9341_SKU:MSP2202)

此帖出自微控制器 MCU论坛

lcofjp · 发表于2020-12-24 08:58

要是能录成视频看看效果就更好了

w494143467 · 发表于2020-12-24 14:43

这教程是真的详细，想看玩起来的视频！

wuguangtao · 发表于2020-12-24 18:28

w494143467 发表于 2020-12-24 14:43 这教程是真的详细，想看玩起来的视频！

是想拍来着，但是转成gif就太大了，而且不清楚，所以就没弄，哈哈

w494143467 · 发表于2020-12-24 19:37

可以拍成视频放到B站，然后分享出来~

freebsder · 发表于2020-12-25 18:15

有点意思。这种小游戏确实很锻炼编程能力。

【MSP430F5529测评】7. TFT彩屏贪吃蛇 [复制链接]

赞赏

点评