STONE Écran LCD pour tableau de bord de voiture

Notes: L'écran LCD de 10.1 pouces pour le tableau de bord de la voiture et le STONE L'écran LCD combiné au MCU RTL8762CJF est utilisé pour développer et créer un tableau de bord d'affichage intégré.

Introduction

Dans le processus d'utilisation quotidienne de la voiture, nous devons toujours comprendre l'état de la voiture, pour éviter d'endommager les parties importantes de la voiture, mais aussi pour éliminer les dangers potentiels. Souvent, les informations affichées au tableau de bord sont un moyen de connaître l'état du véhicule.

Cette fois, je vais utiliser un écran LCD TFT de 10.1 pouces pour créer un tableau de bord d'affichage intégré. Comme nous le savons tous, le développement de STONE L'affichage intelligent du module LCD TFT est pratique et rapide, sans trop d'instructions fastidieuses. Cela convient non seulement à la majorité des amateurs d'apprentissage, mais dans le projet réel peut accélérer le développement, gagner du temps de développement, occuper rapidement le marché.

J'utilise le SCM RTL8762CJF le plus couramment utilisé pour développer, via IIC ou un port série, afin d'atteindre l'objectif de télécharger des données sur l'écran LCD TFT. Cette fois, utilisera également la fonction de diffusion vocale, pour donner au conducteur une meilleure expérience de simulation.

Tableau de bord de voiture à écran LCD Fonction de projet

Ici, nous devons faire un projet d'affichage de voiture d'occasion, le projet principalement via la régulation tactile, la manière d'instructions de téléchargement du microcontrôleur, la simulation avec des boutons, lorsque le bouton MCU appuie, via une commande de port série vers STVC101WT - 01 instructions d'écran d'interface série pour télécharger des données, le L'écran analysera automatiquement les données et s'affichera sur l'écran LCD. Dans le même temps, il existe également une fonction de bouton sur l'écran pour obtenir l'instruction de port série, afin de contrôler le MCU.

En résumé, cinq fonctions

  1. L'écran du port série réalise la fonction d'affichage bitmap ;
  2. pour réaliser la fonction de rotation du cadran ;
  3. pour réaliser la commande tactile émise ;
  4. réaliser la diffusion vocale;
  5. pour réaliser le téléchargement d'instructions de données.

La fonction est déterminée, puis la sélection du module :

  1. Modèle de l'écran tactile ;
  2. quel type de module MCU utiliser ;
  3. module de diffusion vocale.

Introduction et principe du matériel

La Corne

Parce que le STONE L'écran du port série est livré avec un pilote audio et réservé l'interface correspondante, de sorte que vous pouvez utiliser le haut-parleur magnétique le plus courant, communément appelé klaxon. Le haut-parleur est une sorte de transducteur qui convertit les signaux électriques en signaux sonores. Le haut-parleur est l'un des composants les plus faibles de l'équipement de sonorisation et l'un des composants les plus importants pour les effets sonores. Il existe de nombreux types de haut-parleurs et les prix varient considérablement. L'énergie électrique audio produit du son en faisant vibrer et résonner (résonner) son bassin en papier ou son diaphragme avec l'air ambiant par un effet électromagnétique, piézoélectrique ou électrostatique.

Lien d'achat: http://dwz.date/afdC

Description de l'écran LCD série STVC101WT-01

  • Panneau TFT de qualité industrielle 10.1 pouces 1024 × 600 et écran tactile résistif à 4 fils;
  • Luminosité 300cd/m2 ;
  • Rétro-éclairage LED;
  • couleur RVB 65 XNUMX ;
  • La zone visible est de 222.7 mm * 125.3 mm ;
  • Angle visuel 70/70/50/60 ;
  • Durée de vie 20,000 XNUMX heures.
  • Processeur cortex-m32 4Hz 200 bits;
  • Contrôleur CPLD EPM240 tft-lcd ;
  • 128 Mo (ou 1 Go) de mémoire flash ;
  • Téléchargement du port USB (disque U);
  • Logiciel de boîte à outils pour la conception d'interfaces graphiques ;
  • Instruction hexadécimale simple et puissante.

La fonction de base

  • 8m-128m octets Espace mémoire flash, série SDWe 128M octets, série SDWa 8M/16M octets;
  • Prise en charge du décodage JPG matériel, stockage plus efficace, affichage plus rapide;
  • Prend en charge le téléchargement par lots hors ligne du disque U, améliore efficacement l'efficacité du téléchargement par lots, réduit les exigences de qualité professionnelle des opérateurs ;
  • espace de registre de 256 octets ;
  • Espace mémoire variable 64K mots (128K octets), stockage de courbes 8 canaux, affichage variable très rapide (80ms)
  • Vitesse de réponse ;
  • Prend en charge jusqu'à 128 variables d'affichage par page ;
  • Horloge en temps réel RTC intégrée, fonction sonore de sonnerie tactile ;
  • Logiciel de support 90 degrés, 180 degrés, rotation de l'écran à 270 degrés, ajustez l'angle visuel approprié;
  • Prend en charge le réglage de la luminosité du rétroéclairage, la fonction d'économiseur d'écran en veille automatique ;
  • Prise en charge du clavier matriciel externe ;
  • Prise en charge de la lecture audio et vidéo ;
  • Indice de rayonnement électromagnétique à la pointe de l'industrie, vous aide à gérer facilement la classe B ;
  • La règle de dénomination du nom de fichier est simple, sans correspondre au numéro de bloc Flash, également sans allocation manuelle fastidieuse. Fonction de bloc Flash ;
  • Prend en charge la fonction d'écran série virtuel.

STONE Le module d'affichage STVC101WT - 01 se fait via une communication de port série avec MCU, nous devons l'utiliser dans ce projet, nous n'avons besoin que via le PC pour concevoir de bonnes images d'interface utilisateur via le bouton d'options de la barre de menus, la zone de texte, les images d'arrière-plan et la page logique pour ajouter, puis générer des fichiers de configuration, le téléchargement sur l'écran d'affichage peut enfin être exécuté.

RTL8762C EVB Présentation

La carte d'évaluation 8762C fournit l'environnement matériel développé par le client, notamment :

  1. Module de conversion de puissance ;
  2. Capteur de mouvement 26 axes ;
  3. 4 LED et 6 boutons ;
  4. Pile bouton et support de pile au lithium ;
  5. Puce de conversion USB vers UART, FT232RL.

Évaluer la distribution des blocs de cartes et des interfaces
Une description détaillée du bloc de la carte d'évaluation
Distribution du bloc de la carte d'évaluation et de l'interface, voir la figure suivante :

Écran LCD pour tableau de bord de voiture Écran LCD pour tableau de bord de voiture

Les clés

Il y a un total de clés de réinitialisation et 5 ensembles de clés indépendantes,
comme le montre la figure suivante :

Écran LCD pour tableau de bord de voiture

La puce principale 8762 c

  • Conception GPIO flexible
  • Matériel Keyscan et décodeur
  • Émetteur-récepteur IR intégré
  • Compteur en temps réel (RTC)
  • Maître SPI/de x deux ; minuterie x 8 ; I2C x 2 ; PWM x 8 ; UART x 2
  • 400 ksps, 12 bits, AUXADC 8 canaux
  • Interface I2S pour codecs audio externes
  • Interface I8080 pour écran LCD
  • RCOSC 32K interne conserve les liens BLE
  • PGA et ADC audio intégrés avec égaliseur 5 bandes

STONE Étapes de développement de la boîte à outils

En général, il n'y a que trois étapes :

  1. en utilisant la conception de logiciels informatiques supérieurs TOOL2019 ;
  2. Développement de MCU et de communication d'écran ;
  3. production et importation de fichiers audio.

Installation de STONE OUTIL

L'OUTIL peut être téléchargé sur le site https://www.stoneitech.com, ainsi que le pilote série USB correspondant.

L'installation de la KEIL

1、Lien de téléchargement : https://pan.baidu.com/s/1smropvXeXKXw413W_-rvtw
2、Télécharger après décompression

Écran LCD pour tableau de bord de voiture

Ouvrez le dossier après décompression

Écran LCD pour tableau de bord de voiture

4、Double-cliquez sur le fichier c51v900. exe, puis cliquez sur Suivant dans la boîte de dialogue.

Écran LCD pour tableau de bord de voiture

STONE Conception de l'interface OUTIL 2019

À l'aide de l'OUTIL 2019 installé, cliquez sur le nouveau projet dans le coin supérieur gauche, puis cliquez sur OK.

Écran LCD pour tableau de bord de voiture

Un projet par défaut est généré avec un fond bleu par défaut. Sélectionnez-le, cliquez avec le bouton droit de la souris et sélectionnez Supprimer pour supprimer l'arrière-plan. Ensuite, cliquez avec le bouton droit sur le fichier image et cliquez sur ajouter pour ajouter votre propre arrière-plan d'image, comme :

Écran LCD pour tableau de bord de voiture

suit:

Écran LCD pour tableau de bord de voiture

Sélectionnez l'image d'arrière-plan correspondante.

De la même manière, nous ajoutons des fichiers bitmap et des fichiers audio au projet.

Écran LCD pour tableau de bord de voiture

Ajoutez ensuite les contrôles requis, voici principalement le contrôle de bouton, le contrôle d'addition et de soustraction numérique, le contrôle de variable de données.

Écran LCD pour tableau de bord de voiture

Configurez ensuite l'adresse de la variable de chaque commande, ici nous avons la configuration suivante :

  1. L'adresse du bouton de climatisation est configurée en 0x000C ;
  2. L'adresse du bouton de feux de route est configurée en tant que 0x000D ;
  3. l'adresse de numérotation abrégée est configurée en tant que 0x001B ;
  4. l'adresse de l'icône d'électricité est configurée comme 0x0018 ;
  5. l'adresse PM2.5 est configurée comme 0x001C ;

Lorsque le bouton est configuré, la figure suivante s'affiche une fois :

Écran LCD pour tableau de bord de voiture

  1. l'effet de pression sur le bouton de configuration ;
  2. configurer le contrôle de l'adresse de la variable, utilisée pour écrire sa valeur ;
  3. opérations de configuration plus ou moins ;
  4. configurer la plage de valeurs.

Lors de la configuration de la zone de texte numérique, la figure suivante s'affiche tour à tour :

Écran LCD pour tableau de bord de voiture

définir l'adresse de la variable de contrôle ;
définir le nombre de chiffres ;
définir la taille du nombre ;
définir le numéro de l'alignement.

Lors de la configuration du compteur de vitesse, la figure suivante montre tour à tour :

Écran LCD pour tableau de bord de voiture

Fichier de bibliothèque sélectionné ;
Quel fichier spécifier dans le fichier galerie ;
Définissez les coordonnées du centre autour de l'icône du pointeur ;
Définissez la plage de rotation du pointeur.
Définissez l'angle de rotation du pointeur.
Enfin, nous cliquons sur l'outil de configuration de construction.
Remarque :
Les boutons de contrôle sont associés à leurs bitmaps correspondants via des adresses variables, la cohérence est donc nécessaire pour obtenir un contrôle approprié.
Par conséquent, l'instruction du port série est la suivante :
Battery: 0xA5, 0x5A, 0x05, 0x82, 0x00, 0x18, 0x00, 0x00
Speed: 0xA5, 0x5A, 0x05, 0x82, 0x00, 0x1B, 0x00, 0x00
PM2.5: 0xA5, 0x5A, 0x05, 0x82, 0x00, 0x1C, 0x00, 0x00

Le développement de RTL8762C

Ouvrez KEIL et importez notre fichier de projet, comme illustré dans la figure suivante :

Écran LCD pour tableau de bord de voiture

Comme il s'agit de la première utilisation, l'algorithme FLASH doit être ajusté en conséquence :
Cliquez sur le bouton des options pour accéder à la boîte de configuration du téléchargement Flash et modifiez l'algorithme pour qu'il ressemble à la figure suivante.

Écran LCD pour tableau de bord de voiture

Étant donné que le bouton de contrôle est utilisé ici, les modifications suivantes doivent être apportées au code:

/**
* @file     main.c
* @brief    uart demo polling tx and rx.
* @details
* @author   wangzex
* @date     2018-06-28
* @version  v0.1
*********************************************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include
#include "rtl876x_nvic.h"
#include "rtl876x_pinmux.h"
#include "rtl876x_rcc.h"
#include "rtl876x_uart.h"
#include "trace.h"
#include "rtl876x_gpio.h"
#include "os_timer.h"
#include "os_sched.h"
/* Defines ------------------------------------------------------------------*/
#define UART_TX_PIN                P0_0//P4_0
#define UART_RX_PIN                P0_1//P4_1
/* Defines ------------------------------------------------------------------*/
#define GPIO_INPUT_PIN_BAT_UP           P4_0// KEY0
#define GPIO_BAT_UP_INPUT               GPIO_GetPin(GPIO_INPUT_PIN_BAT_UP)
#define GPIO_INPUT_PIN_BAT_DN           P4_1// KEY1
#define GPIO_BAT_DN_INPUT               GPIO_GetPin(GPIO_INPUT_PIN_BAT_DN)
#define GPIO_INPUT_PIN_SPEED_UP         P2_4//KEY2
#define GPIO_SPEED_UP_INPUT             GPIO_GetPin(GPIO_INPUT_PIN_SPEED_UP)
#define GPIO_INPUT_PIN_SPEED_DN         P2_3// KEY3
#define GPIO_SPEED_DN_INPUT             GPIO_GetPin(GPIO_INPUT_PIN_SPEED_DN)
#define GPIO_INPUT_PIN_SWITCH           P0_5//KEY4
#define GPIO_SWITCH_INPUT               GPIO_GetPin(GPIO_INPUT_PIN_SWITCH)
#define KEYSCAN_SW_INTERVAL             (165)/* 200ms */
#define KEYSCAN_SW_RELEASE_TIMEOUT      (10)/* 10ms */
uint8_t data_buf_bat[]     = {0xA5, 0x5A, 0x05, 0x82, 0x00, 0x18, 0x00, 0x00};
uint8_t data_buf_speed[]   = {0xA5, 0x5A, 0x05, 0x82, 0x00, 0x1B, 0x00, 0x00};
uint8_t data_buf_pm25[]    = {0xA5, 0x5A, 0x05, 0x82, 0x00, 0x1C, 0x00, 0x00};//the last byte is data
void *KeyScan_Timer_Handle = NULL;
void timer_keyscan_callback(void *p_xTimer)
{
uint8_t gpio_input_data_level = 0;
gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_BAT_UP_INPUT);//KEY0
DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
if(!gpio_input_data_level)
{
gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_SWITCH_INPUT);//KEY0
DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
if(!gpio_input_data_level)
{
data_buf_pm25[7] ++;
UART_SendData(UART, data_buf_pm25, 8);
}
else
{
data_buf_bat[7] ++;
UART_SendData(UART, data_buf_bat, 8);
}
}
gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_BAT_DN_INPUT);//KEY0
DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
if(!gpio_input_data_level)
{
gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_SWITCH_INPUT);//KEY0
DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
if(!gpio_input_data_level)
{
data_buf_pm25[7] --;
UART_SendData(UART, data_buf_pm25, 8);
}
else
{
data_buf_bat[7] --;
UART_SendData(UART, data_buf_bat, 8);
}
}
gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_SPEED_UP_INPUT);//KEY0
DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
if(!gpio_input_data_level)
{
data_buf_speed[7] ++;
UART_SendData(UART, data_buf_speed, 8);
}
gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_SPEED_DN_INPUT);//KEY0
DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
if(!gpio_input_data_level)
{
data_buf_speed[7] --;
UART_SendData(UART, data_buf_speed, 8);
}
//    gpio_input_data_level = GPIO_ReadInputDataBit(GPIO_PM25_INPUT);//KEY0
//    DBG_DIRECT("GPIO_BAT_UP_INPUT = %d\n", gpio_input_data_level);
//    if(!gpio_input_data_level)
//    {
//        data_buf_pm25[7] --;
//        UART_SendData(UART, data_buf_pm25, 8);
//    }
os_timer_restart(&KeyScan_Timer_Handle, KEYSCAN_SW_INTERVAL);
}
void timer_keyscan_init(void)
{
DBG_DIRECT("[io_keyscan] timer_keyscan_init: keyscan timer init");
if (false == os_timer_create(&KeyScan_Timer_Handle, "keyscan_timer",  1, \
KEYSCAN_SW_INTERVAL, false, timer_keyscan_callback))
{
DBG_DIRECT("[io_keyscan] timer_keyscan_init: timer creat failed!");
}
os_timer_start(&KeyScan_Timer_Handle);
}
/** @brief  UART_BaudRate_Table
*         div ovsr ovsr_adj :These three parameters set the baud rate calibration parameters of UART.
baudrate    |   div     |   ovsr    |   ovsr_adj
--------------------------------------------------------
1200Hz      |   2589    |   7       |   0x7F7
9600Hz      |   271     |   10      |   0x24A
14400Hz     |   271     |   5       |   0x222
19200Hz     |   165     |   7       |   0x5AD
28800Hz     |   110     |   7       |   0x5AD
38400Hz     |   85      |   7       |   0x222
57600Hz     |   55      |   7       |   0x5AD
76800Hz     |   35      |   9       |   0x7EF
115200Hz    |   20      |   12      |   0x252
128000Hz    |   25      |   7       |   0x555
153600Hz    |   15      |   12      |   0x252
230400Hz    |   10      |   12      |   0x252
460800Hz    |   5       |   12      |   0x252
500000Hz    |   8       |   5       |   0
921600Hz    |   4       |   5       |   0x3F7
1000000Hz   |   4       |   5       |   0
1382400Hz   |   2       |   9       |   0x2AA
1444400Hz   |   2       |   8       |   0x5F7
1500000Hz   |   2       |   8       |   0x492
1843200Hz   |   2       |   5       |   0x3F7
2000000Hz   |   2       |   5       |   0
2100000Hz   |   1       |   14      |   0x400
2764800Hz   |   1       |   9       |   0x2AA
3000000Hz   |   1       |   8       |   0x492
3250000Hz   |   1       |   7       |   0x112
3692300Hz   |   1       |   5       |   0x5F7
3750000Hz   |   1       |   5       |   0x36D
4000000Hz   |   1       |   5       |   0
6000000Hz   |   1       |   1       |   0x36D
-----------------------------------------------------
*/ /* End of UART_BaudRate_Table */
/* Globals ------------------------------------------------------------------*/
typedef struct
{
uint16_t div;
uint16_t ovsr;
uint16_t ovsr_adj;
} UART_BaudRate_TypeDef;
const UART_BaudRate_TypeDef BaudRate_Table[10] =
{
{271, 10, 0x24A}, // BAUD_RATE_9600
{165, 7,  0x5AD}, // BAUD_RATE_19200
{20,  12, 0x252}, // BAUD_RATE_115200
{10,  12, 0x252}, // BAUD_RATE_230400
{5,   12, 0x252}, // BAUD_RATE_460800
{4,   5,  0x3F7}, // BAUD_RATE_921600
{2,   5,  0},     // BAUD_RATE_2000000
{1,   8,  0x492}, // BAUD_RATE_3000000
{1,   5,  0},     // BAUD_RATE_4000000
{1,   1,  0x36D}, // BAUD_RATE_6000000
};
void board_gpio_init(void)
{
Pad_Config(GPIO_INPUT_PIN_BAT_UP, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE,
PAD_OUT_HIGH);
Pinmux_Config(GPIO_INPUT_PIN_BAT_UP, DWGPIO);
Pad_Config(GPIO_INPUT_PIN_BAT_DN, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE,
PAD_OUT_HIGH);
Pinmux_Config(GPIO_INPUT_PIN_BAT_DN, DWGPIO);
Pad_Config(GPIO_INPUT_PIN_SPEED_UP, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE,
PAD_OUT_HIGH);
Pinmux_Config(GPIO_INPUT_PIN_SPEED_UP, DWGPIO);
Pad_Config(GPIO_INPUT_PIN_SPEED_DN, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE,
PAD_OUT_HIGH);
Pinmux_Config(GPIO_INPUT_PIN_SPEED_DN, DWGPIO);
Pad_Config(GPIO_INPUT_PIN_SWITCH, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE,
PAD_OUT_HIGH);
Pinmux_Config(GPIO_INPUT_PIN_SWITCH, DWGPIO);
}
uint8_t String_Buf[100];
/**
* @brief  Initialization of pinmux settings and pad settings.
* @param  No parameter.
* @return void
*/
void board_uart_init(void)
{
Pad_Config(UART_TX_PIN, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE, PAD_OUT_HIGH);
Pad_Config(UART_RX_PIN, PAD_PINMUX_MODE, PAD_IS_PWRON, PAD_PULL_UP, PAD_OUT_DISABLE, PAD_OUT_HIGH);
Pinmux_Config(UART_TX_PIN, UART0_TX);
Pinmux_Config(UART_RX_PIN, UART0_RX);
}
/**
* @brief  Initialize GPIO peripheral.
* @param  No parameter.
* @return void
*/
void driver_gpio_init(void)
{
/* Initialize GPIO peripheral */
RCC_PeriphClockCmd(APBPeriph_GPIO, APBPeriph_GPIO_CLOCK, ENABLE);
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_StructInit(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin    = GPIO_INPUT_PIN_BAT_UP;
GPIO_InitStruct.GPIO_Mode   = GPIO_Mode_IN;
GPIO_InitStruct.GPIO_ITCmd  = DISABLE;
GPIO_Init(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin    = GPIO_INPUT_PIN_BAT_DN;
GPIO_Init(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin    = GPIO_INPUT_PIN_SPEED_UP;
GPIO_Init(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin    = GPIO_INPUT_PIN_SPEED_DN;
GPIO_Init(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin    = GPIO_INPUT_PIN_SWITCH;
GPIO_Init(&GPIO_InitStruct);
}
/**
* @brief  Demo code of operation about gpio.
* @param  No parameter.
* @return void
*/
void gpio_demo(void)
{
/* Configure pad and pinmux firstly! */
board_gpio_init();
/* Initialize gpio peripheral */
driver_gpio_init();
}
/**
* @brief  Initialize uart peripheral.
* @param  No parameter.
* @return void
*/
void driver_uart_init(void)
{
UART_DeInit(UART);
RCC_PeriphClockCmd(APBPeriph_UART0, APBPeriph_UART0_CLOCK, ENABLE);
/* uart init */
UART_InitTypeDef UART_InitStruct;
UART_StructInit(&UART_InitStruct);
/* Config uart baudrate */
UART_InitStruct.div            = BaudRate_Table[BAUD_RATE_115200].div;
UART_InitStruct.ovsr           = BaudRate_Table[BAUD_RATE_115200].ovsr;
UART_InitStruct.ovsr_adj       = BaudRate_Table[BAUD_RATE_115200].ovsr_adj;
UART_InitStruct.parity         = UART_PARITY_NO_PARTY;
UART_InitStruct.stopBits       = UART_STOP_BITS_1;
UART_InitStruct.wordLen        = UART_WROD_LENGTH_8BIT;
UART_InitStruct.rxTriggerLevel = 16;                      //1~29
UART_InitStruct.idle_time      = UART_RX_IDLE_2BYTE;      //idle interrupt wait time
UART_Init(UART, &UART_InitStruct);
}
/**
* @brief  UARt send data continuous.
* @param  No parameter.
* @return void
*/
void uart_senddata_continuous(UART_TypeDef *UARTx, const uint8_t *pSend_Buf, uint16_t vCount)
{
uint8_t count;
while (vCount / UART_TX_FIFO_SIZE > 0)
{
while (UART_GetFlagState(UARTx, UART_FLAG_THR_EMPTY) == 0);
for (count = UART_TX_FIFO_SIZE; count > 0; count--)
{
UARTx->RB_THR = *pSend_Buf++;
}
vCount -= UART_TX_FIFO_SIZE;
}
while (UART_GetFlagState(UARTx, UART_FLAG_THR_EMPTY) == 0);
while (vCount--)
{
UARTx->RB_THR = *pSend_Buf++;
}
}
/**
* @brief  Demo code of uart.
* @param  No parameter.
* @return void
*/
void uart_demo(void)
{
uint16_t demo_str_len = 0;
//    uint8_t rx_byte = 0;
board_uart_init();
driver_uart_init();
char *demo_str = "### Uart demo polling read uart data ###\r\n";
demo_str_len = strlen(demo_str);
memcpy(String_Buf, demo_str, demo_str_len);
/* Send demo tips */
uart_senddata_continuous(UART, String_Buf, demo_str_len);
/* Loop rx and tx */
//    while (1)
//    {
//        if (UART_GetFlagState(UART, UART_FLAG_RX_DATA_RDY) == SET)
//        {
//            rx_byte = UART_ReceiveByte(UART);
//            UART_SendByte(UART, rx_byte);
//        }
//    }
}
/**
* @brief    Entry of app code
* @return   int (To avoid compile warning)
*/
int main(void)
{
uart_demo();
gpio_demo();
timer_keyscan_init();
os_sched_start();
return 0;
}

Enfin, connectez simplement le MCU à l'écran LCD du port série LCD pour le tableau de bord de la voiture
et connectez le haut-parleur pour démontrer.

Écran LCD pour tableau de bord de voiture

Remonter en haut