【花雕学编程】Arduino动手做（249）--GC9A01屏38个特色案例

37款传感器与模块的提法，在网络上广泛流传，其实Arduino能够兼容的传感器模块肯定是不止37种的。鉴于本人手头积累了一些传感器和执行器模块，依照实践出真知（一定要动手做）的理念，以学习和交流为目的，这里准备逐一动手试试多做实验，不管成功与否，都会记录下来——小小的进步或是搞不掂的问题，希望能够抛砖引玉。

【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动

  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之二十：基于Adafruit_GFX库测试ESP32与GC9A01显示屏的功能

实验开源代码

/*
  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之二十：基于Adafruit_GFX库测试ESP32与GC9A01显示屏的功能
*/

//       GC9A010 -------- ESP32
//       RST ------------ NC（复位引脚，此处未连接）
//       CS ------------- D4（片选引脚，连接到ESP32的D4引脚）
//       DC ------------- D2（数据/命令选择引脚，连接到ESP32的D2引脚）
//       SDA ------------ D23 (green)（主数据输出引脚，连接到ESP32的D23引脚，绿色线）
//       SCL ------------ D18 (yellow)（时钟信号引脚，连接到ESP32的D18引脚，黄色线）
//       GND ------------ GND（接地引脚，连接到ESP32的接地端）
//       VCC -------------3V3（电源引脚，连接到ESP32的3.3V电源）

#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"

#define TFT_DC 2
#define TFT_CS 4

Adafruit_GC9A01A tft(TFT_CS, TFT_DC);

void setup() {

  Serial.begin (9600);
  Serial.println (" ");
  Serial.println ("GC9A01A Test!");

  tft.begin();

  Serial.println (F("Benchmark                Time (microseconds)"));
  delay (10);
  Serial.print(F ("Screen fill              "));
  Serial.println (testFillScreen ());
  delay (500);

  Serial.print (F("Text                     "));
  Serial.println (testText());
  delay (3000);

  Serial.print (F("Lines                    "));
  Serial.println (testLines (GC9A01A_CYAN));
  delay (500);

  Serial.print (F("Horiz/Vert Lines         "));
  Serial.println (testFastLines (GC9A01A_RED, GC9A01A_BLUE));
  delay (500);

  Serial.print (F("Rectangles (outline)     "));
  Serial.println (testRects (GC9A01A_GREEN));
  delay (500);

  Serial.print (F("Rectangles (filled)      "));
  Serial.println (testFilledRects (GC9A01A_YELLOW, GC9A01A_MAGENTA));
  delay (500);

  Serial.print (F("Circles (filled)         "));
  Serial.println (testFilledCircles (10, GC9A01A_MAGENTA));

  Serial.print (F("Circles (outline)        "));

  delay (500);

  Serial.print (F("Triangles (outline)      "));
  Serial.println (testTriangles ());
  delay (500);

  Serial.print (F("Triangles (filled)       "));
  Serial.println (testFilledTriangles ());
  delay (500);

  Serial.print (F("Rounded rects (outline)  "));
  Serial.println (testRoundRects ());
  delay (500);

  Serial.print (F("Rounded rects (filled)   "));
  Serial.println (testFilledRoundRects ());
  delay (500);

  Serial.println (F("Done!"));
}

void loop(void) {

  for (uint8_t rotation = 0; rotation < 4; rotation++)
  {
    tft.setRotation (rotation);
    testText ();
    delay (1000);
  }
}

unsigned long testFillScreen() {

  unsigned long start = micros();
  tft.fillScreen (GC9A01A_BLACK);
  yield ();
  tft.fillScreen (GC9A01A_RED);
  yield ();
  tft.fillScreen (GC9A01A_GREEN);
  yield ();
  tft.fillScreen (GC9A01A_BLUE);
  yield ();
  tft.fillScreen (GC9A01A_BLACK);
  yield ();
  return micros () - start;
}

unsigned long testText () {

  tft.fillScreen (GC9A01A_BLACK);
  unsigned long start = micros ();
  tft.setCursor (10, 40);
  tft.setTextColor (GC9A01A_WHITE);  tft.setTextSize(1);
  tft.println ("     Hello World!");
  tft.setTextColor (GC9A01A_YELLOW); tft.setTextSize(2);
  tft.println ("   1234.56");
  tft.setTextColor (GC9A01A_RED);    tft.setTextSize(3);
  tft.println (0xDEADBEEF, HEX);
  tft.println ();
  tft.setTextColor (GC9A01A_GREEN);
  tft.setTextSize (5);
  tft.println ("Groop");
  tft.setTextSize (2);
  tft.println ("I implore thee,");
  tft.setTextSize (1);
  tft.println ("my foonting turlingdromes.");
  tft.println ("And hooptiously drangle me");
  tft.println ("with crinkly bindlewurdles,");
  tft.println ("Or I will rend thee");
  tft.println ("in the gobberwarts");
  tft.println ("with my blurglecruncheon,");
  tft.println ("see if I don't!");
  return micros () - start;
  delay (1000);
}

unsigned long testLines (uint16_t color) {

  unsigned long start, t;
  int           x1, y1, x2, y2,
                w = tft.width (),
                h = tft.height ();

  tft.fillScreen (GC9A01A_BLACK);
  yield ();

  x1    = y1 = 0;
  y2    = h - 1;
  start = micros ();
  for (x2 = 0; x2 < w; x2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  x2    = w - 1;
  for (y2 = 0; y2 < h; y2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  t     = micros () - start;                                                  
  // fillScreen doesn't count against timing
  yield ();
  tft.fillScreen (GC9A01A_BLACK);
  yield ();

  x1    = w - 1;
  y1    = 0;
  y2    = h - 1;
  start = micros ();
  for (x2 = 0; x2 < w; x2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  x2    = 0;
  for (y2 = 0; y2 < h; y2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  t    += micros() - start;
  yield ();
  tft.fillScreen (GC9A01A_BLACK);
  yield ();

  x1    = 0;
  y1    = h - 1;
  y2    = 0;
  start = micros ();
  for (x2 = 0; x2 < w; x2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  x2    = w - 1;
  for (y2 = 0; y2 < h; y2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  t    += micros () - start;
  yield ();
  tft.fillScreen (GC9A01A_BLACK);
  yield ();

  x1    = w - 1;
  y1    = h - 1;
  y2    = 0;
  start = micros ();
  for (x2 = 0; x2 < w; x2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  x2    = 0;
  for (y2 = 0; y2 < h; y2 += 6) tft.drawLine (x1, y1, x2, y2, color);
  yield();
  return micros () - start;
}

unsigned long testFastLines(uint16_t color1, uint16_t color2) {

  unsigned long start;
  int           x, y, w = tft.width (), h = tft.height ();

  tft.fillScreen (GC9A01A_BLACK);
  start = micros ();
  for (y = 0; y < h; y += 5) tft.drawFastHLine ( 0, y, w, color1);
  for (x = 0; x < w; x += 5) tft.drawFastVLine (x, 0, h, color2);

  return micros () - start;
}

unsigned long testRects (uint16_t color) {

  unsigned long start;
  int           n, i, i2,
                cx = tft.width ()  / 2,
                cy = tft.height () / 2;

  tft.fillScreen (GC9A01A_BLACK);
  n     = min (tft.width (), tft.height ());
  start = micros ();
  for (i = 2; i < n; i += 6)
  {
    i2 = i / 2;
    tft.drawRect (cx - i2, cy - i2, i, i, color);
  }
  return micros () - start;
}

unsigned long testFilledRects (uint16_t color1, uint16_t color2) {

  unsigned long start, t = 0;
  int           n, i, i2,
                cx = tft.width ()  / 2 - 1,
                cy = tft.height () / 2 - 1;

  tft.fillScreen (GC9A01A_BLACK);
  n = min (tft.width (), tft.height ());
  for (i = n; i > 0; i -= 6)
  {
    i2    = i / 2;
    start = micros ();
    tft.fillRect (cx - i2, cy - i2, i, i, color1);
    t    += micros () - start;
    // outlines are not included in timing results
    tft.drawRect (cx - i2, cy - i2, i, i, color2);
    yield ();
  }
  return t;
}

unsigned long testFilledCircles(uint8_t radius, uint16_t color) {

  unsigned long start;
  int x, y, w = tft.width (), h = tft.height (), r2 = radius * 2;

  tft.fillScreen (GC9A01A_BLACK);
  start = micros ();
  for (x = radius; x < w; x += r2)
  {
    for (y = radius; y < h; y += r2)
    {
      tft.fillCircle (x, y, radius, color);
    }
  }
  return micros () - start;
}

unsigned long testCircles (uint8_t radius, uint16_t color) {

  unsigned long start;
  int           x, y, r2 = radius * 2,
                      w = tft.width ()  + radius,   // screen is not cleared for this one -- this is
                      h = tft.height () + radius;   // intentional and does not affect the reported time.
  start = micros ();

  for (x = 0; x < w; x += r2)
  {
    for (y = 0; y < h; y += r2)
    {
      tft.drawCircle (x, y, radius, color);
    }
  }
  return micros () - start;
}

unsigned long testTriangles () {

  unsigned long start;
  int           n, i, cx = tft.width  () / 2 - 1,
                      cy = tft.height () / 2 - 1;

  tft.fillScreen (GC9A01A_BLACK);
  n     = min (cx, cy);
  start = micros ();
  for (i = 0; i < n; i += 5)
  {
    tft.drawTriangle (
      cx    , cy - i,                                                     // top of triangle
      cx - i, cy + i,                                                     // bottom left
      cx + i, cy + i,                                                     // bottom right
      tft.color565( i, i, i));
  }
  return micros () - start;
}

unsigned long testFilledTriangles () {

  unsigned long start, t = 0;
  int           i, cx = tft.width ()  / 2 - 1,
                   cy = tft.height () / 2 - 1;

  tft.fillScreen (GC9A01A_BLACK);
  start = micros ();
  for (i = min (cx, cy); i > 10; i -= 5)
  {
    start = micros ();
    tft.fillTriangle (cx, cy - i, cx - i, cy + i, cx + i, cy + i,
                      tft.color565 (0, i * 10, i * 10));
    t += micros () - start;
    tft.drawTriangle (cx, cy - i, cx - i, cy + i, cx + i, cy + i,
                      tft.color565 (i * 10, i * 10, 0));
    yield ();
  }
  return t;
}

unsigned long testRoundRects () {

  unsigned long start;
  int           w, i, i2,
                cx = tft.width  () / 2 - 1,
                cy = tft.height () / 2 - 1;

  tft.fillScreen (GC9A01A_BLACK);
  w     = min (tft.width (), tft.height ());
  start = micros ();
  for (i = 0; i < w; i += 6)
  {
    i2 = i / 2;
    tft.drawRoundRect (cx - i2, cy - i2, i, i, i / 8, tft.color565 (i, 0, 0));
  }
  return micros () - start;
}

unsigned long testFilledRoundRects () {

  unsigned long start;
  int           i, i2,
                cx = tft.width  () / 2 - 1,
                cy = tft.height () / 2 - 1;

  tft.fillScreen (GC9A01A_BLACK);
  start = micros ();
  for (i = min (tft.width (), tft.height ()); i > 20; i -= 6)
  {
    i2 = i / 2;
    tft.fillRoundRect (cx - i2, cy - i2, i, i, i / 8, tft.color565 (0, i, 0));
    yield ();
  }
  return micros () - start;
}
复制代码

  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之十七：实现文本正反旋转与随机中心文字

实验开源代码

/*
  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之十七：实现文本正反旋转与随机中心文字
*/

//       GC9A010 -------- ESP32
//       RST ------------ NC（复位引脚，此处未连接）
//       CS ------------- D4（片选引脚，连接到ESP32的D4引脚）
//       DC ------------- D2（数据/命令选择引脚，连接到ESP32的D2引脚）
//       SDA ------------ D23 (green)（主数据输出引脚，连接到ESP32的D23引脚，绿色线）
//       SCL ------------ D18 (yellow)（时钟信号引脚，连接到ESP32的D18引脚，黄色线）
//       GND ------------ GND（接地引脚，连接到ESP32的接地端）
//       VCC -------------3V3（电源引脚，连接到ESP32的3.3V电源）

#include "SPI.h"                   // 引入SPI库
#include "Adafruit_GFX.h"          // 引入Adafruit GFX库
#include "Adafruit_GC9A01A.h"      // 引入GC9A01A显示屏驱动库

#define TFT_DC 2                   // 定义TFT显示屏的DC引脚
#define TFT_CS 4                   // 定义TFT显示屏的CS引脚

Adafruit_GC9A01A tft(TFT_CS, TFT_DC); // 创建GC9A01A对象

#define DELAY_TIME 100             // 每次旋转延迟（毫秒）
#define SCREEN_CENTER_X 120        // 屏幕中心X坐标（240x240屏幕）
#define SCREEN_CENTER_Y 120        // 屏幕中心Y坐标（240x240屏幕）
#define RADIUS 80                  // 旋转半径
#define NUM_TURNS 1                // 每个方向的旋转圈数
#define OFFSET_LEFT 25             // 向左偏移量

void setup() {
    Serial.begin(9600);            // 初始化串口通信
    Serial.println("Rotating Letters and Centered Random 'OK'!");

    tft.begin();                   // 初始化显示屏
    tft.setRotation(2);            // 设置初始旋转方向
    tft.fillScreen(GC9A01A_BLACK); // 清屏
    randomSeed(analogRead(0));     // 初始化随机数种子
}

void rotateText(int direction) {
    // 根据旋转方向正转或反转
    for (int angle = 0; angle < NUM_TURNS * 360; angle += 10) {
        // 清屏
        tft.fillScreen(GC9A01A_BLACK);

        // 随机生成颜色
        uint16_t randomColor = random(0x0000, 0xFFFF); // RGB565随机颜色

        // 计算字母位置（向左偏移 OFFSET_LEFT）
        float radian = angle * direction * 3.14159 / 180; // 正转：方向为1，反转：方向为-1
        int x = SCREEN_CENTER_X + RADIUS * cos(radian) - OFFSET_LEFT; // “Hello”左偏移
        int y = SCREEN_CENTER_Y + RADIUS * sin(radian);

        // 设置旋转文字属性
        tft.setTextColor(randomColor);                 // 设置随机颜色
        tft.setTextSize(2);                            // 设置字体大小
        tft.setCursor(x, y);                           // 设置文本位置
        tft.print("Hello");                            // 显示字母

        // 显示中心文字“OK”
        int randomSize = random(1, 5);                 // 随机生成字体大小
        tft.setTextColor(GC9A01A_WHITE);               // 中心文字颜色为白色
        tft.setTextSize(randomSize);                   // 设置中心文字大小
        tft.setCursor(SCREEN_CENTER_X - (6 * randomSize), SCREEN_CENTER_Y - (8 * randomSize));
        tft.print("OK");                               // 屏幕正中心显示“OK”

        delay(DELAY_TIME);                             // 延迟控制动画速度
    }
}

void loop() {
    rotateText(1);  // 正转一圈
    rotateText(-1); // 反转一圈
}
复制代码

  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之五：多色彩动态循环同心园

  实验开源代码

/*
  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之五：多色彩动态循环同心园
*/

//       GC9A010 -------- ESP32
//       RST ------------ NC（复位引脚，此处未连接）
//       CS ------------- D4（片选引脚，连接到ESP32的D4引脚）
//       DC ------------- D2（数据/命令选择引脚，连接到ESP32的D2引脚）
//       SDA ------------ D23 (green)（主数据输出引脚，连接到ESP32的D23引脚，绿色线）
//       SCL ------------ D18 (yellow)（时钟信号引脚，连接到ESP32的D18引脚，黄色线）
//       GND ------------ GND（接地引脚，连接到ESP32的接地端）
//       VCC -------------3V3（电源引脚，连接到ESP32的3.3V电源）

#include "SPI.h"                   // 引入SPI库
#include "Adafruit_GFX.h"          // 引入Adafruit GFX库
#include "Adafruit_GC9A01A.h"      // 引入GC9A01A显示屏驱动库

#define TFT_DC 2                   // 定义TFT显示屏的DC引脚
#define TFT_CS 4                   // 定义TFT显示屏的CS引脚

Adafruit_GC9A01A tft(TFT_CS, TFT_DC); // 创建GC9A01A对象

void setup() {
    Serial.begin(9600);            // 初始化串口通信
    Serial.println("Multi-Circle Animation with Color Change!");

    tft.begin();                   // 初始化显示屏
    tft.setRotation(3);            // 设置显示屏方向
    tft.fillScreen(GC9A01A_BLACK); // 清屏
}

void loop() {
    int centerX = tft.width() / 2; // 屏幕中心X坐标
    int centerY = tft.height() / 2; // 屏幕中心Y坐标

    // 定义颜色数组用于动态颜色切换
    uint16_t colors[] = {GC9A01A_RED, GC9A01A_GREEN, GC9A01A_BLUE, GC9A01A_YELLOW, GC9A01A_CYAN, GC9A01A_MAGENTA, GC9A01A_WHITE};
    int colorCount = sizeof(colors) / sizeof(colors[0]);
    static int colorIndex = 0;      // 当前颜色索引

    static int radius1 = 10;        // 第一个圆的半径
    static int radius2 = 20;        // 第二个圆的半径
    static int radius3 = 30;        // 第三个圆的半径

    int step = 5;                   // 半径的变化步长
    static bool increasing1 = true; // 控制第一个圆半径增减
    static bool increasing2 = true; // 控制第二个圆半径增减
    static bool increasing3 = true; // 控制第三个圆半径增减

    // 清屏，绘制新一帧动画
    tft.fillScreen(GC9A01A_BLACK);

    // 绘制三个圆
    tft.drawCircle(centerX, centerY, radius1, colors[colorIndex]);                 // 圆1
    tft.drawCircle(centerX, centerY, radius2, colors[(colorIndex + 1) % colorCount]); // 圆2
    tft.drawCircle(centerX, centerY, radius3, colors[(colorIndex + 2) % colorCount]); // 圆3

    // 更新第一个圆半径
    if (increasing1) {
        radius1 += step;
        if (radius1 >= 115) {       // 达到最大半径后反向
            increasing1 = false;
        }
    } else {
        radius1 -= step;
        if (radius1 <= 10) {        // 达到最小半径后反向
            increasing1 = true;
        }
    }

    // 更新第二个圆半径
    if (increasing2) {
        radius2 += step;
        if (radius2 >= 115) {
            increasing2 = false;
        }
    } else {
        radius2 -= step;
        if (radius2 <= 10) {
            increasing2 = true;
        }
    }

    // 更新第三个圆半径
    if (increasing3) {
        radius3 += step;
        if (radius3 >= 115) {
            increasing3 = false;
        }
    } else {
        radius3 -= step;
        if (radius3 <= 10) {
            increasing3 = true;
        }
    }

    // 更新颜色索引
    colorIndex = (colorIndex + 1) % colorCount;

    // 延时0.3秒，控制动画速度
    delay(300);
}
复制代码

知识点：GC9A01 驱动芯片

GC9A01是一款支持262,144种颜色的单芯片SOC驱动器，专用于a-TFT液晶显示器，分辨率为240RGBx240像素。它集成了一个360通道源驱动器、一个32通道栅极驱动器，以及129,600字节的GRAM（用于存储240RGBx240像素的图形显示数据），并配备电源电路。

GC9A01支持多种接口模式，包括并行的8/9/12/16/18位数据总线MCU接口、6/12/16/18位数据总线RGB接口，以及3/4线串行外围接口（SPI）。通过窗口地址功能，可以在内部GRAM中指定动态图像区域，并实现该区域的选择性更新，从而同时显示动态图像和静态图像区域。

此外，GC9A01支持全彩模式、8色显示模式以及通过软件控制的睡眠模式，从而实现精准的电源管理。这些特点使GC9A01成为中小型便携设备（如数字手机、智能手机、MP3和PMP）液晶驱动器的理想选择，特别适合那些注重电池续航的应用场景。

关于1.28寸圆形彩色TFT显示屏（240 * 240，SPI接口，GC9A01驱动）的详细介绍：

一、显示屏基本参数
​尺寸与形状
尺寸为1.28寸，采用圆形设计。这种圆形的屏幕在一些特定的应用场景中具有独特优势，比如在可穿戴设备（如智能手表）上，圆形屏幕更符合人体工程学和用户的视觉习惯，能够提供更自然、舒适的观看体验。
​分辨率与显示效果
分辨率为240 * 240像素。这一分辨率在1.28寸的小尺寸屏幕上能够提供较为清晰的图像显示效果。对于显示简单的图标、文字以及一些基本的图形元素来说已经足够，并且可以在有限的空间内展示较为丰富的信息。
作为彩色TFT显示屏，它能够呈现出丰富的色彩。相比黑白显示屏，彩色显示可以增强视觉效果，使数据显示、图像展示等更加生动直观。
采用IPS（In - Plane Switching）技术。IPS技术的优势在于能够提供更广阔的可视角度，从不同的方向观看屏幕时，图像的色彩和对比度变化较小。这对于需要多人查看或者在各种角度下使用设备的场景非常重要，如在工业控制设备中，不同角度的操作人员都能清晰看到屏幕内容。

二、接口与驱动
​SPI接口
SPI（Serial Peripheral Interface）接口是一种高速、全双工、同步的串行通信接口。对于这个1.28寸的显示屏来说，SPI接口具有很多优点。
高速数据传输能力使得微控制器（MCU）能够快速地向显示屏驱动芯片（GC9A01）发送指令和数据。这有助于提高屏幕的响应速度，减少图像显示的延迟，在显示动态图像或者频繁更新的数据时表现得更为出色。
SPI接口的布线相对简单，只需要少量的信号线（如时钟线、数据线、片选线等）就可以实现通信。这对于PCB（印刷电路板）布局来说非常有利，可以减少布线的复杂性，降低电磁干扰（EMI）的风险，同时也有助于节省PCB的空间，使得整个模块更加紧凑。
​GC9A01驱动芯片
GC9A01芯片专门用于驱动这种TFT - LCD屏幕。它负责接收来自MCU通过SPI接口发送过来的指令和数据，并将其转换为对液晶像素的控制信号。
芯片能够对屏幕的显示参数进行设置，如对比度、亮度、色彩饱和度等。通过MCU的软件控制，可以根据具体的应用需求调整这些参数，以达到最佳的显示效果。
在显示控制方面，GC9A01可以实现对240 * 240像素的精确控制，将接收到的数据准确地显示在屏幕上相应的位置。它还支持多种显示模式和图形操作，如清屏、画点、画线、填充区域等基本图形操作，以及更复杂的图像显示和文字显示功能。

三、应用场景
​可穿戴设备
在智能手表、智能手环等可穿戴设备中，这种显示屏可以用来显示时间、通知信息（如短信、邮件提醒）、健康数据（如心率、步数）等。圆形屏幕和彩色显示能够提升用户体验，而SPI接口和GC9A01驱动芯片的组合则保证了数据传输的高效性和显示的稳定性。
​物联网设备
对于一些小型的物联网终端设备，如智能家居传感器节点（带有显示功能）或者工业物联网中的小型监控设备。它可以显示设备的状态信息（如在线/离线、工作模式）、采集到的数据（如温度、湿度数值）等。其紧凑的尺寸、低功耗（得益于SPI接口和芯片本身的特性）以及良好的显示效果使其成为物联网设备显示模块的理想选择。
​小型消费电子设备
在一些小型的消费电子设备中，如便携式音乐播放器、电子相册等。它可以用来显示歌曲信息、播放进度、照片等内容。彩色屏幕和合适的分辨率能够提供较好的视觉体验，而SPI接口方便与设备的MCU进行连接，GC9A01驱动芯片确保了显示功能的正常实现。

实验开发板使用ESP32

实验模块接线示意图

  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之一：点亮GC9A01A显示屏
  实验开源代码

/*
  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之一：点亮GC9A01A显示屏
*/

#include "SPI.h" // 引入SPI库，用于与SPI设备通信
#include "Adafruit_GFX.h" // 引入Adafruit GFX库，用于图形绘制
#include "Adafruit_GC9A01A.h" // 引入GC9A01A显示屏驱动库

#define TFT_DC 2 // 定义TFT显示屏的DC引脚
#define TFT_CS 4 // 定义TFT显示屏的CS引脚

// 创建GC9A01A对象，初始化显示屏
Adafruit_GC9A01A tft(TFT_CS, TFT_DC); 

void setup() {
    Serial.begin(9600); // 初始化串口通信，波特率为9600
    Serial.println("GC9A01A Test!"); // 打印测试信息到串口

    // 初始化显示屏
    tft.begin();
    // 设置显示屏方向
    tft.setRotation(2); 
}

void loop() {
    // 填充屏幕颜色，这里使用黑色，相当于清屏
    tft.fillScreen(GC9A01A_BLACK); 

    // 设置文本颜色为白色
    tft.setTextColor(GC9A01A_WHITE);
    // 设置文本大小
    tft.setTextSize(2);
    // 设置文本起始位置
    tft.setCursor(75, 110);
    // 显示欢迎词
    tft.println("Welcome!");

    // 可以适当添加延时，避免刷新过快
    delay(100);
}    
复制代码

代码解读：

1、引用库文件

#include "SPI.h"                 

#include "Adafruit_GFX.h"         

#include "Adafruit_GC9A01A.h"     
复制代码

SPI库 (SPI.h)：用于支持与SPI设备通信，这是一种快速同步通信协议。
Adafruit GFX库 (Adafruit_GFX.h)：一个灵活的图形库，支持基本图形操作，如绘制线条、矩形和文本。
Adafruit GC9A01A库 (Adafruit_GC9A01A.h)：特定于GC9A01A显示屏的驱动库，负责初始化和控制显示屏硬件。

2、定义引脚

#define TFT_DC 2   

#define TFT_CS 4   
复制代码

TFT_DC：数据/命令引脚，用于区分发送的是显示数据还是指令。
TFT_CS：片选引脚，用于选择当前连接的显示屏。
通过这些定义，代码可以轻松调整连接的硬件配置。

3、创建显示屏对象

Adafruit_GC9A01A tft(TFT_CS, TFT_DC);
复制代码

tft对象：通过将TFT_CS和TFT_DC作为参数传入构造函数，创建显示屏的控制对象，用于后续操作显示屏。

4、初始化设置 (setup())

Serial.begin(9600);                 

Serial.println("GC9A01A Test!");    



tft.begin();                        

tft.setRotation(2);          
复制代码

串口初始化：Serial.begin(9600) 设置波特率为9600，方便进行调试和输出信息。
串口信息输出：Serial.println("GC9A01A Test!") 在串口监视器打印一条调试信息。
显示屏初始化：调用tft.begin()完成GC9A01A显示屏的初始化配置。
屏幕方向设置：使用tft.setRotation(2)调整屏幕的显示方向（数字参数对应不同方向）。

5、主循环 (loop())

tft.fillScreen(GC9A01A_BLACK);      

tft.setTextColor(GC9A01A_WHITE);    

tft.setTextSize(2);                 

tft.setCursor(75, 110);             

tft.println("Welcome!");            

delay(100);
复制代码

填充屏幕背景色：tft.fillScreen(GC9A01A_BLACK) 将屏幕填充为黑色，相当于清屏。
设置文本颜色：tft.setTextColor(GC9A01A_WHITE) 将后续的文本颜色设为白色。
设置文本大小：tft.setTextSize(2) 设置字体的放大比例，2表示常规字体的2倍大小。
设置文本位置：tft.setCursor(75, 110) 将文本的绘制起始点设置为(75, 110)的像素坐标。
显示文本：tft.println("Welcome!") 在屏幕上输出“Welcome!”文字。
延时：delay(100) 增加短暂延时（100毫秒），避免屏幕内容频繁刷新。

6、总结
这段代码主要完成了以下功能：
硬件初始化：通过串口和显示屏驱动库配置硬件。
屏幕方向设置：调整显示方向以适配需求。
屏幕清屏与文字显示：在屏幕上输出静态文本“Welcome!”。
延时避免刷新干扰：延时使屏幕显示更加稳定。

实验串口返回情况

实验场景图

  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之二：显示线条与大小圆形

实验开源代码

/*
  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之二：显示线条与大小圆形
*/

#include "SPI.h" // 引入SPI库，用于与SPI设备通信
#include "Adafruit_GFX.h" // 引入Adafruit GFX库，用于图形绘制
#include "Adafruit_GC9A01A.h" // 引入GC9A01A显示屏驱动库

#define TFT_DC 2 // 定义TFT显示屏的DC引脚
#define TFT_CS 4 // 定义TFT显示屏的CS引脚

// 创建GC9A01A对象，初始化显示屏
Adafruit_GC9A01A tft(TFT_CS, TFT_DC); 

void setup() {
    Serial.begin(9600); // 初始化串口通信，波特率为9600
    Serial.println("GC9A01A Test!"); // 打印测试信息到串口

    // 初始化显示屏
    tft.begin();
    // 设置显示屏方向
    tft.setRotation(3); 
}

void loop() {
    // 填充屏幕颜色，这里使用黑色，相当于清屏
    tft.fillScreen(GC9A01A_BLACK); 

    // 设置文本颜色为白色
    tft.setTextColor(GC9A01A_WHITE);
    // 设置文本大小
    tft.setTextSize(2);
    // 设置文本起始位置
    tft.setCursor(80, 120);
    // 显示欢迎词
    tft.println("Welcome!");

    // 绘制线条
    tft.drawLine(20, 20, 200, 20, GC9A01A_RED);

    // 绘制小圆形
    tft.drawCircle(120, 60, 10, GC9A01A_GREEN);

    // 绘制大圆形
    tft.fillCircle(130, 200, 30, GC9A01A_BLUE);

    // 可以适当添加延时，避免刷新过快
    delay(100);
}    
复制代码

代码解读

1、​引入库：

SPI.h：用于与SPI设备通信。
Adafruit_GFX.h：提供基本的图形绘制功能（如绘制线条、圆形等）。
Adafruit_GC9A01A.h：提供GC9A01A显示屏的驱动支持。

2、​引脚定义：

TFT_DC：定义TFT显示屏的DC引脚（数据/命令选择引脚）。
TFT_CS：定义TFT显示屏的CS引脚（片选引脚）。

3、​显示屏对象：

使用Adafruit_GC9A01A类创建tft对象，初始化显示屏。

4、setup()函数：

初始化串口通信，用于调试输出。
初始化显示屏，设置显示屏方向为横向（setRotation(3)）。
​
5、loop()函数：

清空屏幕（填充为黑色）。
显示欢迎词（"Welcome!"）。
绘制一条红色线条。
绘制一个小绿色圆形。
绘制一个大蓝色填充圆形。
添加延时（delay(100)），避免刷新过快。

实验串口返回情况

实验场景图  

  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之三：间隔1秒循环显示七彩虹颜色

实验开源代码

/*
  【Arduino】189种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验二百四十九：1.28寸圆形彩色TFT显示屏 高清IPS 模块 240*240 SPI接口GC9A01驱动
  项目实验之三：间隔1秒循环显示七彩虹颜色
*/

#include "SPI.h" // 引入SPI库，用于与SPI设备通信
#include "Adafruit_GFX.h" // 引入Adafruit GFX库，用于图形绘制
#include "Adafruit_GC9A01A.h" // 引入GC9A01A显示屏驱动库

#define TFT_DC 2 // 定义TFT显示屏的DC引脚
#define TFT_CS 4 // 定义TFT显示屏的CS引脚

// 创建GC9A01A对象，初始化显示屏
Adafruit_GC9A01A tft(TFT_CS, TFT_DC);

// 定义七彩虹颜色
const uint16_t rainbowColors[] = {
    GC9A01A_RED,
    GC9A01A_ORANGE,
    GC9A01A_YELLOW,
    GC9A01A_GREEN,
    GC9A01A_BLUE,
    0x4B0082, // 近似靛色的 RGB565 值
    0xEE82EE  // 近似紫色的 RGB565 值
};

// 定义颜色数量
const int numColors = sizeof(rainbowColors) / sizeof(rainbowColors[0]);

void setup() {
    Serial.begin(9600); // 初始化串口通信，波特率为9600
    Serial.println("GC9A01A Test!"); // 打印测试信息到串口

    // 初始化显示屏
    tft.begin();
    // 设置显示屏方向
    tft.setRotation(3);
}

void loop() {
    for (int i = 0; i < numColors; i++) {
        // 填充屏幕为当前七彩虹颜色
        tft.fillScreen(rainbowColors[i]);

        // 设置文本颜色为白色
        tft.setTextColor(GC9A01A_WHITE);
        // 设置文本大小
        tft.setTextSize(2);
        // 设置文本起始位置
        tft.setCursor(80, 120);
        // 显示欢迎词
        tft.println("Welcome!");

        // 绘制线条
        tft.drawLine(20, 20, 200, 20, GC9A01A_RED);

        // 绘制小圆形
        tft.drawCircle(120, 60, 10, GC9A01A_GREEN);

        // 绘制大圆形
        tft.fillCircle(130, 200, 30, GC9A01A_BLUE);

        // 间隔1秒
        delay(1000);
    }
}
复制代码

功能解析
1、​硬件连接：

使用SPI接口连接TFT显示屏。
TFT_DC（数据/命令选择引脚）连接到Arduino的GPIO 2。
TFT_CS（片选引脚）连接到Arduino的GPIO 4。
​
2、主要功能：

初始化TFT显示屏。
定义七彩虹颜色数组。
每隔1秒循环填充屏幕为不同的彩虹颜色。
在屏幕上显示欢迎词（"Welcome!"）。
绘制简单的图形（线条和圆形）。

3、​颜色定义：

使用GC9A01A_RED、GC9A01A_ORANGE等预定义颜色常量。
使用RGB565格式手动定义靛色（0x4B0082）和紫色（0xEE82EE）。

4、​关键代码段分析
​1. 引入库和引脚定义

#include "SPI.h" // 引入SPI库，用于与SPI设备通信

#include "Adafruit_GFX.h" // 引入Adafruit GFX库，用于图形绘制

#include "Adafruit_GC9A01A.h" // 引入GC9A01A显示屏驱动库



#define TFT_DC 2 // 定义TFT显示屏的DC引脚

#define TFT_CS 4 // 定义TFT显示屏的CS引脚
复制代码

​解读：
SPI.h：提供SPI通信协议的支持，TFT显示屏通过SPI接口与Arduino通信。
Adafruit_GFX.h：提供通用的图形绘制功能（如绘制线条、圆形等）。
Adafruit_GC9A01A.h：提供GC9A01A显示屏的驱动支持，包括初始化、设置方向、填充颜色等功能。
TFT_DC和TFT_CS：定义显示屏的控制引脚，分别用于数据/命令选择和片选。

​2. 创建显示屏对象

Adafruit_GC9A01A tft(TFT_CS, TFT_DC);
复制代码

​解读：
创建tft对象，初始化GC9A01A显示屏。
TFT_CS和TFT_DC分别传递给构造函数，用于控制显示屏的片选和数据/命令选择。

​3. 定义七彩虹颜色

const uint16_t rainbowColors[] = {

    GC9A01A_RED,

    GC9A01A_ORANGE,

    GC9A01A_YELLOW,

    GC9A01A_GREEN,

    GC9A01A_BLUE,

    0x4B0082, // 近似靛色的 RGB565 值

    0xEE82EE  // 近似紫色的 RGB565 值

};



const int numColors = sizeof(rainbowColors) / sizeof(rainbowColors[0]);
复制代码

​解读：
rainbowColors数组定义了七彩虹颜色，包括预定义的颜色常量（如GC9A01A_RED）和手动定义的RGB565颜色值。
numColors计算数组中颜色的数量，方便循环遍历。

​4. 初始化显示屏

void setup() {

    Serial.begin(9600); // 初始化串口通信，波特率为9600

    Serial.println("GC9A01A Test!"); // 打印测试信息到串口



    // 初始化显示屏

    tft.begin();

    // 设置显示屏方向

    tft.setRotation(3);

}
复制代码

​解读：
Serial.begin(9600)：初始化串口通信，波特率为9600，用于调试输出。
tft.begin()：初始化GC9A01A显示屏，配置显示屏的工作模式。
tft.setRotation(3)：设置显示屏的方向为横向（旋转180°）。setRotation的值范围为0到3，分别对应不同的屏幕方向：
0：正常方向。
1：顺时针旋转90°。
2：旋转180°。
3：顺时针旋转270°。

​5. 循环显示七彩虹颜色

void loop() {

    for (int i = 0; i < numColors; i++) {

        // 填充屏幕为当前七彩虹颜色

        tft.fillScreen(rainbowColors[i]);



        // 设置文本颜色为白色

        tft.setTextColor(GC9A01A_WHITE);

        // 设置文本大小

        tft.setTextSize(2);

        // 设置文本起始位置

        tft.setCursor(80, 120);

        // 显示欢迎词

        tft.println("Welcome!");



        // 绘制线条

        tft.drawLine(20, 20, 200, 20, GC9A01A_RED);



        // 绘制小圆形

        tft.drawCircle(120, 60, 10, GC9A01A_GREEN);



        // 绘制大圆形

        tft.fillCircle(130, 200, 30, GC9A01A_BLUE);



        // 间隔1秒

        delay(1000);

    }

}
复制代码

​解读：
​循环遍历颜色数组：
使用for循环遍历rainbowColors数组，依次填充屏幕为不同的颜色。
​清空屏幕：
tft.fillScreen(rainbowColors)：用当前颜色填充整个屏幕。
​显示欢迎词：
tft.setTextColor(GC9A01A_WHITE)：设置文本颜色为白色。
tft.setTextSize(2)：设置文本大小为2倍。
tft.setCursor(80, 120)：设置文本的起始位置为(80, 120)。
tft.println("Welcome!")：在屏幕上显示"Welcome!"，并换行。
​绘制图形：
tft.drawLine(20, 20, 200, 20, GC9A01A_RED)：从(20, 20)到(200, 20)绘制一条红色线条。
tft.drawCircle(120, 60, 10, GC9A01A_GREEN)：在(120, 60)处绘制一个半径为10的绿色空心圆。
tft.fillCircle(130, 200, 30, GC9A01A_BLUE)：在(130, 200)处绘制一个半径为30的蓝色实心圆。
​延时：
delay(1000)：延时1秒，确保每种颜色显示1秒。

实验串口返回情况

实验场景图  动态图