【正点原子FPGA连载】第三十四章RGB-LCD触摸屏实验 -摘自【正点原子】新起点之FPGA开发指南_V2.1
1）实验平台：正点原子新起点V2开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=609758951113
2）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-300792-1-1.html
3）对正点原子FPGA感兴趣的同学可以加群讨论：994244016
4）关注正点原子公众号，获取最新资料更新
第三十四章RGB-LCD触摸屏实验
触摸屏（Touch Panel）又称为触控屏、触控面板，是一种可接收触头等输入讯号的感应式液晶显示装置，当接触屏幕时，屏幕上的触觉反馈系统可根据预先编程的程式驱动各种连结装置，可用以取代机械式的按钮面板，并借由液晶显示画面制造出生动的影音效果。本节LCD触摸实验将实现手指触碰LCD屏幕，对应触摸点的坐标就会显示在LCD屏幕上的功能。
本章包括以下几个部分：
3333.1简介
33.2实验任务
33.3硬件设计
33.4程序设计
33.5下载验证
34.1简介
目前最常用的触摸屏有两种：电阻式触摸屏与电容式触摸屏。下面，我们来分别介绍这两种或触摸屏。
1）电阻式触摸屏
在Iphone面世之前，几乎清一色的都是使用电阻式触摸屏，电阻式触摸屏利用压力感应进行触点检测控制，需要直接应力接触，通过检测电阻来定位触摸位置。
正点原子2.4/2.8/3.5寸LCD模块自带的触摸屏都属于电阻式触摸屏，下面简单介绍下电阻式触摸屏的原理。
电阻触摸屏的主要部分是一块与显示器表面非常配合的电阻薄膜屏，这是一种多层的复合薄膜，它以一层玻璃或硬塑料平板作为基层，表面涂有一层透明氧化金属（透明的导电电阻）导电层，上面再盖有一层外表面硬化处理、光滑防擦的塑料层、它的内表面也涂有一层涂层、在它们之间有许多细小的（小于1/1000英寸）的透明隔离点把两层导电层隔开绝缘。当手指触摸屏幕时，两层导电层在触摸点位置就有了接触，电阻发生变化，在X和Y两个方向上产生信号，然后送达触摸屏控制器。控制器侦测到这一接触并计算出（X，Y）的位置，再根据获得的位置模拟鼠标的方式运作。这就是电阻技术触摸屏的最基本的原理。
电阻触摸屏的优点：精度高、价格便宜、抗干扰能力强、稳定性好。
电阻触摸屏的缺点：容易被划伤、透光性不太好、不支持多点触摸。
从以上介绍可知，触摸屏都需要一个AD转换器，一般来说是需要一个控制器的。正点原子LCD模块选择的是四线电阻式触摸屏，这种触摸屏的控制芯片有很多，包括：ADS7843、ADS7846、TSC2046、XPT2046和AK4182等。这几款芯片的驱动基本上是一样的，也就是你只要写出了ADS7843的驱动，这个驱动对其他几个芯片也是有效的，而且封装也有一样的，完全PIN TO PIN兼容。所以在替换起来，很方便。
正点原子LCD模块自带的触摸屏控制芯片为XPT2046。XPT2046是一款4导线制触摸屏控制器，内含12位分辨率125KHz转换速率逐步逼近型A/D转换器。XPT2046支持从1.5V到5.25V的低电压I/O接口。XPT2046能通过执行两次A/D转换查出被按的屏幕位置，除此之外，还可以测量加在触摸屏上的压力。内部自带2.5V参考电压可以作为辅助输入、温度测量和电池监测模式之用，电池监测的电压范围可以从0V到6V。XPT2046片内集成有一个温度传感器。在2.7V的典型工作状态下，关闭参考电压，功耗可小于0.75mW。XPT2046采用微小的封装形式：TSSOP-16,QFN-16(0.75mm厚度)和VFBGA－48。工作温度范围为-40℃～+85℃。
该芯片完全是兼容ADS7843和ADS7846的，关于这个芯片的详细使用，可以参考这两个芯片的datasheet。
电阻式触摸屏就介绍到这里。
2）电容式触摸屏
现在几乎所有智能手机，包括平板电脑都是采用电容屏作为触摸屏，电容屏是利用人体感应进行触点检测控制，不需要直接接触或只需要轻微接触，通过检测感应电流来定位触摸坐标。
正点原子4.3/7/10.1寸LCD模块自带的触摸屏采用的是电容式触摸屏，下面简单介绍下电容式触摸屏的原理。
电容式触摸屏主要分为两种：
1、表面电容式电容触摸屏。
表面电容式触摸屏技术是利用ITO(铟锡氧化物，一种透明的导电材料)导电膜，通过电场感应方式感测屏幕表面的触摸行为进行。但是表面电容式触摸屏有一些局限性，它只能识别一个手指或者一次触摸。
投射式电容触摸屏
投射电容式触摸屏是传感器利用触摸屏电极发射出静电场线。一般用于投射电容传感技术的电容类型有两种：自我电容和交互电容。
自我电容又称绝对电容，是最广为采用的一种方法，自我电容通常是指扫描电极与地构成的电容。在玻璃表面有用ITO制成的横向与纵向的扫描电极，这些电极和地之间就构成一个电容的两极。当用手或触摸笔触摸的时候就会并联一个电容到电路中去，从而使在该条扫描线上的总体的电容量有所改变。在扫描的时候，控制IC依次扫描纵向和横向电极，并根据扫描前后的电容变化来确定触摸点坐标位置。笔记本电脑触摸输入板就是采用的这种方式，笔记本电脑的输入板采用XY的传感电极阵列形成一个传感格子，当手指靠近触摸输入板时，在手指和传感电极之间产生一个小量电荷。采用特定的运算法则处理来自行、列传感器的信号，以此确定手指的位置。
交互电容又叫做跨越电容，它是在玻璃表面的横向和纵向的ITO电极的交叉处形成电容。交互电容的扫描方式就是扫描每个交叉处的电容变化，来判定触摸点的位置。当触摸的时候就会影响到相邻电极的耦合，从而改变交叉处的电容量，交互电容的扫面方法可以侦测到每个交叉点的电容值和触摸后电容变化，因而它需要的扫描时间与自我电容的扫描方式相比要长一些，需要扫描检测XY根电极。目前智能手机/平板电脑等的触摸屏，都是采用交互电容技术。
正点原子所选择的电容触摸屏，采用的是投射式电容屏（交互电容类型），所以后面仅以投射式电容屏作为介绍。
透射式电容触摸屏采用纵横两列电极组成感应矩阵来感应触摸。以两个交叉的电极矩阵（X轴电极和Y轴电极）来检测每一格感应单元的电容变化，如下图所示：
图 34.1.1 投射式电容屏电极矩阵示意图
示意图中的电极，实际是透明的，这里是为了方便大家理解故填充了颜色。图中，X、Y轴的透明电极电容屏的精度、分辨率与X、Y轴的通道数有关，通道数越多，精度越高。以上就是电容触摸屏的基本原理，接下来看看电容触摸屏的优缺点：
电容触摸屏的优点：手感好、无需校准、支持多点触摸、透光性好。
电容触摸屏的缺点：成本高、精度不高、抗干扰能力差。
这里特别提醒大家电容触摸屏对工作环境的要求是比较高的，在潮湿、多尘、高低温环境下面，都是不适合使用电容屏的。
电容触摸屏一般都需要一个驱动IC来检测电容触摸，且一般是通过IIC接口输出触摸数据的。正点原子7’LCD模块的电容触摸屏，使用FT5206/FT5426做为驱动IC，该IC采用的是1528的驱动结构（15个感应通道，28个驱动通道）。正点原子4.3’LCD模块则使用GT9147作为驱动IC，该IC采用1710的驱动结构（10个感应通道，17个驱动通道）。
这两种不同尺寸的屏幕都只支持最多5点触摸，本例程除CPLD方案的V1版本7寸屏模块不支持外，其他所有正点原子的RGB LCD模块都支持，电容触摸驱动IC，这里只介绍GT9147的驱动，FT5206和FT5426的驱动同GT9147类似，大家可以参考着学习即可。
下面我们简单介绍下GT9147，该芯片是深圳汇顶科技研发的一颗电容触摸屏驱动IC，支持100Hz触点扫描频率，支持5点触摸，支持18*10个检测通道，适合小于4.5寸的电容触摸屏使用。
GT9147与FPGA连接是通过4根线：SDA、SCL、RST和INT。其中：SDA和SCL是IIC通信用的，RST是复位脚（低电平有效），INT是中断输出信号。
GT9147的IIC地址，可以是0X14或者0X5D，当复位结束后的5ms内，如果INT是高电平，则使用0X14作为地址，否则使用0X5D作为地址，具体的设置过程请参考GT9147数据手册.pdf这个文档。本章我们使用0X14作为器件地址（不含最低位，换算成读写命令则是读：0X29，写：0X28）。接下来，介绍一下GT9147的几个重要的寄存器。
1，控制命令寄存器（0X8040）
该寄存器可以写入不同值，实现不同的控制，我们一般使用0和2这两个值，写入2，即可软复位GT9147，在硬复位之后，一般要往该寄存器写2，实行软复位。然后，写入0，即可正常读取坐标数据（并且会结束软复位）。
2，配置寄存器组（0X8047~0X8100）
这里共186个寄存器，用于配置GT9147的各个参数，这些配置一般由厂家提供给我们（一个数组），所以我们只需要将厂家给我们的配置，写入到这些寄存器里面，即可完成GT9147的配置。由于GT9147可以保存配置信息（可写入内部FLASH，从而不需要每次上电都更新配置），这里有几点注意的地方提醒大家：1，0X8047寄存器用于指示配置文件版本号，程序写入的版本号，必须大于等于GT9147本地保存的版本号，才可以更新配置。2，0X80FF寄存器用于存储校验和，使得0X8047~0X80FF之间所有数据之和为0。3，0X8100用于控制是否将配置保存在本地，写0，则不保存配置，写1则保存配置。
3，产品ID寄存器（0X8140~0X8143）
这里总共由 4 个寄存器组成，用于保存产品 ID，对于GT9147，这4个寄存器读出来就是：9，1，4，7四个字符（ASCII码格式）。因此，我们可以通过这4个寄存器的值，来判断驱动IC的型号，从而判断是GT9147还是FT5206，以便执行不同的初始化。
4，状态寄存器（0X814E）
该寄存器各位描述如下表所示：
表 34.1.1 寄存器定义
这里，我们仅关心最高位和最低4位，最高位用于表示buffer状态，如果有数据（坐标/按键），buffer就会是1，最低4位用于表示有效触点的个数，范围是：0~5，0表示没有触摸，5表示有5点触摸。最后，该寄存器在每次读取后，如果bit7有效，则必须写0，清除这个位，否则不会输出下一次数据！！这个要特别注意！！！
5，坐标数据寄存器（共 30 个）
这里共分成5组（5个点），每组6个寄存器存储数据，以触点1的坐标数据寄存器组为例，如下表所示：
表 34.1.2 触点 1 坐标寄存器组描述
我们一般只用到触点的x，y坐标，所以只需要读取0X81500X8153的数据，组合即可得到触点坐标。其他4组分别是：0X8158、0X8160、0X8168和0X8170等开头的16个寄存器组成，分别针对触点24的坐标。GT9147支持寄存器地址自增，我们只需要发送寄存器组的首地址，然后连续读取即可，GT9147会自动地址自增，从而提高读取速度。
GT9147相关寄存器的介绍就介绍到这里，更详细的资料，请参考：GT9147编程指南.pdf这个文档。
GT9147只需要经过简单的初始化就可以正常使用了，初始化流程：硬复位→延时10ms→结束硬复位→设置IIC地址→延时100ms→软复位→更新配置（需要时）→结束软复位。此时GT9147即可正常使用了。
然后，我们不停的查询0X814E寄存器，判断是否有有效触点，如果有，则读取坐标数据寄存器，得到触点坐标，特别注意，如果0X814E读到的值最高位为1，就必须对该位写0，否则无法读到下一次坐标数据。
特别说明：FT5206和FT5426的驱动代码完全一模一样，他们只是版本号读取的时候稍有差异，读坐标数据和配置等操作动完全是一模一样的。所以，这两个电容屏驱动IC，可以共用一个驱动程序。电容式触摸屏部分，就介绍到这里。
34.2实验任务
使用新起点开发板驱动LCD显示屏，用手触摸显示屏，在屏幕上显示触摸点的坐标。
34.3硬件设计
新起点板载的LCD接口原理图如图 34.3.1所示。
**
**
图 34.3.1 LCD接口原理图
上图中的关于LCD显示部分的引脚就不再介绍了，这里我们主要看下CT_RST、IIC2_SDA、IIC2_SCL、CT_INT四个引脚，这四个引脚分别连接到了GT9147的RST、SDA、SCL和INT四根引脚，我们在代码中通过控制这四个引脚来初始化GT9147芯片或者和GT9147进行数据交互。
本实验中，各端口信号的管脚分配（由于引脚比较多，这里只给出了GT9147的控制引脚，详细引脚请参考例程提供的TCL文件）如下表所示：
表 34.3.1 触摸显示实验管脚分配
对应的约束语句（GT9147的引脚约束语句）如下所示：
set_location_assignment PIN_P1 -to touch_sda
set_location_assignment PIN_P2 -to touch_rst
set_location_assignment PIN_L2 -to touch_int
set_location_assignment PIN_N1 -to touch_scl
34.4程序设计
根据实验任务我们画出了如下的程序框图：
图 34.4.1 LCD触摸实验程序框图
从上图的程序框架中可以看出本次实验的软件工程主要分成两个大模块：一个是GT9147配置模块（本节实验文档是以GT9147为例的，其他触摸芯片的配置和GT9147基本雷同），这个模块当中包含了IIC通信协议模块，触摸控制模块和信号切换模块，其主要作用就是配置触摸芯片，并和触摸芯片进行数据交互；另一个模块就是LCD显示模块了，这个模块大家应该很熟悉了，在前面LCD显示相关的实验中已经和大家讲解过了，在此就不再重复赘述了。下面我们来一起分析一下本节实验的代码。
本次LCD触摸实验的代码可以分成三个大模块：顶层例化模块（top_lcd_touch）、触摸配置顶层模块（top_touch）、LCD屏幕显示顶层模块（lcd_rgb_char）。
其中顶层例化模块（top_lcd_touch）模块代码如下：
1 module top_lcd_touch(
2
3 //时钟和复位接口
4 input sys_clk, //晶振时钟
5 input sys_rst_n, //按键复位
6 //TOUCH 接口
7 inout touch_sda,
8 output touch_scl,
9 inout touch_int,
10 output touch_rst,
11 //RGB LCD接口
12 output lcd_de, //LCD 数据使能信号
13 output lcd_hs, //LCD 行同步信号
14 output lcd_vs, //LCD 场同步信号
15 output lcd_bl, //LCD 背光控制信号
16 output lcd_rst_n,
17 output lcd_clk, //LCD 像素时钟
18 inout [15:0] lcd_rgb //LCD RGB888颜色数据
19 );
20
21 //wire define
22 wire clk_100m ;
23 wire clk_50m ;
24 wire locked ;
25 wire rst_n ;
26 wire touch_valid ;
27 wire [15:0] lcd_id ;
28 wire [31:0] tp1_xy ;
29 wire [31:0] data ;
30 wire tft_sda_i ;
31 wire tft_sda_o ;
32 wire tft_sda_t ;
33 //*****************************************************
34 //** main code
35 //*****************************************************
36
37 assign rst_n = sys_rst_n & locked;
38 assign data = {tp1_xy[31:16],tp1_xy[15:0]};
39 assign lcd_rst_n = 1'b1;
40 assign touch_sda = tft_sda_t ? tft_sda_o : 1'bz;
41 assign tft_sda_i = touch_sda;
42
43 pll pll_inst (
44 .areset ( ~sys_rst_n ),
45 .inclk0 ( sys_clk ),
46 .c0 ( clk_50m ),
47 .c1 ( clk_100m ),
48 .locked ( locked )
49 );
50
51 //触摸驱动
52 top_touch u_top_touch(
53 .sys_clk (clk_100m),
54 .sys_rst_n (rst_n),
55 .lcd_id (lcd_id), //LCD ID
56
57 // .tft_sda (touch_sda ),
58 .tft_sda_i (tft_sda_i),
59 .tft_sda_o (tft_sda_o),
60 .tft_sda_t (tft_sda_t),
61 .tft_scl (touch_scl),
62 .tft_int (touch_int),
63 .tft_tcs (touch_rst),
64 .tp1_xy (tp1_xy),
65 .touch_valid (touch_valid),
66 .tp_num ()
67 );
68
69 //例化LCD显示模块
70 lcd_rgb_char u_lcd_rgb_char
71 (
72 .sys_clk (clk_50m),
73 .sys_rst_n (rst_n),
74 .data (data),
75 //RGB LCD接口
76 .lcd_id (lcd_id),
77 .lcd_hs (lcd_hs), //LCD 行同步信号
78 .lcd_vs (lcd_vs), //LCD 场同步信号
79 .lcd_de (lcd_de), //LCD 数据输入使能
80 .lcd_rgb (lcd_rgb), //LCD RGB565颜色数据
81 .lcd_bl (lcd_bl), //LCD 背光控制信号
82 .lcd_clk (lcd_clk) //LCD 采样时钟
83 );
84
85 endmodule
顶层代码比较简单主要就是例化锁相环（pll）模块、触摸配置顶层模块（top_touch）和LCD屏幕显示顶层模块（lcd_rgb_char），需要注意的一点就是代码第40和41行做了一个双向的判断，因为IIC协议不仅仅是主机（FPGA）对从机（GT9147）写数据，还要接收从机反馈的数据，因此touch_sda信号什么时候作为输入什么时候作为输出必须给出一个判断条件（tft_sda_t）来判断，这个判断条件是由IIC驱动模块（i2c_dri_m）发出的；还有一个GT9147自身中断控制信号（touch_int）也是双向信号，它是在触摸控制模块做的处理。
接下来我们继续分析顶层模块（top_lcd_touch）所例化的子模块代码，首先看一下锁相环（pll）模块，它主要是用来生成一路50M时钟（clk_50m）和一路100M（clk_100m）时钟。可能有人会疑惑系统时钟不就是50M时钟，为什么还要重新生成一次50M时钟？其实将系统时钟过一遍锁相环是常用的一种消除时钟抖动、扭斜的方法，并且锁相环还输出了一个locked信号，这个信号拉高代表时钟稳定，此时再去执行逻辑语句会使整个工程的时序更加稳定。
看完锁相环（pll）模块后我们继续分析触摸配置顶层模块（top_touch），顾名思义配置顶层模块是整个触摸操作的顶层模块，它同样例化了2个子模块，分别是寄存器配置模块（touch_gt_cfg）和触摸控制模块（touch_ctrl），下面给出触摸配置顶层模块（top_touch）的代码：
1 module top_touch(
2 //module clock
3 input sys_clk, // 系统时钟信号
4 input sys_rst_n, // 复位信号（低有效）
5
6 //tft interface
7 // inout tft_sda,
8 input tft_sda_i,
9 output tft_sda_o,
10 output tft_sda_t,
11 output tft_scl,
12 inout tft_int,
13 output tft_tcs,
14
15 //touch lcd interface
16 output touch_valid, // 连续触摸标志
17 output [2:0] tp_num,
18
19 input [15:0] lcd_id,
20 output [31:0] tp1_xy
21 );
22
23 //parameter define
24 parameter WIDTH = 5'd8;
25 //wire define
26 wire sda_out ;
27 wire sda_dir ;
28 wire ack;
29 wire i2c_exec ;
30 wire i2c_rh_wl ;
31 wire [15:0] i2c_addr ;
32 wire [ 7:0] i2c_data_w;
33 wire [WIDTH-1'b1:0] reg_num ;
34 wire [ 7:0] i2c_data_r;
35 wire i2c_done ;
36 wire once_done ;
37 wire bit_ctrl ;
38 wire clk ;
39 wire cfg_done ;
40 wire cfg_switch;
41
42 //*****************************************************
43 //** main code
44 //*****************************************************
45
46 assign tft_sda_o=sda_out;
47 assign tft_sda_t=sda_dir;
48
49 touch_gt_cfg #(.WIDTH(4'd8)) u_touch_gt_cfg(
50 //module clock
51 .clk (sys_clk ), // 时钟信号
52 .rst_n (sys_rst_n ), // 复位信号
53 //port interface
54 .scl (tft_scl ), // 时钟线scl
55 .sda_in (tft_sda_i ), // 数据线sda
56 .sda_out (sda_out),
57 .sda_dir (sda_dir),
58 //I2C interface
59 .ack (ack ),
60 .i2c_exec (i2c_exec ), // i2c触发控制
61 .i2c_rh_wl (i2c_rh_wl ), // i2c读写控制
62 .i2c_addr (i2c_addr ), // i2c操作地址
63 .i2c_data_w (i2c_data_w), // i2c写入的数据
64 .reg_num (reg_num ),
65 .i2c_data_r (i2c_data_r), // i2c读出的数据
66 .i2c_done (i2c_done ), // i2c操作结束标志
67 .once_done (once_done ), // 一次读写操作完成
68 .bit_ctrl (bit_ctrl ),
69 .clk_i2c (clk ), // I2C操作时钟
70 .cfg_done (cfg_done ), // 寄存器配置完成标志
71 //user interfacd
72 .cfg_switch (cfg_switch),
73 .lcd_id (lcd_id ) //LCD ID
74 );
75
76 touch_ctrl
77 #(.WIDTH(4'd8)) // 一次读写寄存器的个数的位宽
78 u_touch_ctrl(
79 //module clock
80 .clk (clk ), // 时钟信号
81 .rst_n (sys_rst_n), // 复位信号（低有效）
82 .cfg_done (cfg_done ), // 配置完成标志
83 .tft_tcs (tft_tcs ),
84 .tft_int (tft_int ),
85
86 //I2C interface
87 .ack (ack ),
88 .i2c_exec (i2c_exec ), // i2c触发控制
89 .i2c_rh_wl (i2c_rh_wl ), // i2c读写控制
90 .i2c_addr (i2c_addr ), // i2c操作地址
91 .i2c_data_w (i2c_data_w), // i2c写入的数据
92 .i2c_data_r (i2c_data_r), // i2c读出的数据
93 .once_done (once_done ), // 一次读写操作完成
94 .i2c_done (i2c_done ), // i2c操作结束标志
95 .bit_ctrl (bit_ctrl ),
96 .reg_num (reg_num ), // 一次读写寄存器的个数
97
98 //touch lcd interface
99 .touch_valid (touch_valid),
100 .tp_num (tp_num),
101 .tp1_xy (tp1_xy),
102 .tp2_xy (),
103 .tp3_xy (),
104 .tp4_xy (),
105 .tp5_xy (),
106
107 //user interface
108 .cfg_switch (cfg_switch),
109 .lcd_id (lcd_id ) //LCD ID
110 );
111
112 endmodule
触摸配置顶层模块（top_touch）的代码没有什么好讲解的，它就是单纯的作为一个顶层模块去例化寄存器配置模块（touch_gt_cfg）和触摸控制模块（touch_ctrl），下面我们来重点分析这两个子模块。
首先给出触摸控制模块（touch_ctrl）的代码（由于这个模块的代码太长我们一段一段的分析）：
82 assign tft_int = int_dir ? int_out : 1'bz;
83
84 always @(*) begin
85 if(lcd_id[15:8] == 8'h70 ) begin // 7寸屏的FT系列触摸芯片
86 bit_ctrl = 1'b0 ;
87 CTRL_REG = 8'h00; // 控制寄存器地址
88 GTCH_REG = 8'h02; // 检测到的当前触摸情况
89 TP1_REG = 8'h03; // 第一个触摸点数据地址
90 TP2_REG = 8'h09; // 第二个触摸点数据地址
91 TP3_REG = 8'h0f; // 第三个触摸点数据地址
92 TP4_REG = 8'h15; // 第四个触摸点数据地址
93 TP5_REG = 8'h1b; // 第五个触摸点数据地址
94 end
95 else begin
96 bit_ctrl = 1'b1 ;
97 CTRL_REG = 16'h8040; // 控制寄存器地址
98 GTCH_REG = 16'h814e; // 检测到的当前触摸情况
99 TP1_REG = 16'h8150; // 第一个触摸点数据地址
100 TP2_REG = 16'h8158; // 第二个触摸点数据地址
101 TP3_REG = 16'h8160; // 第三个触摸点数据地址
102 TP4_REG = 16'h8168; // 第四个触摸点数据地址
103 TP5_REG = 16'h8170; // 第五个触摸点数据地址
104 end
105 end
106
107 //计时控制
108 always @(posedge clk or negedge rst_n) begin
109 if(!rst_n) begin
110 cnt_1us_cnt <= 20'd0;
111 end
112 else if(cnt_1us_en)
113 cnt_1us_cnt <= cnt_1us_cnt + 1'b1;
114 else
115 cnt_1us_cnt <= 'd0;
116 end
117
118 //状态跳转
119 always @ (posedge clk or negedge rst_n) begin
120 if(!rst_n)
121 cur_state <= init;
122 else
123 cur_state <= next_state;
124 end
125
126 //组合逻辑状态判断转换条件
127 always @( * ) begin
128 case(cur_state)
129 init: begin
130 if(st_done)
131 if(lcd_id == 16'h4384 || lcd_id == 16'h4342)
132 next_state = chk_touch;
133 else
134 next_state = cfg_state;
135 else
136 next_state = init;
137 end
138
139 cfg_state: begin
140 if(st_done) begin
141 next_state = chk_touch;
142 end
143 else
144 next_state = cfg_state;
145 end
146 chk_touch: begin
147 if(st_done)
148 next_state = change_addr;
149 else
150 next_state = chk_touch;
151 end
152 change_addr: begin
153 if(st_done)
154 next_state = getpos_xy;
155 else
156 next_state = change_addr;
157 end
158 getpos_xy: begin
159 if(st_done)
160 next_state = id_handle;
161 else
162 next_state = getpos_xy;
163 end
164 id_handle: begin
165 if(st_done)
166 next_state = tp_xy;
167 else
168 next_state = id_handle;
169 end
170 tp_xy: begin
171 if(st_done) begin
172 if(tp_num_t == tp_num)
173 next_state = chk_touch;
174 else
175 next_state = change_addr;
176 end
177 else
178 next_state = tp_xy;
179 end
180 default: next_state = init;
181 endcase
182 end
因为这个模块的代码特别长，所以乍一看可能觉得特别难，但是你只要把这个模块的内容理顺了你就会发现这个模块的代码并不是很难，它是由一个LCD显示屏ID判断模块、一个计数器和一个经典三段状态机组成。代码的第84105行就是LCD显示屏ID判断模块，根据不同的屏幕ID来判断触摸芯片是七寸屏的FT系列触摸芯片还是4.3寸屏的GT系列触摸芯片（10.1寸屏也是GT系列），不同系列触摸芯片的配置寄存器地址不同（具体寄存器地址可以查找对应芯片的数据手册），同一系列芯片的寄存器地址相同（这里仅仅是指触摸数据的存放地址相同，其它功能性寄存器地址即使是同一系列的也存在差异，具体的要看对应芯片数据手册）。代码的第108116行是一个计数器，通过计数器使能信号（cnt_1us_en）来控制这个计数器的持续累加还是清零。
接下来的代码就是经典的三段状态机了，其中代码第119124行是状态机第一段，主要就是时序逻辑下让状态机发生状态跳转，而代码第127182行则是组合逻辑下判断状态机发生改变的执行条件，整个第二段（三段状态机的第二段）的状态变化条件都有st_done信号，这个信号是状态机每个状态内逻辑执行完成的标志，由状态机第三段控制。我们可以看到整个状态机共有七个状态分别是init（初始化状态）、cfg_state（配置寄存器状态）、chk_touch（触摸检测状态）、change_addr（触摸数据寄存器地址改变状态）、getpos_xy（读取触摸点坐标状态）、id_handle（坐标数据处理状态）和tp_xy（输出触摸点坐标状态）。首先进入初始化状态，在初始化状态会检查外接的显示屏ID，如果是4.3寸屏幕就跳过寄存器配置状态（因为出厂的时候厂家已经将触摸芯片的寄存器配置好了不需要我们再去重复配置，如果大家一定想自己配置寄存器，也可以不跳过配置状态进行寄存器配置，但是前提是一定要将整个工程完全看懂并且熟悉了芯片手册，否则一旦寄存器配置错误LCD显示屏将无法正常工作，即使断电重启也不行，因为配置信息会存储在FLASH中。所以这里提醒读者修改寄存器一定要慎重）进入触摸检测状态，如果是10寸屏或者7寸屏就会进入寄存器配置状态，等待寄存器配置完成再进入触摸检测状态；进入触摸检测状态后等待触摸检测状态的逻辑执行完（st_done拉高）然后进入触摸数据寄存器地址改变状态，同理等待逻辑执行完成后进入下一状态，直到进入最后一个状态（输出触摸点坐标状态），然后开始检测触摸点的个数（除了10.1寸屏幕支持最大10点触摸之外其他屏幕都是支持最大5点触摸），如果触摸点个数没有达到最大个数，则进入触摸数据寄存器地址改变状态，改变寄存器读取地址读出下一个点的坐标；如果达到了最大触摸点个数（注意这里的最大触摸点个数是可以设置的不一定就是10.1寸屏的最大10点触摸或者其他尺寸的最大5点触摸，小于10或者小于5都是可以的）则进入触摸检测状态进行下一轮的触摸点坐标检测，最终状态机会在chk_touch（触摸检测状态）、change_addr（触摸数据寄存器地址改变状态）、getpos_xy（读取触摸点坐标状态）、id_handle（坐标数据处理状态）和tp_xy（输出触摸点坐标状态）之间循环执行，以达到将连续触摸的点都输出出来的功能。
清楚了整个状态机的运作机制后我们再来看看每个状态都执行了哪些逻辑，也就是第三段状态机的内容，第三段状态机代码如下：183
184 always @ (posedge clk or negedge rst_n) begin
185 if(!rst_n) begin
186 touch_valid <= 1'b0;
187 flow_cnt <= 4'b0;
188 st_done <= 1'b0;
189 cnt_1us_en <= 1'b0;
190 i2c_exec <= 1'b0;
191 tft_tcs <= 1'b0;
192 int_dir <= 1'b0;
193 int_out <= 1'b0;
194 i2c_addr <= 16'b0;
195 i2c_data_w <= 8'd0;
196 i2c_rh_wl <= 1'd0;
197 cfg_switch <= 1'd0;
198 tp_num <= 3'b0;
199 tp_num_t <= 3'd0;
200 reg_addr <= 16'd0;
201 tp_x <= 16'd0;
202 tp_y <= 16'd0;
203 tp1_xy <= 32'd0;
204 tp2_xy <= 32'd0;
205 tp3_xy <= 32'd0;
206 tp4_xy <= 32'd0;
207 tp5_xy <= 32'd0;
208 end
209 else begin
210 i2c_exec <= 1'b0;
211 st_done <= 1'b0;
212 case(next_state)
213 init: begin
214 case(flow_cnt)
215 'd0: begin
216 flow_cnt <= flow_cnt + 1'b1;
217 int_dir <= 1'b1;
218 int_out <= 1'b1;
219 end
220 'd1: begin
221 cnt_1us_en <= 1'b1;
222 if(cnt_1us_cnt <= 20000) begin // 延时20ms
223 tft_tcs <= 1'b0;
224 end
225 else begin
226 tft_tcs <= 1'b1;
227 cnt_1us_en <= 1'b0;
228 flow_cnt <= flow_cnt + 1'b1;
229 end
230 end
231 'd2 : begin
232 cnt_1us_en <= 1'b1;
233 if(cnt_1us_cnt == 10000) begin // 延时10ms设置IIC地址
234 int_dir <= 1'b0;
235 end
236 else if(cnt_1us_cnt == 100000) begin //延时100ms
237 cnt_1us_en <= 1'b0;
238 st_done <= 1'b1;
239 int_dir <= 1'b0;
240 flow_cnt <= 'd0;
241 end
242 end
243 default : ;
244 endcase
245 end
246
247 cfg_state: begin
248 st_done <= 1'b0;
249 case(flow_cnt)
250 'd0 : begin
251 i2c_exec <= 1'b1;
252 i2c_addr <= CTRL_REG;
253 if(lcd_id[15:8] == 8'h70)
254 i2c_data_w<= 8'h00;
255 else
256 i2c_data_w<= 8'h02;
257 reg_num <= 'd1;
258 i2c_rh_wl <= 1'b0;
259 flow_cnt <= flow_cnt + 1'b1;
260 end
261 'd1: begin
262 if(i2c_done) begin
263 if(ack)
264 flow_cnt <= flow_cnt - 1'b1;
265 else
266 flow_cnt <= flow_cnt + 1'b1;
267 end
268 end
269 'd2 : begin
270 i2c_exec <= 1'b1;
271 if(lcd_id[15:8] == 8'h70 )
272 i2c_addr <= FT_ID_G_MODE;
273 else
274 i2c_addr <= CTRL_REG;
275 i2c_data_w <= 8'h0;
276 i2c_rh_wl <= 1'b0;
277 reg_num <= 'd1;
278 flow_cnt <= flow_cnt + 1'b1;
279 end
280 'd3 : begin
281 if(i2c_done) begin
282 if(ack)
283 flow_cnt <= flow_cnt - 1'b1;
284 else
285 flow_cnt <= flow_cnt + 1'b1;
286 end
287 end
288 'd4 : begin
289 if(lcd_id[15:8] == 8'h70 )
290 flow_cnt <= 'd7;
291 else begin
292 flow_cnt <= flow_cnt + 1'b1;
293 cfg_switch <= 1'b1;
294 end
295 end
296 'd5: begin
297 if(cfg_done) begin
298 cfg_switch <= 1'b0;
299 flow_cnt <= flow_cnt + 1'b1;
300 end
301 end
302 'd6 : begin
303 if(i2c_done) begin
304 st_done <= 1'b1;
305 flow_cnt <= 'd0;
306 end
307 end
308 'd7: begin //设置触摸有效值
309 i2c_exec <= 1'b1;
310 i2c_addr <= FT_ID_G_THGROUP;
311 i2c_data_w<= 8'd22;
312 reg_num <= 'd1;
313 i2c_rh_wl <= 1'b0;
314 flow_cnt <= flow_cnt + 1'b1;
315 end
316 'd8: begin
317 if(i2c_done) begin
318 if(!ack)
319 flow_cnt <= flow_cnt + 1'b1;
320 else
321 flow_cnt <= flow_cnt - 1'b1;
322 end
323 end
324 'd9: begin //激活周期，不能小于12，最大14
325 i2c_exec <= 1'b1;
326 i2c_addr <= FT_ID_G_PERIODACTIVE;
327 i2c_data_w<= 8'd12;
328 reg_num <= 'd1;
329 i2c_rh_wl <= 1'b0;
330 flow_cnt <= flow_cnt + 1'b1;
331 end
332 'd10: begin
333 if(i2c_done) begin
334 flow_cnt <= 'b0;
335 st_done <= 1'b1;
336 end
337 end
338 default : ;
339 endcase
340 end
341 chk_touch: begin // 检测触摸状态
342 st_done <= 1'b0;
343 case(flow_cnt)
344 'd0: begin
345 tp_num_t <= 3'd0;
346 tp_num <= 3'd0;
347 if(lcd_id[15:8] == 8'h70 )
348 flow_cnt <= flow_cnt + 1'b1;
349 else if(lcd_id[15:8] == 8'h10)begin
350 cnt_1us_en <= 1'b1;
351 if(cnt_1us_cnt == 50000)
352 flow_cnt <= flow_cnt + 1'b1;
353 end
354 else begin
355 cnt_1us_en <= 1'b1;
356 if(cnt_1us_cnt == 17000) //模块驱动时钟周期为625ns（频率为I2C时钟的4倍，400Kbps*4）
357 flow_cnt <= flow_cnt + 1'b1; //此处每隔625ns*17000采样一次，即LCD每隔10.625ms更新一次坐标
358 end
359 end
360 'd1: begin //'d2
361 if(lcd_id==16'h7016)begin
362 cnt_1us_en <= 1'b1;
363 if(cnt_1us_cnt == 2000) begin
364 cnt_1us_en <= 1'b0;
365 i2c_exec <= 1'b1;
366 i2c_addr <= GTCH_REG;
367 i2c_rh_wl<= 1'b1;
368 reg_num <= 'd1;
369 flow_cnt <= flow_cnt + 1'b1;
370 end
371 end
372 else begin
373
374 cnt_1us_en <= 1'b0;
375 i2c_exec <= 1'b1;
376 i2c_addr <= GTCH_REG;
377 i2c_rh_wl<= 1'b1;
378 reg_num <= 'd1;
379 flow_cnt <= flow_cnt + 1'b1;
380 end
381 end
382
383 'd2: begin
384 if(i2c_done) begin
385 if(ack)
386 flow_cnt <= flow_cnt - 1'b1;
387 else
388 flow_cnt <= flow_cnt + 1'b1;
389 end
390 end
391 'd3: begin
392 if(lcd_id[15:8] == 8'h70 )
393 flow_cnt <= flow_cnt + 1'b1;
394 else
395 flow_cnt <= flow_cnt + 2'd2;
396 end
397 'd4: begin
398 if(i2c_data_r != 8'hff && i2c_data_r[3:0] != 4'd0 && i2c_data_r[3:0] < 4'd6) begin
399 flow_cnt <= 'd0;
400 st_done <= 1'b1;
401 touch_valid<= 1'b1;
402 tp_num <= i2c_data_r[2:0];
403 end
404 else begin
405 touch_valid<= 1'b0;
406 flow_cnt <= 'd1;
407 end
408 end
409 'd5: begin
410 if(i2c_data_r[7]== 1'b1 && i2c_data_r[3:0] != 4'd0) begin
411 flow_cnt <= flow_cnt + 1'b1;
412 touch_valid<= 1'b1; //i2c_data_r[4];
413 tp_num <= i2c_data_r[2:0];
414 end
415 else begin
416 touch_valid<= 1'b0; //i2c_data_r[4];
417 flow_cnt <= flow_cnt + 1'b1;
418 end
419 end
420 'd6: begin
421 i2c_exec <= 1'b1;
422 i2c_addr <= GTCH_REG;
423 i2c_rh_wl<= 1'b0;
424 i2c_data_w<= 8'd0;
425 reg_num <= 'd1;
426 flow_cnt <= flow_cnt + 1'b1;
427 end
428 'd7: begin
429 if(i2c_done) begin
430 if(ack)
431 flow_cnt <= flow_cnt - 1'b1;
432 else if(tp_num) begin
433 st_done <= 1'b1;
434 flow_cnt <= 'd0;
435 end
436 else
437 flow_cnt <= 'd0;
438 end
439 end
440 default : ;
441 endcase
442 end // case: touch_statue
443 change_addr: begin
444 st_done <= 1'b0;
445 if(tp_num_t < tp_num) begin
446 case(tp_num_t)
447 'd0 : begin
448 reg_addr <= TP1_REG;
449 st_done <= 1'b1;
450 end
451 'd1 : begin
452 reg_addr <= TP2_REG;
453 st_done <= 1'b1;
454 end
455 'd2 : begin
456 reg_addr <= TP3_REG;
457 st_done <= 1'b1;
458 end
459 'd3 : begin
460 reg_addr <= TP4_REG;
461 st_done <= 1'b1;
462 end
463 'd4 : begin
464 reg_addr <= TP5_REG;
465 st_done <= 1'b1;
466 end
467 default : ;
468 endcase
469 end
470 else begin
471 st_done <= 1'b1;
472 end
473 end
474 getpos_xy: begin
475 st_done <= 1'b0;
476 case(flow_cnt)
477 'd0 : begin
478 i2c_exec <= 1'b1;
479 i2c_rh_wl<= 1'b1;
480 i2c_addr <= reg_addr;
481 reg_num <= 'd4;
482 flow_cnt <= flow_cnt + 1'b1;
483 end
484 'd1 : begin
485 if(ack)
486 flow_cnt <= flow_cnt - 1'b1;
487 if(once_done) begin
488 tp_x[7:0] <= i2c_data_r;
489 flow_cnt <= flow_cnt + 1'b1;
490 end
491 end
492 'd2 : begin
493 if(once_done) begin
494 tp_x[15:8] <= i2c_data_r;
495 flow_cnt <= flow_cnt + 1'b1;
496 end
497 end
498 'd3 : begin
499 if(once_done) begin
500 tp_y[7:0] <= i2c_data_r;
501 flow_cnt <= flow_cnt + 1'b1;
502 end
503 end
504 'd4 : begin
505 if(i2c_done) begin
506 tp_y[15:8] <= i2c_data_r;
507 st_done <= 1'b1;
508 flow_cnt <= 'd0;
509 end
510 end
511 default : ;
512 endcase
513 end
514 id_handle: begin
515 st_done <= 1'b0;
516 case(lcd_id)
517 16'h4342: begin // 4.3' RGB
518 tp_x <= tp_x;
519 tp_y <= tp_y;
520 st_done <= 1'b1;
521 end
522 16'h7084,16'h1963: begin
523 tp_x <= {4'd0,tp_y[3:0],tp_y[15:8]};
524 tp_y <= {4'd0,tp_x[3:0],tp_x[15:8]};
525 st_done <= 1'b1;
526 end
527 16'h7016: begin
528 tp_x <={4'd0,tp_y[3:0],tp_y[15:8]};
529 tp_y <={4'd0,tp_x[3:0],tp_x[15:8]};
530 st_done <= 1'b1;
531 end
532 16'h1018: begin
533 tp_x <= tp_x;
534 tp_y <= tp_y;
535 st_done <= 1'b1;
536 end
537 16'h4384: begin
538 tp_x <=tp_x;
539 tp_y <=tp_y;
540 st_done <= 1'b1;
541 end
542
543 default: st_done <= 1'b1;
544 endcase
545 end
546 tp_xy: begin
547 st_done <= 1'b0;
548 case(tp_num_t)
549 'd0: begin
550 tp1_xy <= {tp_x,tp_y};
551 st_done <= 1'b1;
552 tp_num_t <= tp_num_t + 1'b1;
553 end
554 'd1 : begin
555 tp2_xy <= {tp_x,tp_y};
556 st_done <= 1'b1;
557 tp_num_t <= tp_num_t + 1'b1;
558 end
559 'd2: begin
560 tp3_xy <= {tp_x,tp_y};
561 st_done <= 1'b1;
562 tp_num_t <= tp_num_t + 1'b1;
563 end
564 'd3: begin
565 tp4_xy <= {tp_x,tp_y};
566 st_done <= 1'b1;
567 tp_num_t <= tp_num_t + 1'b1;
568 end
569 'd4: begin
570 tp5_xy <= {tp_x,tp_y};
571 st_done <= 1'b1;
572 tp_num_t <= tp_num_t + 1'b1;
573 end
574 default : ;
575 endcase
576 end
577 default : ;
578 endcase
579 end
580 end
581
582 endmodule
第三段状态机就比较长了，不过没关系我们一个状态一个状态的分析。首先是初始化状态，此状态执行了一个case语句，它包含了flow_cnt等于0、1、2三个小状态，当flow_cnt等于0的时候int_dir（触摸芯片tft_int中断信号的方向判定）和int_out（触摸芯片中断信号的值）拉高，接着进入flow_cnt等于1状态进行延迟（延迟主要通过上文提到的计数器来完成），然后对应输出tft_tcs（触摸芯片的复位信号）的值，之后进入flow_cnt等于2状态再次改变int_dir的值（改变触摸芯片tft_int中断信号的方向），同时清空flow_cnt的值（flow_cnt这个寄存器是重复使用的，每个状态逻辑执行完后要对它清零）并拉高st_done信号（让三段状态机的第二段进入下一个状态），至于为什么要延迟并给中断信号和复位信号进行不同的赋值主要是根据芯片手册的时序来的，具体上电时序可以查看芯片数据手册。
初始化状态结束后是寄存器配置状态（cfg_state），进入这个状态同样是执行一个case语句，然后判断外接屏幕是7寸的还是10寸的（因为4.3寸屏幕会跳过这个状态，所以这里只判断是7寸还是10寸），不同尺寸的屏幕配置的寄存器地址与对应写入的值是不相同的。这里尤其要注意flow_cnt等于4的时候如果是10寸屏就会激活cfg_switch控制信号，它一旦被激活就会传递到另外一个信号切换子模块（signal_switch）然后再传递到寄存器配置子模块（i2c_reg_cfg），之后会激活整个寄存器组重新配置，总共会配置188个寄存器，其他尺寸的屏幕其实都没有真正意义上的重新配置寄存器，仅仅只是配置了控制寄存器，并读取存放触摸数据的寄存器的值，只有10寸屏是真正意义上的配置完整寄存器组。如果你想对其他尺寸的屏幕进行整个寄存器组的重配置这里也可以修改一下，比如识别到其他尺寸屏幕ID时也可以仿照10寸屏的写法激活cfg_switch信号，在寄存器配置子模块（i2c_reg_cfg）中我们是存放了三种尺寸屏幕的完整寄存器组的，只要修改了这里的状态机就可以激活所有屏幕的完整寄存器配置（这里提醒读者慎重修改，防止寄存器组配置错误导致屏幕无法正常工作）。
接下来进入触摸检测状态（chk_touch），同样的要检测外接LCD屏的ID，判断是什么尺寸的，不同尺寸的屏幕对应检测的时序不同，主要体现在延迟时间的长短上，然后根据不同尺寸的ID，访问触摸芯片的触摸控制寄存器（GTCH_REG），根据触摸芯片给出的反馈（ack）和应答（i2c_data_r读出的数据）判断触摸是否有效（touch_valid），最大触摸点数是多少（tp_num）。之后进入触摸数据存放寄存器地址改变状态，根据上一状态得到的最大触摸点数改变相应的地址。有了地址之后就可以进入读取触摸数据坐标状态（getpos_xy），在这一状态主要就是通过IIC协议把对应地址里的数据读取出来就行。再之后进入数据处理状态（id_handle），在此状态中根据不同屏幕的尺寸把对应数值做一下处理，主要就是作数据拼接（7寸屏的数据读取出来需要拼接）或者改变x轴y轴的方向（例如ID为4384的屏幕分辨率为800*480，它的x轴坐标本身是从左往右坐标递增，现在假如将第538行代码改写成“tp_x <=799-tp_x;”那么x轴坐标就变成从左往右递减了）。数据处理完后就会进入最后一个状态数据输出状态（tp_xy），在这个状态坐标会被输出，并且每输出一个坐标tp_num_t（已读出的数据个数）计数器就会加一，用来配合触摸数据存放寄存器地址改变状态（change_addr）使用。
到这里整个触摸控制子模块就给大家讲解完了，下面我们继续分析另一个寄存器配置子模块（touch_gt_cfg），其代码如下：
1 module touch_gt_cfg #(parameter WIDTH = 4'd8)
2 (
3 //system clock
4 input clk , // 时钟信号
5 input rst_n , // 复位信号
6
7 //port interface
8 output scl , // 时钟线scl
9 input sda_in , // 数据线sda
10 output sda_out ,
11 output sda_dir ,
12
13 //I2C interface
14 input bit_ctrl ,
15 input i2c_exec , // i2c触发控制
16 input i2c_rh_wl , // i2c读写控制
17 input [15:0] i2c_addr , // i2c操作地址
18 input [ 7:0] i2c_data_w, // i2c写入的数据
19 input [WIDTH-1'b1:0] reg_num ,
20 input cfg_switch,
21 output [ 7:0] i2c_data_r, // i2c读出的数据
22 output i2c_done , // i2c操作结束标志
23 output once_done , // 一次读写操作完成
24 output clk_i2c , // I2C操作时钟
25 output ack ,
26 //user interface
27 output cfg_done , // 寄存器配置完成标志
28 input [15:0] lcd_id
29 );
30
31 //parameter define
32 //localparam SLAVE_ADDR = 7'h5d ; // 器件地址(SLAVE_ADDR)
33 //localparam BIT_CTRL = 1'b1 ; // 字地址位控制参数(16b/8b)
34 localparam CLK_FREQ = 27'd100_000_000; // i2c_dri模块的驱动时钟频率(CLK_FREQ)
35 localparam I2C_FREQ = 19'd400_000 ; // I2C的SCL时钟频率
36
37 //wire define
38 wire cfg_i2c_exec ; // i2c触发控制
39 wire cfg_i2c_rh_wl ; // i2c读写控制
40 wire [15:0] cfg_i2c_addr ; // i2c操作地址
41 wire [ 7:0] cfg_i2c_data ; // i2c写入的数据
42 wire cfg_once_done ; // i2c操作结束标志
43 wire [WIDTH-1'b1:0] cfg_reg_num ; // i2c读出的数据
44 wire m_i2c_exec ;
45 wire m_i2c_rh_wl ;
46 wire [15:0] m_i2c_addr ;
47 wire [ 7:0] m_i2c_data_w ;
48 wire [ 7:0] m_i2c_data_r ;
49 wire [WIDTH-1'b1:0] m_reg_num ;
50 wire m_once_done ;
51 reg [6:0] slave_addr ;
52
53 //*****************************************************
54 //** main code
55 //*****************************************************
56
57 always @(*) begin
58 if(lcd_id[15:8] == 8'h70 || lcd_id[15:8]== 8'h19)
59 slave_addr = 7'h38;
60 else
61 slave_addr = 7'h14;
62 end
63
64 //信号转换
65 signal_switch #(.WIDTH(WIDTH)
66 ) u1_signal_switch(
67 //module1
68 .m1_0 (i2c_exec ),
69 .m1_1 (i2c_rh_wl ),
70 .m1_2 (i2c_addr ),
71 .m1_3 (i2c_data_w ),
72 .m1_4 (i2c_data_r ),
73 .m1_5 (reg_num ),
74 .m1_6 (once_done ),
75 //module2
76 .m2_0 (cfg_i2c_exec ),
77 .m2_1 (cfg_i2c_rh_wl ),
78 .m2_2 (cfg_i2c_addr ),
79 .m2_3 (cfg_i2c_data ),
80 .m2_4 ( ),
81 .m2_5 (cfg_reg_num ),
82 .m2_6 (cfg_once_done ),
83 //module3
84 .m3_0 (m_i2c_exec ), // i2c触发控制
85 .m3_1 (m_i2c_rh_wl ), // i2c读写控制
86 .m3_2 (m_i2c_addr ), // i2c寄存器地址
87 .m3_3 (m_i2c_data_w ), // i2c写入的数据
88 .m3_4 (m_i2c_data_r ), // i2c读出的数据
89 .m3_5 (m_reg_num ), // 一次读写寄存器的个数
90 .m3_6 (m_once_done ), // 一次读写操作完成
91 //ctrl signal
92 .ctrl_switch (cfg_switch ) // 切换信号
93 );
94
95 //例化i2c_dri_m
96 i2c_dri_m #(
97 // .SLAVE_ADDR (SLAVE_ADDR), // slave address从机地址，放此处方便参数传递
98 .CLK_FREQ (CLK_FREQ ), // i2c_dri模块的驱动时钟频率(CLK_FREQ)
99 .I2C_FREQ (I2C_FREQ ), // I2C的SCL时钟频率
100 .WIDTH (WIDTH )
101 ) u_i2c_dri(
102 //global clock
103 .clk (clk ), // i2c_dri模块的驱动时钟(CLK_FREQ)
104 .rst_n (rst_n ), // 复位信号
105 //i2c interface
106 .slave_addr (slave_addr ),
107 .i2c_exec (m_i2c_exec ), // I2C触发执行信号
108 .bit_ctrl (bit_ctrl ), // 器件地址位控制(16b/8b)
109 .i2c_rh_wl (m_i2c_rh_wl ), // I2C读写控制信号
110 .i2c_addr (m_i2c_addr ), // I2C寄存器地址
111 .i2c_data_w (m_i2c_data_w), // I2C要写的数据
112 .i2c_data_r (m_i2c_data_r), // I2C读出的数据
113 .i2c_done (i2c_done ), // I2C操作完成
114 .once_done (m_once_done ), // 一次读写操作完成
115 .scl (scl ), // I2C的SCL时钟信号
116 .sda_in (sda_in ), // I2C的SDA信号
117 .sda_out (sda_out ),
118 .sda_dir (sda_dir ),
119 .ack (ack ),
120 //user interface
121 .reg_num (m_reg_num ), // 一次读写寄存器的个数
122 .dri_clk (clk_i2c ), // I2C操作时钟
123 .lcd_id (lcd_id )
124 );
125
126 //例化i2c_reg_cfg模块
127 i2c_reg_cfg u_i2c_reg_cfg(
128 //clock & reset
129 .clk (clk_i2c ), // i2c_reg_cfg驱动时钟(一般取1MHz)
130 .rst_n (rst_n ), // 复位信号
131 //i2c interface
132 .i2c_exec (cfg_i2c_exec ), // I2C触发执行信号
133 .i2c_rh_wl (cfg_i2c_rh_wl), // I2C读写控制信号
134 .i2c_addr (cfg_i2c_addr ), // 寄存器地址
135 .i2c_data (cfg_i2c_data ), // 寄存器数据
136 .once_done (cfg_once_done), // 一次读写操作完成
137 .cfg_done (cfg_done ), // 配置完成
138 //user interface
139 .reg_num (cfg_reg_num ), // 一次读写寄存器的个数
140 .cfg_switch (cfg_switch ), // 切换信号
141 .lcd_id (lcd_id )
142 );
143
144 endmodule
寄存器配置子模块（touch_gt_cfg）同样例化了三个子模块分别是信号切换模块（signal_switch）、IIC驱动模块（i2c_dri_m）和寄存器组控制模块（i2c_reg_cfg）。
要想理解整个寄存器配置子模块（touch_gt_cfg）是如何工作的就要先理清它所例化的三个子模块之间的关系。首先IIC驱动模块（i2c_dri_m）的功能很好理解，它就是执行IIC协议通信，给出触发信号（i2c_exec）、读写切换信号（i2c_rh_wl）、读写地址（i2c_addr）、写数据（i2c_data_w）它就能和从器件进行数据交互。关键就在这里，这四个控制线由谁发出呢？在上文已经说过了touch_ctrl模块的状态机会执行配置触摸芯片控制寄存器，会访问触摸芯片的触摸检测寄存器和触摸数据存放寄存器，它也是通过IIC协议去进行数据交互的那么它也就必然也会给出相应的i2c_exec、i2c_rh_wl、i2c_addr和i2c_data_w信号。同样的在上文touch_ctrl模块中我也说了对于10寸屏是需要配置整个寄存器组的，而寄存器组是存放在寄存器组控制模块（i2c_reg_cfg）中的，那么i2c_reg_cfg模块必然也要给出i2c_exec、i2c_rh_wl、i2c_addr和i2c_data_w信号，这就会造成冲突。因此我们引入了信号切换模块（signal_switch），寄存器组控制模块（i2c_reg_cfg）和touch_ctrl模块给出的IIC驱动信号都先接入信号切换模块（signal_switch），然后信号切换模块（signal_switch）会判断cfg_switch信号是否被激活，如果激活说明需要对触摸芯片的整个寄存器组进行重配置，那么寄存器组控制模块（i2c_reg_cfg）给出的IIC驱动信号有效，反之touch_ctrl模块给出的IIC驱动信号有效，这样就完美的解决了IIC驱动信号冲突的问题。
当我们了解了信号切换模块（signal_switch）、IIC驱动模块（i2c_dri_m）和寄存器组控制模块（i2c_reg_cfg）三者之间的关系我们再来分析它的代码，先看信号切换模块（signal_switch）的代码：
1 module signal_switch #(parameter WIDTH = 4'd8 // 一次读写寄存器的个数的位宽
2 )(
3 //module1
4 input m1_0,
5 input m1_1,
6 input [15:0] m1_2,
7 input [ 7:0] m1_3,
8 output reg [ 7:0] m1_4,
9 input [WIDTH-1'b1:0] m1_5,
10 output reg m1_6,
11
12 //module2
13 input m2_0,
14 input m2_1,
15 input [15:0] m2_2,
16 input [ 7:0] m2_3,
17 output reg [ 7:0] m2_4,
18 input [WIDTH-1'b1:0] m2_5,
19 output reg m2_6,
20
21 //module2
22 output reg m3_0,
23 output reg m3_1,
24 output reg [15:0] m3_2,
25 output reg [ 7:0] m3_3,
26 input [ 7:0] m3_4,
27 output reg [WIDTH-1'b1:0] m3_5,
28 input m3_6,
29
30 //ctrl signal
31 input ctrl_switch // 切换信号
32
33 );
34
35 //*****************************************************
36 //** main code
37 //*****************************************************
38
39 //信号转换
40 always @(*) begin
41 if(ctrl_switch) begin
42 m3_0 = m2_0;
43 m3_1 = m2_1;
44 m3_2 = m2_2;
45 m3_3 = m2_3;
46 m2_4 = m3_4;
47 m3_5 = m2_5;
48 m2_6 = m3_6;
49 end
50 else begin
51 m3_0 = m1_0;
52 m3_1 = m1_1;
53 m3_2 = m1_2;
54 m3_3 = m1_3;
55 m1_4 = m3_4;
56 m3_5 = m1_5;
57 m1_6 = m3_6;
58 end
59 end
60
61 endmodule
信号切换模块（signal_switch）的代码比较简单就不讲解了，下面我们直接来看寄存器组控制模块（i2c_reg_cfg）的代码：
1 module i2c_reg_cfg #(parameter WIDTH = 4'd8
2 )(
3 input clk , // i2c_reg_cfg驱动时钟(一般取1MHz)
4 input rst_n , // 复位信号
5 input once_done , // I2C一次操作完成反馈信号
6
7 output reg i2c_exec , // I2C触发执行信号
8 output reg i2c_rh_wl , // I2C读写控制信号
9 output reg [15:0] i2c_addr , // 寄存器地址
10 output reg [ 7:0] i2c_data , // 寄存器数据
11 output reg cfg_done , // ES8388配置完成
12
13 //user interface
14 input cfg_switch, // 配置切换
15 input [15:0] lcd_id,
16 output reg [WIDTH-1'b1:0] reg_num
17 );
18
19 //parameter define
20 localparam MODE = 8'h1 ; // 0X8100用于控制是否将配置保存在本地，写 0，则不保存配置，写 1 则保存配置。
21 //localparam REG_NUM_4 = 8'd186; // 总共需要配置的寄存器个数
22 //GT9147 部分寄存器定义
23 localparam GT_CTRL_REG = 16'h8040; // GT系列控制寄存器
24 localparam GT_CFGS_REG = 16'h8047; // GT系列配置起始地址寄存器
25 localparam GT_CHECK_REG = 16'h80FF; // GT系列校验和寄存器
26
27 //reg define
28 reg [2:0] start_init_cnt; // 初始化时间计数
29 reg [7:0] init_reg_cnt ; // 寄存器配置个数计数器
30 reg [7:0] sum_t1; // 计算校验和
31 reg [7:0] REG_NUM; // 总共需要配置的寄存器个数
32
33 //wire define
34 wire rd_en ;
35 wire [7:0] sum_t2; // 计算校验和
36 reg [9:0] address;
37 wire [7:0] q;
38
39 //*****************************************************
40 //** main code
41 //*****************************************************
42
43 //计算校验和
44 assign sum_t2 = init_reg_cnt == REG_NUM - 'd3 ? (~sum_t1 + 1'd1) : sum_t2;
45 assign rd_en = init_reg_cnt <= REG_NUM - 'd3 ? 1'b1: 1'b0;
46
47 always @(*) begin
48 if(lcd_id ==16'h4342)
49 address =init_reg_cnt;
50 else if(lcd_id ==16'h1018)
51 address =init_reg_cnt+ 8'd184;
52 else if(lcd_id == 16'h4384)
53 address =init_reg_cnt+ 9'd370;
54 end
55
56 always @(*) begin
57 if(lcd_id[15:12] == 4'h1) // 10.1'
58 REG_NUM = 8'd188;
59 else
60 REG_NUM = 8'd186; // 4.3'
61 end
62
63 //I2C开始操作控制
64 always @(posedge clk or negedge rst_n) begin
65 if(!rst_n) begin
66 start_init_cnt <= 3'b0;
67 end
68 else if(cfg_switch) begin
69 if(start_init_cnt < 3'h2)
70 start_init_cnt <= start_init_cnt + 1'b1;
71 end
72 end
73
74 // 触发I2C操作控制
75 always @(posedge clk or negedge rst_n) begin
76 if(!rst_n)
77 i2c_exec <= 1'b0;
78 else if(cfg_switch) begin
79 if(start_init_cnt == 9'h1)
80 i2c_exec <= 1'b1;
81 else
82 i2c_exec <= 1'b0;
83 end
84 end
85
86 //配置寄存器个数计数
87 always @(posedge clk or negedge rst_n) begin
88 if(!rst_n) begin
89 init_reg_cnt <= 8'd0;
90 end
91 else if(cfg_switch & once_done)
92 init_reg_cnt <= init_reg_cnt + 1'b1;
93 end
94
95 //寄存器配置完成信号
96 always @(posedge clk or negedge rst_n) begin
97 if(!rst_n)
98 cfg_done <= 1'b0;
99 else if(init_reg_cnt == REG_NUM)
100 cfg_done <= 1'b1;
101 end
102
103 //计算校验和
104 always @(posedge clk) begin
105 if(once_done & (init_reg_cnt <= REG_NUM - 'd3))
106 sum_t1 = sum_t1 + i2c_data;
107 else
108 sum_t1 = sum_t1;
109 end
110
111 always @(posedge clk) begin
112 if(cfg_switch) begin
113 i2c_rh_wl<= 1'b0;
114 i2c_addr <= GT_CFGS_REG;
115 reg_num <= REG_NUM;
116 if(lcd_id[15:12] == 4'h1) begin // 16'h1018 10.1'
117 case(init_reg_cnt)
118 8'd186: i2c_data <= sum_t2;
119 8'd187: i2c_data <= MODE ;
120 default: i2c_data <= q;
121 endcase
122 end
123 else begin
124 case(init_reg_cnt)
125 8'd184: i2c_data <= sum_t2;
126 8'd185: i2c_data <= MODE ;
127 default: i2c_data <= q;
128 endcase
129 end
130 end
131 end
132
133 gt_cfg gt_cfg_inst (
134 .address ( address ),
135 .clock ( clk ),
136 .rden ( rd_en ),
137 .q ( q )
138 );
139
140 endmodule
这个模块的代码其实也很简单，就是当cfg_switch信号激活后生成对应的IIC控制信号，需要注意的是整个寄存器组不是直接存放在代码中而是放在了ROM中。代码的第133~138行例化了一个ROM IP核，这个ROM会加载一个coe文件（gt_cfg1.coe文件放在工程目录下的doc文件夹中），coe文件包含了三种尺寸屏幕的寄存器组数值。因此代码的第4754行就根据LCD屏的不同ID选择ROM读取数据地址的起始位置，不同的起始位置对应不同屏幕的寄存器组。代码第5661行是根据屏幕ID选择具体配置寄存器的个数。代码第103~131行是计算校验和，这个仅仅是10寸屏需要执行校验，其他两种屏幕不需要。
最后我们再来看看IIC驱动模块的代码，因为IIC驱动模块在前面的例程中已经讲解过了，这里就不再详细讲解了，主要就是看一下修改的地方，本节实验的IIC驱动模块新增了连续读写的功能，代码如下(因为代码比较长，这里只给出局部代码，如果对整个IIC协议不了解的请参考前面eeprom例程)：
66 assign reg_done = reg_cnt == reg_num ? 1'b1 : 1'b0;
67
68 //生成I2C的SCL的四倍频率的驱动时钟用于驱动i2c的操作
69 always @(posedge clk or negedge rst_n) begin
70 if(rst_n == 1'b0) begin
71 dri_clk <= 1'b1;
72 clk_cnt <= 10'd0;
73 end
74 else if(clk_cnt == clk_divide - 1'd1) begin
75 clk_cnt <= 10'd0;
76 dri_clk <= ~dri_clk;
77 end
78 else
79 clk_cnt <= clk_cnt + 1'b1;
80 end
81
82 //寄存器个数计数
83 always @(posedge dri_clk or negedge rst_n) begin
84 if(!rst_n)
85 reg_cnt <= 'd0;
86 else if(once_done)
87 reg_cnt <= reg_cnt + 1'd1;
88 else if(i2c_done)
89 reg_cnt <= 'd0;
90 end
91
92 //(三段式状态机)同步时序描述状态转移
93 always @(posedge dri_clk or negedge rst_n) begin
94 if(rst_n == 1'b0)
95 cur_state <= st_idle;
96 else
97 cur_state <= next_state;
98 end
99
100 //组合逻辑判断状态转移条件
101 always @( * ) begin
102 // 状态跳转
103 case(cur_state)
104 st_idle: begin // 空闲状态
105 if(i2c_exec) begin
106 next_state = st_sladdr;
107 end
108 else
109 next_state = st_idle;
110 end
111 st_sladdr: begin
112 if(st_done) begin
113 if(!ack) begin
114 if(bit_ctrl) // 判断是16位还是8位字地址
115 next_state = st_addr16;
116 else
117 next_state = st_addr8 ;
118 end
119 else
120 next_state = st_stop;
121 end
122 else
123 next_state = st_sladdr;
124 end
125 st_addr16: begin // 写16位字地址
126 if(st_done) begin
127 if(!ack)
128 next_state = st_addr8;
129 else
130 next_state = st_stop;
131 end
132 else
133 next_state = st_addr16;
134 end
135 st_addr8: begin // 8位字地址
136 if(st_done) begin
137 if(!ack) begin
138 if(wr_flag==1'b0) // 读写判断
139 next_state = st_data_wr;
140 else
141 next_state = st_addr_rd;
142 end
143 else
144 next_state = st_stop;
145 end
146 else
147 next_state = st_addr8;
148 end
149 st_data_wr: begin // 写数据(8 bit)
150 if(st_done) begin
151 if(reg_done)
152 next_state = st_stop;
153 else
154 next_state = st_data_wr;
155 end
156 else
157 next_state = st_data_wr;
158 end
159 st_addr_rd: begin // 写地址以进行读数据
160 if(st_done) begin
161 if(!ack)
162 next_state = st_data_rd;
163 else
164 next_state = st_stop;
165 end
166 else
167 next_state = st_addr_rd;
168 end
169 st_data_rd: begin // 读取数据(8 bit)
170 if(st_done) begin
171 if(reg_done)
172 next_state = st_stop;
173 else
174 next_state = st_data_rd;
175 end
176 else
177 next_state = st_data_rd;
178 end
179 st_stop: begin // 结束I2C操作
180 if(st_done)
181 next_state = st_idle;
182 else
183 next_state = st_stop ;
184 end
185 default: next_state= st_idle;
186 endcase
187 end
代码的第66行定义了reg_done信号，它就是连续写完成的标志，当“reg_cnt == reg_num”的时候reg_done才会拉高。reg_num是需要配置寄存器的个数由touch_ctrl模块或者i2c_reg_cfg模块提供，代码第8290行是寄存器个数计数器，每完成一个寄存器写入reg_cnt就会加一，直到i2c_done信号拉高为止。i2c_done信号是当IIC状态机进入最后一个状态（st_stop）时才会拉高，因此当i2c_done拉高代表连续读写多个寄存器完成。代码第100187行是状态机第二段（IIC通信三段状态机的第二段），我们可以看到代码第149158行以及代码第169178行分别是IIC通信的写数据和读数据状态，这两个状态都判断了reg_done信号是否拉高，如果reg_done信号未拉高代表连续读写寄存器还没完成，那么读写状态循环执行，直到把所有寄存器全部写完或者读完，reg_done信号才会拉低，状态机进入st_stop状态，然后拉高i2c_done信号，告诉其它模块一次连续读写完成。
到这里整个触摸部分就全部给大家分析完了，接下来再带领大家一起看一下LCD显示部分代码，LCD显示部分代码在前面的例程中也都讲解过了，本节实验仅仅分析一下字模显示模块的代码，至于LCD驱动部分的代码如果大家有不熟悉的可以参考前面LCD彩条显示实验。
字模显示模块（lcd_display）代码如下（因为本模块的字模比较长，直接粘贴代码不好看，所以这里以截图的方式一段一段给大家讲解）：
图 34.4.2字模显示模块（lcd_display）代码
上图展示的是数字0~9和字母“X”、字母“Y”的字模，它是使用“PCtoLCD2002完美版”（软件存放路径：[正点原子]新起点FPGA开发板光盘资料\新起点FPGA开发板资料盘(A盘)\6_软件资料\1_软件）软件生成的，生成步骤如下图所示：
图 34.4.3字模生成步骤
首先在资料盘A盘找到“PCtoLCD2002完美版”软件并打开，然后按照上图步骤操作。第一步点击“选项”按钮打开字模属性设置，然后按照上图序号2、3、4、5、6、7、8步骤设置字模参数并点击确定，之后在上图序号9的位置输入我们想要生成的字符（本节实验输入0123456789XY），再到序号10的位置设置字符的宽度和高度（本节实验选择3232，但是在实际显示英文字符的时候宽度会减半也就是1632），最后点击“生成字模”按钮，在上图序号11的位置就生成了我们需要的字模数据组，拷贝到代码中即可使用。
接下来我们再来看看怎么把touch_ctrl模块读取到的坐标显示到LCD屏幕上去，首先我们要把坐标点数据接入字模显示模块（lcd_display），然后将X轴Y轴数据转换成能显示的个位、十位、百位、千位（只有X轴坐标会到达千位，因为最大分辨率是1280*800），与上文的字模数组对应起来，代码如下：
36 assign data6 = data[31:16] / 10'd1000 % 4'd10 ; // X轴坐标千位数
37 assign data5 = data[31:16] / 7'd100 % 4'd10 ; // X轴坐标百位数
38 assign data4 = data[31:16] / 4'd10 % 4'd10 ; // X轴坐标十位数
39 assign data3 = data[31:16] % 4'd10 ; // X轴坐标个位数
40 assign data2 = data[15:0] / 7'd100 % 4'd10 ; // Y轴坐标百位数
41 assign data1 = data[15:0] / 4'd10 % 4'd10 ; // Y轴坐标十位数
42 assign data0 = data[15:0] % 4'd10 ; // Y轴坐标个位数
这里的data就是touch_ctrl模块读到的数据点坐标，data的高16位是X轴坐标，低16位是Y轴坐标，将坐标数据拆分成个位、十位、百位、千位后分别存到寄存器data0~ data6中，最后就是将实际坐标数据与字模数组联系起来，代码如下：
图 34.4.4显示区域赋值
上图中的代码就是将具体要显示的坐标数据和字模数组结合到一起，达到显示坐标数据的功能（上图只截了一部分，完整版请参考例程源代码），那么它的原理是什么呢？我们来分析一下代码，首先代码的第101~107行是显示第一个字符，也就是X轴坐标的最高位，其中代码第101和102行是用来确定第一个字符显示的位置，pixel_xpos与pixel_ypos是LCD屏幕行列扫描信号，CHAR_POS_X与CHAR_POS_Y是显示区域的起始坐标，CHAR_WIDTH和CHAR_HEIGHT是整个显示区域的总宽度和高度（X轴最大显示四位数，Y轴最大显示三位数，再加上“X”和“Y”两个字母，整个显示区域需要显示九个英文字符所以总宽度为169等于144个像素点宽度），第一个字符的显示位置就是从起始点开始算起，X轴方向大于起始点小于起始点加16，Y轴方向就是大于起始点，小于起始点加32；依次类推第二个字符的位置就是X轴方向大于起始点加16小于起始点加32，Y轴方向还是大于起始点，小于起始点加32。这样就将九个字符的位置确定下来了，那么每个位置具体显示什么数字呢？看代码第103行，我们要显示第一个数字也就是X轴坐标的最高位，它被存放在寄存器data6中，把它带入字模数组即char [data6]， data6的值是几就定位到字模对应的数字为几，例如data6的值为“1”就定位到数组char [1]，对应的数字就是“1”的字模。找到这个字模后就要把它显示到LCD屏幕上去，还拿data6的值为“1”举例，“1”的字模其实就是1632等于512个像素点，每个像素点都有自己的值，要么“1”，要么“0”。我们需要做的就是把第一个字符显示区域的512个像素点代入字模的512个像素点中去，如果字模的像素点值为“1”那么对应的字符显示区域像素点赋值颜色数值为黑色，反之给白色数值。举个例子现在要显示第一个字符的第一个像素点，对应LCD屏幕上的像素点就是起始点，对应字模数组的值就是char [data6] [511]，同理第二个像素点数据对应的就是char [data6] [510]，依次类推最后一个像素点数据就是char [data6] [0]。因此代码第103行执行的功能就是把pixel_xpos与pixel_ypos对应的LCD实际显示像素点转换成对应的字模数组char中的元素，顺便提一句Y轴的值每增减1则像素点增减16，所以代码中要“*16”。
清楚了第一个字符的显示原理后，其他字符的显示原理是一模一样的就不再赘述了，到此整个LCD触摸实验代码就分析完了，接下来就可以生成bit流文件下板验证了。
34.5下载验证
首先将下载器与新起点开发板上的JTAG接口连接，下载器另外一端与电脑连接，然后将LCD屏连接到开发板上，最后连接电源线并打开电源开关。
然后将本次实验生成的sof文件下载到开发板中，此时可以看到LCD屏幕点亮并显示“0000X000Y”，我们用手触摸LCD屏，触摸点的数据就会显示出来了。
实验结果如下图所示：
图 34.5.1 触摸显示