S32K144 UART通讯

目录

一、UART工作原理：

1.帧格式：​编辑

２.奇偶校验位：

３.FIFO、DATA 数据寄存器、移位寄存器完整数据流

３.１开启FIFO：

３.２关闭FIFO：

４.通讯过程：

二、S32K44 UART通讯：

1.主要寄存器说明：

BAUD：

CTRL：

STAT：

DATA：

2.三种通讯方式：

2.1.使用DATA寄存器未使用FIFO通讯：

clock.c

uart.c

uart.h

main.c

io.c

2.2.使用DATA寄存器且使用FIFO通讯：

2.3.使用FIFO轮询通讯：

一、UART工作原理：

UART是一种通用串行数据总线，用于异步通信。该总线双向通信，可以实现全双工传输和接收

⑴输出缓冲寄存器，它接收CPU从数据总线上送来的并行数据，并加以保存。uart基本结构

⑵ 输出移位寄存器，它接收从输出缓冲器送来的并行数据，以发送时钟的速率把数据逐位移出，即将并行数据转换为串行数据输出。

⑶ 输入移位寄存器，它以接收时钟的速率把出现在串行数据输入线上的数据逐位移入，当数据装满后，并行送往输入缓冲寄存器，即将串行数据转换成并行数据。

⑷ 输入缓冲寄存器，它从输入移位寄存器中接收并行数据，然后由CPU取走。

⑸控制寄存器，它接收CPU送来的控制字，由控制字的内容，决定通信时的传输方式以及数据格式等。例如采用异步方式还是同步方式，数据字符的位数，有无奇偶校验，是奇校验还是偶校验，停止位的位数等参数。

⑹状态寄存器。状态寄存器中存放着接口的各种状态信息，例如输出缓冲区是否空，输入字符是否准备好等。在通信过程中，当符合某种状态时，接口中的状态检测逻辑将状态寄存器的相应位置"1"，以便让CPU查询。

1.帧格式：

• 起始位：当有数据要发送时，数据信号线变成低电平，并持续一段时间，用于表示字符的开始，这一位称为起始位。

• 数据位：紧接着起始位之后。在信号线上会依次出现待发送的每一位字符，最低有效位D0最先出现，因此它最早被发送出去。采用不同的编码方案，数据位的个数不同，数据位的个数可以是4、5、6、7、8等；当字符用ASCII码表示时，数据位占7位（D0~D7）。

• 奇偶校验位：数据位加上这一位后，使得“1”的位数应为偶数(偶校验)或奇数(奇校验)，以此来校验资料传送的正确性，例如数据传输采用奇校验时，如果数据“1”的个数是奇数，这一位就被置为“0”，反之置为“1”。当然系统中也可以不采用奇偶校验。

• 停止位：它是一个字符数据的结束标志。可以是1位、1.5位、2位的高电平。 由于数据是在传输线上定时的，并且每一个设备有其自己的时钟，很可能在通信中两台设备间出现了小小的不同步。因此停止位不仅仅是表示传输的结束，并且提供计算机校正时钟同步的机会。适用于停止位的位数越多，不同时钟同步的容忍程度越大，但是数据传输率同时也越慢。奇偶校验位的后面至少应该有一位高电平表示停止位，如果传输完一个字符后立即传输下一个字符，那么后一个字符的起始位就紧跟着前一个字符的停止位，否则停止位后又进入一个空闲状态。

• 空闲位：处于逻辑“1”状态，表示当前线路上没有数据传送。

２.奇偶校验位：

在异步串行通信中，如何知道一个字节的传输是否正确的？最常见的方法是增加一个位（奇偶校验位），供错误检测使用。字符奇偶校验检查（Character Parity Checking，CPC）也称为垂直冗余检查（Vertical Redundancy Checking，VRC），它为每个字节增加一个额外位，使字节中 1 的个数为奇数或偶数，奇数或偶数依据使用的是奇校验检查还是偶校验检查而定。

当使用奇校验检查时，如果字节数据位中 1 的数目是偶数，校验位应为 1，如果 1 的数目是奇数，校验位应为 0；当使用偶校验检查时，如果字符数据位中 1 的数目是偶数，则校验位应为 0，否则为 1。这里列举奇偶校验检查的一个实例，如 ASCII 字符 R，其二进制数为 1010010。由于字符 R 中有 3 个位为 1，若使用奇校验检查，则校验位为 0；若使用偶校验检查，则校验位为 1。

在传输过程中，若有 1 位（或奇数个数据位）发生错误，使用奇偶校验检查可以知道发生传输错误；若有 2 位（或偶数个数据位）发生错误，使用奇偶校验检查就不能知道已经发生了传输错误。但是奇偶校验检查方法简单，使用方便，发生 1 位错误的概率远大于 2 位的概率，所以奇偶校验这种方法还是最为常用的校验方法。

几乎所有 MCU 的串行异步通信接口都提供这种功能。但实际编程使用较少，原因是单字节校验意义不大。

３.FIFO、DATA 数据寄存器、移位寄存器完整数据流

• DATA 寄存器（TDR 发送 / RDR 接收，软件唯一交互入口） CPU 通过 APB 总线读写，只有这个寄存器有内存地址，代码直接操作；发送 / 接收共用同一寄存器地址，硬件内部物理分离。
• 硬件 FIFO（TX_FIFO/RX_FIFO，可选缓存队列） 多字节硬件缓冲区（常见 8/16/32 字节），DATA ↔ 移位寄存器中间缓冲层；无 FIFO 时直接 DATA↔移位寄存器。
• 移位寄存器（Tx Shift Reg / Rx Shift Reg，底层串行转换单元） 无软件地址，硬件私有；负责并行字节 ↔ 串行比特流转换，逐位输出 / 采样 TX/RX 引脚。

３.１开启FIFO：

发送：

CPU 写 TDR (DATA) → TX_FIFO → Tx 移位寄存器 → TX 引脚串行输出

1. CPU 轮询 / 中断判断 TXFIFO 未满，执行代码写入字节到TDR（DATA 发送寄存器）
2. 硬件自动把 TDR 内数据移入TX_FIFO，立刻释放 TDR，CPU 可继续写下一字节
3. TX_FIFO 非空时，硬件持续从 FIFO 头部取出 1 字节送入Tx 移位寄存器
4. 移位寄存器按波特率时钟，逐比特输出起始位 + 数据位 + 校验 + 停止位到 TX 引脚
5. 单字节发完后，移位寄存器清空；若 TX_FIFO 仍有数据，自动重复步骤 3 继续发送
6. 触发条件：TX_FIFO 达到空阈值时，置 TXE/TC 标志，通知 CPU 填充更多数据

接收：

RX 引脚采样比特 → Rx 移位寄存器 → RX_FIFO → RDR (DATA) → CPU 读取

1. RX 引脚检测起始位下降沿，波特率时钟逐位采样电平存入Rx 移位寄存器
2. 收满完整 1 字节（含校验校验）后，硬件并行送入RX_FIFO，移位寄存器立刻清空，可继续收下一帧
3. RX_FIFO 持续缓存多字节；当缓存字节达到中断触发阈值（如 1/4 满、半满），置 RXNE 中断标志
4. CPU 响应中断，循环读取RDR（DATA 接收寄存器），批量取出 FIFO 内所有数据
5. 全部读取后 RX_FIFO 空位释放，继续缓存后续接收字节

３.２关闭FIFO：

发送：

CPU 写 TDR (DATA) → Tx 移位寄存器 → TX 引脚

1. CPU 等待TXE=1（TDR 为空），写入数据到 TDR
2. 硬件瞬间将 TDR 字节载入 Tx 移位寄存器，TDR 变空，TXE 标志置 1
3. 移位寄存器逐位串行输出；移位寄存器发完前，TDR 不能送入下一字节，否则阻塞、丢帧

接收：

RX 引脚采样比特 → Rx 移位寄存器 → RDR (DATA) → CPU 读取

1. 移位寄存器收满 1 字节，立刻并行拷贝至 RDR（DATA），置RXNE=1
2. CPU 必须在下一字节收完前读取 RDR；若未及时读取，新字节会覆盖 RDR，产生数据溢出丢失
3. 读取 RDR 硬件自动清零 RXNE 标志，移位寄存器继续接收下一帧

概要：

·移位寄存器永远是最底层，所有数据最终都要经过它才能进出引脚，不受 FIFO 开关影响；

·DATA 寄存器是 CPU 唯一入口，FIFO 只是中间缓冲，没有 FIFO 时 DATA 直接对接移位寄存器；

·无 FIFO 风险：每收发 1 字节就要进一次中断，若接收方接受慢、发送方发送快，外部高速数据流持续从 RX 引脚输入；移位寄存器正在组装新的一字节；此时 RDR（DATA 寄存器）里还存放着上一帧未被 CPU 读取的数据；新字节组装完成后，硬件无处存放新数据，直接触发溢出（Overrun），新字节被丢弃，产生丢数，即高速串口极易丢数据。开启 FIFO 支持批量收发，中断次数大幅减少，开启 FIFO 后会提供 8/16/32 字节硬件缓存： 就算 CPU 临时处理缓慢，新数据可以先存入 FIFO 队列，给 CPU 留出批量读取的缓冲时间，大幅降低溢出丢包概率。

·发送方向：TDR 写完先进 FIFO，再给移位寄存器；接收方向：移位寄存器收完先进 FIFO，CPU 再从 DATA 读 FIFO 数据；

·移位寄存器、FIFO 均无寄存器映射地址，程序员代码中只能操作 DATA 寄存器。

·发送：CPU 写 DATA → FIFO 缓存 → 移位逐位发 TX

·接收：RX 采样进移位 → FIFO 缓存 → CPU 读 DATA 取数据

FIFO 是蓄水池，DATA 是门窗，移位寄存器是搬运比特的底层流水线。

４.通讯过程：

UART发送数据时先发低位后发高位。当总线处于空闲状态时，线路保持高电平。以发送数据0x96为例，发送数据前会先发一个0，让总线从高电平变成低电平，提醒数据接收方做好准备，然后依次从低位到高位发送八位数据。传输完成后，会发一个1，让总线重新回到高电平。

UART数据发送过程中，包含8位数据位，一位起始位，一位停止位。一共10位。如若需要发送新的数据，则重新从起始位开始。

UART属于异步通讯，这意味着没有时钟信号，取而代之的是在数据包中添加开始和停止位。这些位定义了数据包的开始和结束，因此接收UART知道何时读取这些数据。

个人理解：单片机设备和PC串口调试通讯时：

1.单片机发送字符串：发送前，STAT寄存器发送bit状态为空，此时往DATA寄存器上写一个字符，即发送了一个字符，STAT寄存器发送bit状态变为满；此时，PC串口调试助手，马上就收一个字符，STAT寄存器发送bit状态变为空，依次

2.单片机接受字符：接受前，STAT寄存器接受bit为满，从DATA寄存器读取一个字符后，STAT寄存器接受bit变为空。此时，PC串口调试助手检测到STAT发送bit状态为空，马上又发送一个字符，STAT寄存器接受bit变为满，依次

二、S32K44 UART通讯：

备注：各位读者在以下代码有什么问题（比如：时钟为什么要这样设置、引脚为什么这样设置、波特率这样计算等）都可以留言提出来，我会一一解答，因为我在自己摸索过程中也踩雷不少，希望借该文章对同行尽力所能及的帮助。

1.主要寄存器说明：

BAUD：

备注：UART 是异步串行通信，收发双方没有共享时钟线，完全依靠约定相同波特率来同步每一位的采样时刻： 接收端按固定时间间隔（波特率倒数）对 RX 引脚电平采样； 一旦波特率不同，采样点会持续偏移，最终解析不出正确字节。

配置生成波特率

CTRL：

是能串口功能

STAT：

判断通讯是否可以进行

DATA：

数据收发

2.三种通讯方式：

2.1.使用DATA寄存器未使用FIFO通讯：

使用中断方式接受数据，直接往DATA写数据进行发送。源码如下，读者可以直接复制使用：

clock.c

#include "S32K144.h"

void SOSC_init_8MHz(void) {
  SCG->SOSCDIV=0x00000101;  /* SOSCDIV1 & SOSCDIV2 =1: divide by 1 */
  SCG->SOSCCFG=0x00000024;  /* Range=2: Medium freq (SOSC betw 1MHz-8MHz)*/
                            /* HGO=0:   Config xtal osc for low power */
                            /* EREFS=1: Input is external XTAL */
  while(SCG->SOSCCSR & SCG_SOSCCSR_LK_MASK); /* Ensure SOSCCSR unlocked */
  SCG->SOSCCSR=0x00000001;  /* LK=0:          SOSCCSR can be written */
                            /* SOSCCMRE=0:    OSC CLK monitor IRQ if enabled */
                            /* SOSCCM=0:      OSC CLK monitor disabled */
                            /* SOSCERCLKEN=0: Sys OSC 3V ERCLK output clk disabled */
                            /* SOSCLPEN=0:    Sys OSC disabled in VLP modes */
                            /* SOSCSTEN=0:    Sys OSC disabled in Stop modes */
                            /* SOSCEN=1:      Enable oscillator */
  while(!(SCG->SOSCCSR & SCG_SOSCCSR_SOSCVLD_MASK)); /* Wait for sys OSC clk valid */
}
void SPLL_init_160MHz(void) {
  while(SCG->SPLLCSR & SCG_SPLLCSR_LK_MASK); /* Ensure SPLLCSR unlocked */
  SCG->SPLLCSR = 0x00000000;  /* SPLLEN=0: SPLL is disabled (default) */
  SCG->SPLLDIV = 0x00000302;  /* SPLLDIV1 divide by 2; SPLLDIV2 divide by 4 */
  SCG->SPLLCFG = 0x00180000;  /* PREDIV=0: Divide SOSC_CLK by 0+1=1 */
                              /* MULT=24:  Multiply sys pll by 16 + 24=40 */
                              /* SPLL_CLK = 8MHz / 1 * 40 / 2 = 160 MHz */
  while(SCG->SPLLCSR & SCG_SPLLCSR_LK_MASK); /* Ensure SPLLCSR unlocked */
  SCG->SPLLCSR = 0x00000001; /* LK=0:        SPLLCSR can be written */
                             /* SPLLCMRE=0:  SPLL CLK monitor IRQ if enabled */
                             /* SPLLCM=0:    SPLL CLK monitor disabled */
                             /* SPLLSTEN=0:  SPLL disabled in Stop modes */
                             /* SPLLEN=1:    Enable SPLL */
  while(!(SCG->SPLLCSR & SCG_SPLLCSR_SPLLVLD_MASK)); /* Wait for SPLL valid */
}

void NormalRUNmode_80MHz (void) {  /* Change to normal RUN mode with 8MHz SOSC, 80 MHz PLL*/
  SCG->RCCR=SCG_RCCR_SCS(6)      /* PLL as clock source*/
    |SCG_RCCR_DIVCORE(0b01)      /* DIVCORE=1, div. by 2: Core clock = 160/2 MHz = 80 MHz*/
    |SCG_RCCR_DIVBUS(0b01)       /* DIVBUS=1, div. by 2: bus clock = 40 MHz*/
    |SCG_RCCR_DIVSLOW(0b10);     /* DIVSLOW=2, div. by 2: SCG slow, flash clock= 26 2/3 MHz*/
  if ((SCG->CSR & SCG_CSR_SCS_MASK >> SCG_CSR_SCS_SHIFT ) != 6) {}
                                 /* Wait for sys clk src = SPLL */
}

void init_clks_80MHz(void)
{
//  SMC->PMPROT   = SMC_PMPROT_AVLP_MASK;  //allow VLPS mode
//  SMC->STOPCTRL = SMC_STOPCTRL_STOPO(1); //1:BOTH system and bus clock disable;2:system clock disable, bus clock enabled
//  SMC->PMCTRL   = 0x00000002;//+ SMC_PMCTRL_RUNM_MASK;  //select very-low-power stop
//  while (!(SMC->PMSTAT & 1)){ ; }                      //wait RUN ok.

    SOSC_init_8MHz();
    SPLL_init_160MHz();
    NormalRUNmode_80MHz();
}

uart.c

/*
 * LPUART.c              Copyright NXP 2016
 * Description: LPUART functions
 * 2015 Sept 28 Kushal Shaw - original version AN5213;
 * 2016 Mar 17  O Romero - ported to S32K144;
 * 2017 Jul 03 SM: Correced "receive" spelling for function
 */

#include "S32K144.h" /* include peripheral declarations S32K144 */
#include "uart.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>

UART_DATA_t uart_data;

/*
数据位：8bit                     优化：其他bit数据通讯7、9、10
停止位：1bit                     优化：2bit停止位
校验位：disable                  优化：开启奇偶检验
数据通讯方式：UART模块DATA寄存器  优化：1.DMA；2.FIFO 轮询；3.FIFO中断1字节或者N字节中断
实验：
1.LPUART_s32K144工程循环收1个字节，看是否能接收字符串
2.在lpuart_echo_s32k144工程上改变接收长度1->N看是否能接收字符串
3.在lpuart_echo_s32k144工程上改变数据位、停止位、校验位通讯
4.优化当前代码，通过参数输入选择数据位、停止位、校验位、通讯方式进行正常通讯
*/
void set_baud(void)
{
    // look for best suitable BAUD
    U32 osr = 4, tempDiff, calculatedBaud, baudDiff;
    U16 sbr, sbrTemp, i;

    // First calculate the baud rate using the minimum OSR possible
    sbr = (uint16_t)(8000000 / (115200 * osr));
    calculatedBaud = (8000000 / (osr * sbr));

    if (calculatedBaud > 115200)
    {
        baudDiff = calculatedBaud - 115200;
    }
    else
    {
        baudDiff = 115200 - calculatedBaud;
    }

    /* loop to find the best osr value possible, one that generates minimum baudDiff
     * iterate through the rest of the supported values of osr */
    for (i = 5U; i <= 32U; i++)
    {
        /* calculate the temporary sbr value   */
        sbrTemp = (uint16_t)(8000000 / (115200 * i));
        /* calculate the baud rate LPUART1d on the temporary osr and sbr values */
        calculatedBaud = (8000000 / (i * sbrTemp));

        if (calculatedBaud > 115200)
        {
            tempDiff = calculatedBaud - 115200;
        }
        else
        {
            tempDiff = 115200 - calculatedBaud;
        }

        if (tempDiff <= baudDiff)
        {
            baudDiff = tempDiff;
            osr = i;  /* update and store the best osr value calculated */
            sbr = sbrTemp;  /* update store the best sbr value calculated */
        }
    }
    /* Check if osr is between 4x and 7x oversampling.
     * If so, then "BOTHEDGE" sampling must be turned on */
    if ((osr > 3U) && (osr < 8U))
    {
        LPUART1->BAUD |= (LPUART1->BAUD & ~LPUART_BAUD_BOTHEDGE_MASK) | (1 << LPUART_BAUD_BOTHEDGE_SHIFT);
    }

    /* program the osr value (bit value is one less than actual value) */
//    LPUART1->BAUD &= ~(LPUART_BAUD_OSR_MASK);
    tempDiff = LPUART1->BAUD;
    tempDiff &= ~(LPUART_BAUD_OSR_MASK);
    tempDiff |= LPUART_BAUD_OSR(osr - 1);
    LPUART1->BAUD = tempDiff;
//    LPUART1->BAUD &= ~(0x1f << 24);
//    LPUART1->BAUD |= (osr - 1) << 24;

    /* write the sbr value to the BAUD registers */
    LPUART1->BAUD &= ~(LPUART_BAUD_SBR_MASK);
    LPUART1->BAUD |= sbr << 0;
}

void LPUART1_init(void)  /* Init. summary: 9600 baud, 1 stop bit, 8 bit format, no parity */
{
  PCC->PCCn[PCC_LPUART1_INDEX] &= ~PCC_PCCn_CGC_MASK;    /* Ensure clk disabled for config */
  PCC->PCCn[PCC_LPUART1_INDEX] |= PCC_PCCn_PCS(0b001)    /* Clock Src= 1 (SOSCDIV2_CLK) */
                               |  PCC_PCCn_CGC_MASK;     /* Enable clock for LPUART1 regs */
  set_baud();
  //LPUART1->BAUD = 0x0F000034;  /* Initialize for 9600 baud, 1 stop: */
                               /* SBR=52 (0x34): baud divisor = 8M/9600/16 = ~52 */
                               /* OSR=15: Over sampling ratio = 15+1=16 */
                               /* SBNS=0: One stop bit */
                               /* BOTHEDGE=0: receiver samples only on rising edge */
                               /* M10=0: Rx and Tx use 7 to 9 bit data characters */
                               /* RESYNCDIS=0: Resync during rec'd data word supported */
                               /* LBKDIE, RXEDGIE=0: interrupts disable */
                               /* TDMAE, RDMAE, TDMAE=0: DMA requests disabled */
                               /* MAEN1, MAEN2,  MATCFG=0: Match disabled */

  LPUART1->CTRL=0x000C0000;    /* Enable transmitter & receiver, no parity, 8 bit char: */
                               /* RE=1: Receiver enabled */
                               /* TE=1: Transmitter enabled */
                               /* PE,PT=0: No hw parity generation or checking */
                               /* M7,M,R8T9,R9T8=0: 8-bit data characters*/
                               /* DOZEEN=0: LPUART enabled in Doze mode */
                               /* ORIE,NEIE,FEIE,PEIE,TIE,TCIE,RIE,ILIE,MA1IE,MA2IE=0: no IRQ*/
                               /* TxDIR=0: TxD pin is input if in single-wire mode */
                               /* TXINV=0: TRansmit data not inverted */
                               /* RWU,WAKE=0: normal operation; rcvr not in statndby */
                               /* IDLCFG=0: one idle character */
                               /* ILT=0: Idle char bit count starts after start bit */
                               /* SBK=0: Normal transmitter operation - no break char */
                               /* LOOPS,RSRC=0: no loop back */
    // Enable LPUART interrupt.
	S32_NVIC->ISER[(uint32_t)(LPUART1_RxTx_IRQn) >> 5U] = (uint32_t)(1UL << ((uint32_t)(LPUART1_RxTx_IRQn) & (uint32_t)0x1FU));
}

void LPUART1_transmit_char(char send) {    /* Function to Transmit single Char */
	while((LPUART1->STAT & LPUART_STAT_TDRE_MASK)>>LPUART_STAT_TDRE_SHIFT==0);
								   /* Wait for transmit buffer to be empty */
	LPUART1->DATA=send;              /* Send data */
}

void LPUART1_transmit_string(char data_string[])  {  /* Function to Transmit whole string */
	uint32_t i=0;
	while(data_string[i] != '\0')  {           /* Send chars one at a time */
		LPUART1_transmit_char(data_string[i]);
		i++;
	}
}

char LPUART1_receive_char(void) {    /* Function to Receive single Char */
	char recieve;
	while((LPUART1->STAT & LPUART_STAT_RDRF_MASK)>>LPUART_STAT_RDRF_SHIFT==0);
									 /* Wait for received buffer to be full */
	recieve= LPUART1->DATA;          /* Read received data*/
	return recieve;
}

void LPUART1_receive_and_echo_char(void)  {  /* Function to echo received char back */
	char send[RECV_LEN + 2] = {0};
	char buf[RECV_LEN + 2] = {0};
	short i = 0;

	if ((LPUART1->STAT >> LPUART_STAT_RDRF_SHIFT) || (LPUART1->CTRL >> LPUART_CTRL_RIE_SHIFT)) {
		// err
		buf[i++] = LPUART1->DATA; // 读数据清RDRF，兜底
		LPUART1_transmit_string(buf);
	}

	for (i = 0; i < RECV_LEN; i++) {
	  buf[i] = 'a';
	}
	uart_data.rxBuff = send;
	uart_data.rxSize = RECV_LEN + 2; // 2用于存放\r\n两字符

	LOG("start recv! recvlen:%d, out:0x%x, str:%s\n", 1048574, 0x12345678, buf);

	/* Enable receive data full interrupt */
	LPUART1->CTRL |= 1 << LPUART_CTRL_RIE_SHIFT;
	while (uart_data.rxSize);
    if (!strncmp(send, buf, strlen(buf))) {
    	LPUART1_transmit_string("罗紫屹努力考701\r\n");
    }
}

void LPUART1_RxTx_IRQHandler(void)
{
    UART_DATA_t *data_type = &uart_data;

    /* Handle receive data full interrupt */
    if (LPUART1->CTRL >> LPUART_CTRL_RIE_SHIFT)
    {
        if (LPUART1->STAT >> LPUART_STAT_RDRF_SHIFT)
        {
            /* Get data and put in receive buffer  */
            // 8 bit per char, 9 and 10bit ??? TODO:
            *data_type->rxBuff = (U8)LPUART1->DATA;

            /* Update the internal state */
			++data_type->rxBuff;
			--data_type->rxSize;

            /* Finish reception if this was the last byte received */
            if (data_type->rxSize == 0U)
            {
                /* Complete transfer, will disable rx interrupt */
                LPUART1->CTRL &= ~(1 << LPUART_CTRL_RIE_SHIFT) ;
            }
        }
    }
}

void DecToChar(U8 *num)
{
	assert(num);
	U8  HexChar[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	if (*num == 0) {
		*num = HexChar[0];
	} else if (*num == 1) {
		*num = HexChar[1];
	} else if (*num == 2) {
		*num = HexChar[2];
	} else if (*num == 3) {
		*num = HexChar[3];
	} else if (*num == 4) {
		*num = HexChar[4];
	} else if (*num == 5) {
		*num = HexChar[5];
	} else if (*num == 6) {
		*num = HexChar[6];
	} else if (*num == 7) {
		*num = HexChar[7];
	} else if (*num == 8) {
		*num = HexChar[8];
	} else if (*num == 9) {
		*num = HexChar[9];
	} else if (*num == 10) {
		*num = HexChar[10];
	} else if (*num == 11) {
		*num = HexChar[11];
	} else if (*num == 12) {
		*num = HexChar[12];
	} else if (*num == 13) {
		*num = HexChar[13];
	} else if (*num == 14) {
		*num = HexChar[14];
	} else if (*num == 15) {
		*num = HexChar[15];
	}
}

void DecToHexStr(U32 DecNum, U8 *dest, U16 *index)
{
	U32 HexI = 1;
	U8	HexP = 0;
	U8  str[9] = {0};
	U8  i = 0;
	U8  len;

	while (HexI > 0) {
		HexI = DecNum / 16;
		HexP = DecNum % 16;
		DecNum = HexI;
		DecToChar(&HexP);
		str[i++] = HexP;
	}
	len = strlen(str);
	for (i = 0; str[i] != 0; i++) {
		*dest++ = str[len - 1 - i];
		*index += 1;
	}
}

void self_printf(const U8* format, ...)
{
	va_list ap;
	U16 i = 0;
	U8 buf[1024] = {0};

	va_start(ap, format);
	while (*format != 0) {
		if (*format == '%') {
			if (*(format + 1) == 'c') {
				buf[i++] = va_arg(ap, char);
			} else if (*(format + 1) == 'd') {
				sprintf(&buf[i], "%u", va_arg(ap, U32));
				i += strlen(&buf[i]);
			} else if (*(format + 1) == 'x') {
//				sprintf(&buf[i], "%x", va_arg(ap, U32));
//				i += strlen(&buf[i]);
				DecToHexStr(va_arg(ap, int), &buf[i], &i);
			} else if (*(format + 1) == 's') {
				strcpy(&buf[i], (char *)va_arg(ap, U32));
				i += strlen(&buf[i]);
			} else if (*(format + 1) == 'p') {

			}
			format += 2;
		} else {
			buf[i++] = *format++;
		}
	}
	buf[i] = 0;
	LPUART1_transmit_string(buf);
}

uart.h

/*
 * LPUART.h
 *
 *  Created on: Mar 17, 2016
 *      Author: B46911
 */

#ifndef LPUART_H_
#define LPUART_H_

#include "common.h"

typedef struct uart_data_type {
    char *rxBuff;
    U32 rxSize;
    char *txBuff;
    U32 txSize;
} UART_DATA_t;

/*
 * 1.DMA；
 * 2.非FIFO轮询；
 * 3.非FIFO中断；
 * 4.FIFO 轮询；
 * 5.FIFO中断1字节或者N字节中断
 */
enum communicate {
	E_DMA,
	E_NO_FIFO_POLL,
	E_NO_FIFO_IRQ, // 中断接受时，应用层不知道接受的数据有多长，接受数据长度固定，此时每接受一个字节（8bit传输）会产生一次中断，若没有中断认为数据接受完
	E_FIFO_POLL,
	E_FIFO_IRQ
};

#define COMMUNICATE_MODE 2
#define RECV_LEN 258

void LPUART1_init(void);
void LPUART1_transmit_char(char send);
void LPUART1_transmit_string(char data_string[]);
char LPUART1_receive_char(void);
void LPUART1_receive_and_echo_char(void);

#define LOG(format, ...) self_printf(format, ##__VA_ARGS__);
#define LOG1(...) self_printf(__VA_ARGS__);

#endif /* LPUART_H_ */

main.c

#include "clock.h"
#include "can.h"
#include "io.h"
#include "systick.h"
#include "wdog.h"
#include "timer.h"
#include "common.h"
#include "adc.h"
#include "get_various_clock.h"
#include "uart.h"
#include "rtc.h"

int main()
{
//	U32 adc_value;
//	U8 buf[8];
//	U8 can_buf[8] = { 0 };
//	U8 i = 0;

	init_clks_80MHz(); // 研究寄存器
    port_init();
//	FLEXCAN0_init(); // 研究寄存器
	LPUART1_init();
//	RTC_Init();
//	systick_init(80000000);
//	TimerInt();
//	wdog_init();
//	adc_init();

//	flash_init();

	while (1)
	{
		//led_funtion();
//		if (0x777 == FLEXCAN0_receive_msg(can_buf))
//		{
//			FLEXCAN0_transmit_msg("12345678", 0x123);
//		}
//		if (i == 8) {
//			i = 0;
//		}
		LPUART1_receive_and_echo_char(); // wdg and uart module 相互影响
//

		//wdtExtReset();
		//read_adc_value(&adc_value);
//		datas[0]++;
//		FLASH_DRV_EraseSector(&flashSSDConfig, 0x31000, 4096);
//		FLASH_DRV_Program(&flashSSDConfig, 0x31000, 32, datas);
		//wdog_feed();
	}

	return 0;
}

io.c

/*
 * io.c
 *
 *  Created on: 2022年7月15日
 *      Author: Administrator
 */
#include "io.h"
#include "systick.h"
#include "timer.h"
#include "common.h"
#include "S32K144.h"

/*************************************
 * 输入参数：NO
 * 输出参数：NO
 * 函数功能：芯片IO口初始化，包括按键1中断初始化
 * 返回值：NO
 *************************************/
void port_init(void)
{
	unsigned char i;

	// PTA
	// enble PTA端口clock
	PCC->PCCn[PCC_PORTA_INDEX] |= PCC_PCCn_CGC_MASK; // Enable clock for PORTA
	// 配置PORTA之 A0/A1/A2/A3为 GPIO输出，分别对应开发板上的4个小灯LED1/LED2/LED3/LED4
	// 管脚复用为GPIO
	for (i = 0; i < 4; i++)
	{
		PTA->PDDR |= 1 << i;  // Port An: Data Direction = output
		PORTA->PCR[i] = 0x100; // Port A0: MUX = ALT1, GPIO
	}

	// PTB
	//PCC->PCCn[PCC_PORTB_INDEX] |= PCC_PCCn_CGC_MASK; // Enable clock for PORTB

	//PTC
	// PTC10 key1
	PCC->PCCn[PCC_PORTC_INDEX] |= PCC_PCCn_CGC_MASK; // Enable clock for PORTC
	PTC->PDDR &= ~(1 << 10);  // Port An: Data Direction = input
	PORTC->PCR[10] = 0xa0100; // Port A0: MUX = ALT1, GPIO // interrupt on falling-edge
	// UART
	PORTC->PCR[6]|=PORT_PCR_MUX(2);           /* Port C6: MUX = ALT2,UART1 TX */
	PORTC->PCR[7]|=PORT_PCR_MUX(2);           /* Port C7: MUX = ALT2,UART1 RX */

	// 外部中断配置
	S32_NVIC->ICPR[1] = 1 << (PORTC_IRQn % 32);
	S32_NVIC->ISER[(uint32_t)(PORTC_IRQn) >> 5U] = (uint32_t)(1UL << ((uint32_t)(PORTC_IRQn) & (uint32_t)0x1FU));

	// PTD
	PCC->PCCn[PCC_PORTD_INDEX] |= PCC_PCCn_CGC_MASK; // Enable clock for PORTD
	// PTD13, RTC_CLKOUT
	PORTD->PCR[13] &= ~PORT_PCR_MUX_MASK;
	PORTD->PCR[13] |= PORT_PCR_MUX(7);

	//PTE
	/* CAN RX TX  PTE4 PTE5*/
	PCC->PCCn[PCC_PORTE_INDEX] |= PCC_PCCn_CGC_MASK; /* Enable clock for PORTE */
	PORTE->PCR[4] |= PORT_PCR_MUX(5); /* Port E4: MUX = ALT5, CAN0_RX */
	PORTE->PCR[5] |= PORT_PCR_MUX(5); /* Port E5: MUX = ALT5, CAN0_TX */


}

void PORTC_IRQHandler()
{
	U8 i;
	U8 j = 2;

	PTA->PDOR = 15;
	while (j)
	{
		for (i = 0; i < 4; i++)
		{
			PTA->PDOR &= ~(1 << i);
			timer_delay();
			// 这里不能使用systick_delay_times做延时，系统滴答靠滴答中断计数，此时还未退出按键中断
			PTA->PDOR |= 1 << i;
			timer_delay();
		}
		j--;
	}
	PORTC->ISFR |= 1 << 10; //清除中断标志位
}

void led_funtion(void)
{
	uint8_t i;

	PTA->PDOR = 15;
	for (i = 0; i < 4; i++)
	{
		PTA->PDOR &= ~(1 << i);
		systick_delay_times(100);
		PTA->PDOR |= 1 << i;
		systick_delay_times(100);
	}
}

2.2.使用DATA寄存器且使用FIFO通讯：

使用中断带有FIFO的方式收、发数据。源码如下，读者可以直接复制使用：

额外寄存器配置：

FIFO：

WATER:

代码初始化时配置FIFO和WATER寄存器，需要注意：在收发使能前设置

  LPUART1->CTRL &= ~((1 << 18) | (1 << 19));
  LPUART1->FIFO |= ((1 << 7) | (1 << 3));
  LPUART1->WATER |= (3 << 16);

2.3.使用FIFO轮询通讯：

轮询：就是周期性去操作DATA寄存器。

这里说明一下数据位非8bit通讯方式，如：9bit，10bit

CTRL：

9bit/10bit数据需要2字节，前8bit直接操作DATA寄存器，剩下的1/2bit有CTRL寄存器操作

void LPUART_Putchar10(LPUART_Type * base, uint16_t data)
{
    uint8_t ninthDataBit, tenthDataBit;
    uint32_t ctrlRegVal;
    volatile uint8_t * dataRegBytes = (volatile uint8_t *)(&(base->DATA));

    ninthDataBit = (uint8_t)((data >> 8U) & 0x1U);
    tenthDataBit = (uint8_t)((data >> 9U) & 0x1U);

    /* write to ninth/tenth data bit (T[0:7]=8-bits, T8=9th bit, T9=10th bit) */
    ctrlRegVal = base->CTRL;
    ctrlRegVal = (ctrlRegVal & ~LPUART_CTRL_R9T8_MASK) | ((uint32_t)ninthDataBit << LPUART_CTRL_R9T8_SHIFT);
    ctrlRegVal = (ctrlRegVal & ~LPUART_CTRL_R8T9_MASK) | ((uint32_t)tenthDataBit << LPUART_CTRL_R8T9_SHIFT);
    base->CTRL = ctrlRegVal;

    /* write to 8-bits to the data register */
    dataRegBytes[0] = (uint8_t)data;
}