IOT

Trò chơi Tic-tac-toe Dựa trên STONE TFT LCD và STM32

Được xuất bản lại bởi Plato Được xuất bản lại bởi PlatoDấu thời gian:

Tổng kết

Tic-tac-toe là một trò chơi được chơi trên lưới 3 x 3, tương tự như gobang. Nó có tên như vậy bởi vì bảng thường không vẽ đường viền và các đường lưới được sắp xếp thành tic-tac-toe. Công cụ cần thiết cho trò chơi chỉ là giấy và bút. Sau đó, hai người chơi đại diện cho O và X lần lượt để lại dấu trên lưới. Ba dấu bất kỳ tạo thành một đường thẳng, đó là người chiến thắng.

Bài viết này sử dụng vi điều khiển STM32 và màn hình STONE LCD để phát triển một trò chơi tic-tac-toe đơn giản.

Vật liệu cần thiết cho thí nghiệm

Nguyên tắc hệ thống

Chỉ định lần nhấn đầu tiên trên màn hình phải là O, lần nhấn thứ hai trên màn hình là X, đã được thực hiện chu kỳ này. Đặt 8 mảng để lưu trữ số lượng O và X trong mỗi hàng, cột và đường chéo của mỗi lưới, miễn là có ba dấu giống nhau là chiến thắng, sau đó sẽ có một ô màu đỏ nhấp nháy để chứng minh chiến thắng của hàng, cột hoặc đường chéo, sau đó chạm vào đặt lại để bắt đầu lại trò chơi.

Sau đây là lưu đồ:

Thiết kế phần cứng Hệ thống hiển thị STM32 và STONE LCD

(A) Màn hình LCD ĐÁ

  1. Thiết kế phần cứng "Tic-tac-toe game"

Sử dụng màn hình LCD STONE của Beijing STONE Technology co., Ltd, model là STWI070WT-01, với màn hình TFT tích hợp và bộ điều khiển cảm ứng.

  1.  SVC070WT-01 tính năng sản phẩm
Thông số vật lý 
Kích thước máy7 inch
Độ phân giải800 × RGB × 480
Khoảng cách pixel0.0642 (W) × 0.1790 (H) mm
Màu262,144 màu (18 bit)
Nhìn xung quanh154.08 (W) × 85.92 (H) mm
Kích thước hiển thị186.4mmx105.5mm
Kích thước tổng thể186.4mmx105.5mmx17.4mm (Loại tiêu chuẩn) 186.4mmx105.5mmx23.8mm (với cổng Ethernet)
Khối lượng tịnh300g
Giao diện 
Loại đèn nềnLED
độ sáng300cd / m2 (Độ sáng có thể được điều chỉnh ở 100 cấp độ)
Tương phản500:1
Ngược sáng cuộc sống300,000 giờ
Góc nhìn70 ° / 70 ° / 50 ° / 70 ° (L / R / U / D)
Bảng điều khiển TFTBảng điều khiển công nghiệp hạng A
Màn hình cảm ứng4 dây điện trở Cảm ứng / Cảm ứng điện dung / Không có màn hình cảm ứng
Chế độ màn hình ：Kỹ thuật số
Bộ xử lý 
CPUCortex A8
Tốc độ làm tươi1G Hz
Tốc độ khung hình tối đa60 FPS
Giao thức 
Giao diện nối tiếpMức RS232 / RS422 / RS485 / TTL
giao diện Ethernet10 triệu / 100 triệu (Tùy chọn)
Giao diện không dâyWi-Fi / Bluetooth (Tùy chọn)
Tải xuống tệp dự ánCổng USB2.0 hoặc Đĩa lưu trữ U
Điện nguồn 
Điện áp định mức+ 12V DC hoặc + 5V DC
Dải điện áp cho phép+ 7V DC… + 28V DC hoặc + 5V DC
Tối đa quá độ cho phép+ 28V
Thời gian giữa hai lần chuyển tiếpTối thiểu 50 giây
Cầu chì nội bộCầu chì tự phục hồi 2A
Công suất tiêu thụ3.0 W
Điều kiện môi trường xung quanh 
Tối đa nhiệt độ môi trường cho phépHoạt độngStorage-20 ℃ ～ + 70 ℃ -30 ℃ ～ + 80 ℃
Độ ẩm tương đốiHoạt độngStorage55 ℃, 85% 60 ℃, 90%
Tải sốcHoạt độngStorage15 g / 11 msec 25 g / 6 msec
RungHoạt độngStorage0.035 mm (10 - 58 Hz) / 1 g (58 - 500 Hz) 3.5 mm (5 - 8,5 Hz) / 1 g (8.5 - 500 Hz)
Áp suất khí quyểnHoạt độngStorage706 đến 1030 hPa581 đến 1030 hPa
Khả năng chống ồn 
Xả tĩnh (xả tiếp xúc / xả khí)EN 61000-4-2 6 kV / 8 kV
Chiếu xạ RFEN 61000-4-310 V / m, 80% AM1 kHz
Điều chế xungENV 50204900 MHz ± 5 MHz 10 V / meff., 50% ED, 200 Hz
Dẫn truyền RFEN 61000-4-6150 kHz - 80 MHz10 V, 80% AM, 1 kHz
Nhiễu chùm Đường cung cấp Đường dữ liệu xử lý Đường tín hiệuEN 61000-4-42kV2kV1kV
Thiết bị hỗ trợ 
Cổng UARTHỗ trợ RS232 / RS422 / RS485 / TTL
Cảng mạngHỗ trợ Cổng Ethernet / Wi-Fi / Bluetooth
Flash MemoryHỗ trợ Tiêu chuẩn 256MB, Mở rộng 1GB hoặc 2GB
buzzerHỖ TRỢ
RTCHỖ TRỢ
Cổng USBHỗ trợ Tải xuống trực tuyến bằng cáp USB
Giao diện đĩa lưu trữ UHỗ trợ. Tải xuống ngoại tuyến hoặc sao chép dữ liệu người dùng
Màn hình cảm ứng4 Điện trở dây / Điện dung
Phông chữ Véc tơĐịnh dạng TTF chuẩn
Hình ảnhHỗ trợ định dạng PNG / JPG / BMP / SVG / GIF
Âm thanh giao diệnHỗ trợ định dạng WAV Độ dài của một tệp âm thanh đơn lẻ không bị giới hạn, về mặt lý thuyết lên đến 4096 tệp âm thanh, công suất loa là 8 ohms 2 watt hoặc 4 ohms 3 watt
Bộ lệnhBộ lệnh đơn giản hóa hợp nhất
Bộ nhớ 
Flash MemoryTiêu chuẩn 256MB, Phần mở rộng 1GB hoặc 2GB
Dung lượng bộ nhớ cho hình ảnhTheo khả năng của hình ảnh, Đề xuất định dạng “PNG, BMP, JPG, SVG, GIF”.

(B) Bảng STM32

Sử dụng bo mạch STM32, chip của STM32 là CKS32F303.

Họ STM32 gồm các lõi ARM Cortex-M0, M0 +, M3, M4 và M7 được thiết kế cho các ứng dụng nhúng yêu cầu hiệu suất cao, chi phí thấp và tiêu thụ điện năng thấp.

  • Nguồn điện 2.0V-3.6V
  • Chân I / O tương thích 5V
  • Chế độ đồng hồ an toàn tuyệt vời
  • Chế độ năng lượng thấp với chức năng đánh thức
  • Bộ dao động RC bên trong
  • Mạch đặt lại được nhúng
  • Nhiệt độ hoạt động.
  • -40 ° C đến + 85 ° C hoặc 105 ° C

Thiết kế phần mềm hệ thống

Quá trình phát triển của màn hình LCD STM32 và STONE

1: tạo dự án và tải các hình ảnh cần thiết vào dự án.

2: sử dụng phần mềm Stone-designer để tạo, liên kết động các mối quan hệ; các điều khiển chính là: “Nút”, “hình ảnh”;

3: mô phỏng và biên dịch phần mềm để tạo ra các tệp thực thi.

4: màn hình LCD được kết nối với PC qua USB và sao chép tệp thực thi vào màn hình.

Đầu tiên hãy tạo một dự án mới như hình dưới đây.

Thứ hai, nhập tất cả các hình ảnh vào tài nguyên

Sau đó, đặt các nút điều khiển cho từng lưới và làm cho các nút ẩn đi. 

Đừng quên đặt nút đặt lại!

Hiệu ứng hoàn thành được hiển thị bên dưới:

Sau đó, thêm các điều khiển hình ảnh vào từng lưới theo cách tương tự và đặt tất cả chúng thành hình ảnh màu trắng.

Cuối cùng, thêm điều khiển gif và đặt nó thành ẩn.

Các phần của hiệu ứng đã hoàn thành được hiển thị bên dưới:

Sơ đồ kết nối mạch

Chia sẽ mã

/* Bao gồm ----------------------*/ 

#include “stm32f0xx_hal.h” 

#include “Uart.h” 

#include “chuỗi.h” 

#include “ws2812.h” 

#include “IWDG.h” 

RGB_COLOR NGƯỜI DÙNG_RGB_COLOR; 

unsigned char TX_Mode = 1; // Cờ kiểu truyền bit 1: 232 0: TTL 

char không dấu BLINK_2 = 0; 

char không dấu RX3_BUF [32]; // Bộ đệm nhận ba cấp tùy chỉnh 

#define NÚT1 0x81 

#define NÚT2 0x82 

#define NÚT3 0x83 

#define NÚT4 0x84 

#define NÚT5 0x85 

#define NÚT6 0x86 

#define NÚT7 0x87 

#define NÚT8 0x88 

#define NÚT9 0x89 

#define NÚT0 0x8A 

#define XÓA 0x8E 

không dấu int r_flag1 = 0; 

unsigned int quan [4] [2] = {0}; 

unsigned int cha [4] [2] = {0}; 

unsigned int quan_hang1 = 0; 

unsigned int quan_hang2 = 0; 

unsigned int quan_hang3 = 0; 

unsigned int quan_lie1 = 0; 

unsigned int quan_lie2 = 0; 

unsigned int quan_lie3 = 0; 

không dấu int quan_zuoxia = 0; 

không dấu int quan_youxia = 0; 

không dấu int cha_hang1 = 0; 

không dấu int cha_hang2 = 0; 

không dấu int cha_hang3 = 0; 

không dấu int cha_lie1 = 0; 

không dấu int cha_lie2 = 0; 

không dấu int cha_lie3 = 0; 

không dấu int cha_zuoxia = 0; 

unsigned int cha_youxia = 0; // không dấu int r_flag10 = 0; 

void SystemClock_Config (void); 

void Error_Handler (void); 

static void MX_GPIO_Init (void); 

int chính (void) 

{ 

uint8_t color_buf = 0; 

// Lựa chọn hàm 

/ * Đặt lại tất cả các thiết bị ngoại vi, Khởi tạo giao diện Flash và Systick. * / 

HAL_Init (); 

/ * Định cấu hình đồng hồ hệ thống * / 

SystemClock_Config (); 

/ * Khởi tạo tất cả các thiết bị ngoại vi đã định cấu hình * / 

MX_GPIO_Init (); 

TX_Mode = HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_4); 

if (TX_Mode) 

MX_USART1_UART_Init (); 

// 232 Khởi tạo 

khác 

MX_USART1_UART_Init2 (); 

// Khởi tạo TTl 

trong khi (1) 

{ 

if (TX_Mode! = HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_4)) 

HAL_NVIC_SystemReset (); 

// Đảo ngược jumper, khởi động lại và khởi động lại 

nếu (MNG_USART1.RX_OVER_FLG == TRUE) 

// 

Bit cờ nhận dữ liệu nối tiếp 

{ 

RX3_BUF [0] = MNG_USART1.RX_BUF [7]; 

// Phương pháp 2: Lấy tên điều khiển độ dài cố định 

RX3_BUF [1] = MNG_USART1.RX_BUF [8]; 

RX3_BUF [2] = MNG_USART1.RX_BUF [9]; 

RX3_BUF [3] = MNG_USART1.RX_BUF [10]; 

RX3_BUF [4] = MNG_USART1.RX_BUF [11]; 

RX3_BUF [5] = MNG_USART1.RX_BUF [12]; 

RX3_BUF [6] = MNG_USART1.RX_BUF [13]; 

//RX3_BUF[7]=MNG_USART1.RX_BUF[14]; 

if ((strcmp (“button1”, (const char *) RX3_BUF)) == 0) 

// Chọn điều khiển

{ 

color_buf = BUTTON1; 

}

if ((strcmp (“button2”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON2; 

}

if ((strcmp (“button3”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON3; 

}

if ((strcmp (“button4”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON4; 

}

if ((strcmp (“button5”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON5; 

}

if ((strcmp (“button6”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON6; 

}

if ((strcmp (“button7”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON7; 

}

if ((strcmp (“button8”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON8; 

}

if ((strcmp (“button9”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON9; 

}

if ((strcmp (“button0”, (const char *) RX3_BUF)) == 0) 

{ 

color_buf = BUTTON0; 

}

chuyển đổi (color_buf) 

{ 

trường hợp NÚT1: 

// if (r_flag1 == 0) 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

r_flag1 ^ = 1; 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image2 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 ^ = 1; 

quan_hang1 ++; 

quan_lie1 ++; 

quan_youxia ++;  

// memset (RX3_BUF, 0,7); 

//bộ nhớ(MNG_USART1.RX_BUF,0,USART1_RX_LEN); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image2 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang1 ++; 

cha_lie1 ++; 

cha_youxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

// r_flag1 = 1; 

phá vỡ; 

trường hợp NÚT2: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image3 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang1 ++; 

quan_lie2 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image3 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang1 ++; 

cha_lie2 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT3: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image4 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang1 ++; 

quan_lie3 ++; 

quan_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image4 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang1 ++; 

cha_lie3 ++; 

cha_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT4: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image5 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang2 ++; 

quan_lie1 ++; 

// memset (RX3_BUF, 0,7); 

// r_flag10 = 1; 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image5 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang2 ++; 

cha_lie1 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT5: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image6 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang2 ++; 

quan_lie2 ++; 

quan_zuoxia ++; 

quan_youxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image6 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang2 ++; 

cha_lie2 ++; 

cha_zuoxia ++; 

cha_youxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT6: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image7 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang2 ++; 

quan_lie3 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02))

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image7 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang2 ++; 

cha_lie3 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT7: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image8 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang3 ++; 

quan_lie1 ++; 

quan_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image8 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang3 ++; 

cha_lie1 ++; 

cha_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT8: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image9 \ ”, \” image \ ”: \” circle \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang3 ++; 

quan_lie2 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image9 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang3 ++; 

cha_lie2 ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT9: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image10 \ ”, \” image \ ”: \” circle \ ”}> ET”);

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang3 ++; 

quan_lie3 ++; 

quan_youxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

khác nếu ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image10 \ ”, \” image \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang3 ++; 

cha_lie3 ++; 

cha_youxia ++; 

// memset (RX3_BUF, 0,7); 

color_buf = XÓA; 

}

phá vỡ; 

trường hợp NÚT0: 

r_flag1 = 0; 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image2 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image3 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image4 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image5 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image6 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image7 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image8 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image9 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1);

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_image \ ”, \” type \ ”: \” image \ ”, \” widget \ ”: \” image10 \ ”, \” image \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif4 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif5 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif6 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif7 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif8 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif9 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif10 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif11 \ ”, \” hiển thị \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

// memset (RX3_BUF, 0,7); 

memset (MNG_USART1.RX_BUF, 0, USART1_RX_LEN); 

phá vỡ; 

mặc định: 

MNG_USART1.RX_OVER_FLG = FALSE; 

phá vỡ; 

}

//////////////////////////////////////////////////////// //////////////////// 

if ((quan_hang1 == 3) || (cha_hang1 == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif4 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_hang2 == 3) || (cha_hang2 == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif5 \ ”, \” hiển thị \ ”: true}> ET ”);

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_hang3 == 3) || (cha_hang3 == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif6 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_lie1 == 3) || (cha_lie1 == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif7 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_lie2 == 3) || (cha_lie2 == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif8 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_lie3 == 3) || (cha_lie3 == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif9 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_zuoxia == 3) || (cha_zuoxia == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif11 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_youxia == 3) || (cha_youxia == 3)) 

{ 

bộ nhớ (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” type \ ”: \” widget \ ”, \” widget \ ”: \” gif10 \ ”, \” hiển thị \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

} 

MNG_USART1.RX_OVER_FLG = FALSE; 

} 

} 

}

/ ** Cấu hình đồng hồ hệ thống 

*/

void SystemClock_Config (void) 

{ 

RCC_OscInitTypeDef RCC_OscInitStruct; 

RCC_ClkInitTypeDef RCC_ClkInitStruct; 

RCC_PeriphCLKInitTypeDef PeriphClkInit; 

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI; 

RCC_OscInitStruct.HSIState = RCC_HSI_ON; 

RCC_OscInitStruct.HSICalibrationValue = 16; 

RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; 

RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI; 

RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12; 

RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1; 

if (HAL_RCC_OscConfig (& RCC_OscInitStruct)! = HAL_OK) 

{ 

Error_Handler (); 

}

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK 

| RCC_CLOCKTYPE_PCLK1; 

RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; 

RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; 

RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; 

if (HAL_RCC_ClockConfig (& RCC_ClkInitStruct, FLASH_LATENCY_1)! = HAL_OK) 

{ 

Error_Handler (); 

}

PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1; 

PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1; 

if (HAL_RCCEx_PeriphCLKConfig (& PeriphClkInit)! = HAL_OK) 

{ 

Error_Handler (); 

}

HAL_SYSTICK_Config (HAL_RCC_GetHCLKFreq () / 1000); 

HAL_SYSTICK_CLKSourceConfig (SYSTICK_CLKSOURCE_HCLK); 

/ * Cấu hình ngắt SysTick_IRQn * / 

HAL_NVIC_SetPosystem (SysTick_IRQn, 0, 0); 

}

/ ** Cấu hình sơ đồ chân 

*/

static void MX_GPIO_Init (void) 

{ 

GPIO_InitTypeDef GPIO_InitStruct; 

/ * Bật đồng hồ cổng GPIO * / 

__HAL_RCC_GPIOA_CLK_ENABLE (); 

GPIO_InitStruct.Pin = GPIO_PIN_7; 

GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; 

GPIO_InitStruct.Pull = GPIO_PULLDOWN; 

GPIO_InitStruct.Speed ​​= GPIO_SPEED_FREQ_HIGH; 

HAL_GPIO_Init (GPIOA, & GPIO_InitStruct); 

GPIO_InitStruct.Pin = GPIO_PIN_4; 

GPIO_InitStruct.Mode = GPIO_MODE_INPUT; 

GPIO_InitStruct.Pull = GPIO_PULLUP; 

GPIO_InitStruct.Speed ​​= GPIO_SPEED_FREQ_HIGH; 

HAL_GPIO_Init (GPIOA, & GPIO_InitStruct); 

}

/ * MÃ NGƯỜI DÙNG BẮT ĐẦU 4 * /

/ * MÃ NGƯỜI DÙNG KẾT THÚC 4 * / 

/ **

* @brief Chức năng này được thực thi trong trường hợp xảy ra lỗi. 

* @param Không có 

* @retval Không có 

*/ 

void Error_Handler (void) 

{ 

/ * MÃ NGƯỜI DÙNG BEGIN Error_Handler * / 

/ * Người dùng có thể thêm phần triển khai của riêng mình để báo cáo trạng thái trả về lỗi HAL * / 

trong khi (1) 

{

}

/ * USER CODE END Error_Handler * / 

}

#ifdef SỬ DỤNG_FULL_ASSERT 

/ **

* @brief Báo cáo tên của tệp nguồn và số dòng nguồn 

* nơi mà lỗi khẳng định_param đã xảy ra. 

* @param tệp: con trỏ đến tên tệp nguồn 

* Dòng @param: số nguồn của dòng lỗi khẳng định_param 

* @retval Không có 

*/ 

void khẳng định_failed (tệp uint8_t *, dòng uint32_t) 

{ 

/ * MÃ NGƯỜI DÙNG BẮT ĐẦU 6 * / 

/ * Người dùng có thể thêm triển khai của riêng mình để báo cáo tên tệp và số dòng, 

ví dụ: printf (“Giá trị tham số sai: tệp% s trên dòng% d \ r \ n”, tệp, dòng) * / 

/ * MÃ NGƯỜI DÙNG KẾT THÚC 6 * / 

}

#endif 

/ **

* @} 

*/ 

/ **

* @} 

*/

/ ************************ (C) BẢN QUYỀN STMicroelectronics ***** END OF FILE **** /

Kết quả cuối cùng cho thấy

Nguồn: Plato Data Intelligence

bài viết liên quan

Tự động hóa đồng hồ và nhà bằng màn hình ĐÁ

Nút nguồn:
Dấu thời gian: Ngày 11 tháng 2021 năm 8 27:XNUMX sáng - Đã sửa đổi vào: Tháng Mười Một 11, 2021 - Xuất bản bởi:
Cụm nguồn:
Được xuất bản lại bởi Plato

Nội dung Mô tả Thiết kế giao diện người dùng 3. Sơ đồ mạch Mã số Video Mô tả Trong dự án này, chúng tôi sẽ thiết kế một đồng hồ và một hệ thống tự động hóa với sự trợ giúp này, chúng tôi có thể BẬT hoặc TẮT đèn nhà và cũng có đồng hồ sẽ hiển thị thời gian và ngày tháng. Đối với điều này, chúng tôi đang sử dụng màn hình TFT (STONE-HMI), màn hình này có phần mềm là phần mềm GUI với sự trợ giúp này, chúng tôi sẽ thiết kế giao diện sẽ chứa cả đồng hồ phần và tự động hóa. Tải xuống phần mềm GUI nhấp vào đây Thiết kế phần đồng hồ

Điều khiển máy bơm Arduino + Màn hình HMI ĐÁ

Nút nguồn:
Dấu thời gian: Ngày 11 tháng 2021 năm 5 35:XNUMX sáng - Đã sửa đổi vào: Tháng Mười Một 12, 2021 - Xuất bản bởi:
Cụm nguồn:
Được xuất bản lại bởi Plato

Hệ thống điều tiết thông minh dạng phiến là một công nghệ đã được cấp bằng sáng chế, được sử dụng trong hệ thống điều khiển dòng chính của các trạm thủy điện và trạm bơm lớn, vừa và nhỏ khác nhau. Dự án này sử dụng màn hình cảm ứng công nghiệp nối tiếp đáng tin cậy làm giao diện người-máy để hiển thị các thông số hàng ngày và liều lượng lưỡi dao theo thời gian thực, công suất đầu ra, dòng chảy tức thời và các thông tin khác, khi hiển thị hiệu ứng hoạt động. Ngoài ra, bản ghi điều kiện làm việc và biểu mẫu cảnh báo lỗi cũng được lên kế hoạch, và nút chờ được dành riêng. Dự án sử dụng màn hình cảm ứng nối tiếp để hiển thị dữ liệu và chỉ dẫn trang chiếu