O_STM32HAL库二次封装

---

O_嵌入式专题目录

---

• 基于 STM32Cube_FW_F1_V1.8.0 HAL库，具体库函数说明详见索引；索引因实时性问题与源码可能会有些许差距，源码为最新版本。

• 打包下载 - ATYSTMLIB_HAL.rar

• 在线索引 - ATYSTMLIB_HAL.html

• 离线索引 - ATYSTMLIB_HAL.chm

（Tips：Win系统反编译chm hh -decompile D:\htmlFloder D:\DEC.chm）

INCLUDE_ATY.h

/**
* @mainpage ATYSTMLIB_HAL
* @section Project
*       - ATYSTMLIB_HAL
*
* @section Author
*       - ATY
*
* @section Copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @section Descriptions
*       - Familiar functions for STM32F1 series
**********************************************************************************
*/

#ifndef __INCLUDE_ATY_H
#define __INCLUDE_ATY_H


#include "stdio.h"
//#include "GPIO_ATY.h"
//#include "TIMER_ATY.h"
//#include "UART_ATY.h"
//#include "I2C_ATY.h"
//#include "RTC_ATY.h"
//#include "PID_ATY.h"
//#include "CRC_ATY.h"
//#include "FILTER_ATY.h"
//#include "L_74HC165_ATY.h"
//#include "L_TPIC6B595_ATY.h"


#endif  /* __INCLUDE_ATY_H */

/******************************** End Of File *********************************/

CRC_ATY.h

/**
* @file CRC_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_200318 > ATY
*           -# Preliminary version, first Release
*       - 1_03_200318 > ATY
*           -# Add Conditional Compilation
*           -# Add user port
*       - 1_05_200722 > ATY
*           -# Change parameters
**********************************************************************************
*/


#ifndef __CRC_ATY_H
#define __CRC_ATY_H

#include "stm32f1xx_hal.h"


/******************************* For user *************************************/
/******************************************************************************/


/**
* @brief Invert buf with uint8_t size
* @param genBuf     - Generate buf
* @param srcBuf     - Input source buf
*/
void InvertUint8(uint8_t *genBuf, uint8_t *srcBuf)
{
    uint8_t i;
    uint8_t tempBuf=0;

    for(i=0;i<8;i++)
    {
        if(srcBuf[0]&(1<<i))
            tempBuf|=1<<(7-i);
    }
    genBuf[0]=tempBuf;
}
/**
* @brief Invert buf with uint16_t size
* @param genBuf     - Generate buf
* @param srcBuf     - Input source buf
*/
void InvertUint16(uint16_t *genBuf, uint16_t *srcBuf)
{
    uint8_t i;
    uint16_t tempBuf=0;

    for(i=0;i<16;i++)
    {
        if(srcBuf[0]&(1<<i))
            tempBuf|=1<<(15-i);
    }
    genBuf[0]=tempBuf;
}
/**
* @brief Generate CRC of Modbus 16
* @param buf        - Generate buf
* @param size       - Input source buf
* @return Value of CRC generate
* @warning Buf size should not cross the boundary, otherwise it will get stuck
*/
uint16_t GenCrc16Modbus(uint8_t *buf, uint8_t size)
{
    uint16_t crcXorResult=0xFFFF;
    uint16_t crcXorMultinomial=0x8005;
    uint8_t tempBuf=0;

    while(size--)
    {
        tempBuf=*(buf++);
        InvertUint8(&tempBuf, &tempBuf);
        crcXorResult^=(tempBuf<<8);

        for(int i=0;i<8;i++)
        {
            if(crcXorResult&0x8000)
                crcXorResult=(crcXorResult<<1)^crcXorMultinomial;
            else
                crcXorResult=crcXorResult<<1;
        }
    }
    InvertUint16(&crcXorResult, &crcXorResult);
    return (crcXorResult);
}
/**
* @brief Generate CRC of Modbus 16 with high bit or low bit
* @param buf        - Generate buf
* @param size       - Input source buf
* @param highLow    - Choose output high bit or low bit, 1 is high, 0 is low
* @return Value of CRC generate in high bit or low bit
* @warning Buf size should not cross the boundary, otherwise it will get stuck
*/
uint8_t GenCrc16ModbusHL(uint8_t *buf, uint8_t size, uint8_t highLow)
{
    uint16_t crcXorResult=0xFFFF;
    uint16_t crcXorMultinomial=0x8005;
    uint8_t tempBuf=0;

    while(size--)
    {
        tempBuf=*(buf++);
        InvertUint8(&tempBuf, &tempBuf);
        crcXorResult^=(tempBuf<<8);

        for(int i=0;i<8;i++)
        {
            if(crcXorResult&0x8000)
                crcXorResult=(crcXorResult<<1)^crcXorMultinomial;
            else
                crcXorResult=crcXorResult<<1;
        }
    }
    InvertUint16(&crcXorResult, &crcXorResult);
    if(highLow)
        return ((uint8_t)(crcXorResult & 0x00FF));
    return ((uint8_t)((crcXorResult >> 8) & 0xFF));
}
/**
* @brief Check CRC of Modbus 16
* @param buf        - Generate buf
* @param size       - Input source buf
* @return Check CRC success or fault
* @warning Buf size should not cross the boundary, otherwise it will get stuck
* @todo "bufData" can creat with unkonw size
*/
uint8_t CheckCrc16Modbus(uint8_t *buf, uint8_t size)
{
    uint8_t bufData[20];
    for(int i=0;i<size-2;i++)
        bufData[i]=buf[i];

    uint16_t crcO=GenCrc16Modbus(bufData, size-2);
    uint8_t CRC_L=(uint8_t)(crcO&0x00FF);
    uint8_t CRC_H=(uint8_t)((crcO>>8)&0xFF);

    if((buf[size-2]==CRC_L) && (buf[size-1]==CRC_H))
        return 1;
    return 0;
}

/**
* @brief Method of application
*/
void UseOfCrc16Modbus(void)
{
    volatile uint8_t checkResult=0;
    uint8_t tempA[12]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB3,0xC3};
    uint8_t tempB[12]={0x0A,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01};  //B0E7
    uint8_t tempC[12]={0x0A,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01};  //B0E7

    checkResult=CheckCrc16Modbus(tempA, 12);
    tempB[10]=(uint8_t)(GenCrc16Modbus(tempB, 10) & 0x00FF);
    tempB[11]=(uint8_t)((GenCrc16Modbus(tempB, 10) >> 8) & 0x00FF);
    tempC[10]=GenCrc16ModbusHL(tempC, 10, 1);
    tempC[11]=GenCrc16ModbusHL(tempC, 10, 0);
}


#endif  /* __CRC_ATY_H */

/******************************** End Of File *********************************/

FILTER_ATY.h

/**
* @file FILTER_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_200318 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200318 > ATY
*           -# Add Conditional Compilation
*           -# Add user port
**********************************************************************************
*/


#ifndef __FILTER_ATY_H
#define __FILTER_ATY_H

#include "stm32f1xx_hal.h"


/******************************* For user *************************************/
#define CHECK_TIMES  0x06
#define CHECK_STATE  0x14
/******************************************************************************/


volatile uint8_t filterState8[CHECK_STATE][CHECK_TIMES]={0};
/**
* @brief 8 byte size filter
* @param name       - Which array bit to save
* @param state      - The newest state of input
* @param checkTimes - Times to check
* @return The newest state when it be stable
* @warning The real filter time depends on the total run time of the loop which
*          contains this program multiply the number of filter times
*/
uint8_t FilterA_8(uint8_t name, uint8_t state, uint8_t checkTimes)
{
    uint8_t FilterA_8_i=0;
    for(FilterA_8_i=0; FilterA_8_i < (checkTimes-1); FilterA_8_i++)
        filterState8[name][FilterA_8_i+1] = filterState8[name][(FilterA_8_i)];
    filterState8[name][0]=state;
    for(FilterA_8_i=0; FilterA_8_i < (checkTimes-1); FilterA_8_i++)
    {
        if(filterState8[name][FilterA_8_i] != filterState8[name][(FilterA_8_i+1)])
            return 0xFF;
    }
    return filterState8[name][0];
}


volatile uint32_t filterState32[CHECK_STATE][CHECK_TIMES]={0};
/**
* @brief 32 byte size filter
* @param name       - Which array bit to save
* @param state      - The newest state of input
* @param checkTimes - Times to check
* @return The newest state when it be stable
* @warning The real filter time depends on the total run time of the loop which
*          contains this program multiply the number of filter times
*/
uint32_t FilterA_32(uint32_t name, uint32_t state, uint32_t checkTimes)
{
    uint32_t FilterA_32_i=0;
    filterState32[name][CHECK_TIMES-1]=state;
    for(FilterA_32_i=0; FilterA_32_i < (checkTimes-1); FilterA_32_i++)
        filterState32[name][FilterA_32_i] = filterState32[name][(FilterA_32_i+1)];
    for(FilterA_32_i=0; FilterA_32_i < (checkTimes-1); FilterA_32_i++)
    {
        if(filterState32[name][FilterA_32_i] != filterState32[name][(FilterA_32_i+1)])
            return 0xFF;
    }
    return filterState32[name][0];
}


#endif  /* __DEBOUNCE_ATY_H */

/******************************** End Of File *********************************/

GPIO_ATY.h

/**
* @file GPIO_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @attention
*       - If use KeyDetect function, the whole while delay should be as small
*         as possible
*
* @par Update
*       - 1_01_200321 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200401 > ATY
*           -# Add KeyTest()
*       - 1_03_200402 > ATY
*           -# Add KeyScan() reserved function
*           -# Refactor all function
*           -# Add KeyDetectOnce()
*           -# Add KeyDetectTwiceBlock()
*           -# Add KeyDetectTwiceUnblock()
**********************************************************************************
*/


#ifndef __GPIO_ATY_H
#define __GPIO_ATY_H

#include "stm32f1xx_hal.h"


/******************************* For user *************************************/
/** @brief You can define GPIO read&write function with your MCU type */

#define HeartbeatLedPort    GPIOE
#define HeartbeatLedPin     GPIO_PIN_5
#define KeyPort             GPIOE
#define KeyPin              GPIO_PIN_4
/******************************************************************************/


#define NONE_PRESS   0
#define PRESS_ONCE   1
#define PRESS_TWICE  2
#define PRESS_LONG   3


uint8_t pressType=NONE_PRESS;
#define LONG_PRESS_TIME 60
uint8_t longPressCount=0;
/**
* @brief Detect whether the key is pressed and how to press
* @param GPIOx      - GPIO_Port
* @param GPIO_Pin   - GPIO_Pin
*/
void KeyDetectOnce(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
    if(HAL_GPIO_ReadPin(GPIOx, GPIO_Pin)==GPIO_PIN_RESET)
    {
        HAL_Delay(20);
        if(HAL_GPIO_ReadPin(GPIOx, GPIO_Pin)==GPIO_PIN_RESET)
        {
            if(longPressCount>LONG_PRESS_TIME)
            {
                pressType=PRESS_LONG;
            }
            else
            {
                longPressCount++;
            }
        }
    }
    if(HAL_GPIO_ReadPin(GPIOx, GPIO_Pin)==GPIO_PIN_SET)
    {
        if(longPressCount>0 && longPressCount<=LONG_PRESS_TIME)
        {
            pressType=PRESS_ONCE;
        }
        longPressCount=0;
    }
}

#define INTERVAL_TIME   100
uint16_t intervalCount=0;
/**
* @brief Detect press key twice in block way
* @param GPIOx      - GPIO_Port
* @param GPIO_Pin   - GPIO_Pin
*/
void KeyDetectTwiceBlock(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
    KeyDetectOnce(GPIOx, GPIO_Pin);
    if(pressType==PRESS_ONCE)
    {
        intervalCount=0;
        pressType=NONE_PRESS;
        while(++intervalCount)
        {
            KeyDetectOnce(GPIOx, GPIO_Pin);
            HAL_Delay(1);
            if(pressType==PRESS_ONCE)
            {
                pressType=PRESS_TWICE;
                break;
            }
            else
            {
                if(intervalCount>INTERVAL_TIME)
                {
                    pressType=PRESS_ONCE;
                    break;
                }
            }
        }
    }
}

uint8_t pressTimes=0;
/**
* @brief Detect press key twice in block way
* @param GPIOx      - GPIO_Port
* @param GPIO_Pin   - GPIO_Pin
*/
void KeyDetectTwiceUnblock(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
    KeyDetectOnce(GPIOx, GPIO_Pin);
    if(pressType==PRESS_ONCE)
    {
        intervalCount=0;
        if(pressTimes==0)
        {
            pressType=NONE_PRESS;
            pressTimes++;
        }
        else
        {
            pressType=PRESS_TWICE;
            pressTimes=0;
            intervalCount=0;
        }
    }
    intervalCount++;
    HAL_Delay(1);
    if(intervalCount>INTERVAL_TIME && pressTimes!=0)
    {
        pressType=PRESS_ONCE;
        pressTimes=0;
        intervalCount=0;
    }
}
/**
* @brief Scan key matrix value
* @warning If return value is 32bit, theoretical support 16*16 key matrix
*/
uint32_t KeyScan(void)
{

    return 0;
}
/**
* @brief 8 byte size filter
* @param keyValue       - Key value from KeyScan() return
*/
void KeyDetectCombine(uint32_t keyValue)
{

}
/**
* @brief Test key input
* @param testMode       - Test key input
*/
void KeyTest(uint8_t testMode)
{
    switch(testMode)
    {
        case 1:
        {
            KeyDetectOnce(KeyPort, KeyPin);
            if(pressType==PRESS_ONCE)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
            }
            else if(pressType==PRESS_LONG)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(20);
            }
            break;
        }
        case 2:
        {
            KeyDetectTwiceBlock(KeyPort, KeyPin);
            if(pressType==PRESS_ONCE)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
            }
            else if(pressType==PRESS_LONG)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(20);
            }
            else if(pressType==PRESS_TWICE)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);

            }
            break;
        }
        case 3:
        {
            KeyDetectTwiceUnblock(KeyPort, KeyPin);
            if(pressType==PRESS_ONCE)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
            }
            else if(pressType==PRESS_LONG)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(20);
            }
            else if(pressType==PRESS_TWICE)
            {
                pressType=NONE_PRESS;
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);
                HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
                HAL_Delay(200);

            }
            break;
        }
        case 4:
        {
            KeyScan();
            break;
        }
    }
}


#endif  /* __GPIO_ATY_H */

/******************************** End Of File *********************************/

I2C_ATY.h

/**
* @file I2C_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_200320 > ATY
*           -# Preliminary version, first Release
**********************************************************************************
*/


#ifndef __I2C_ATY_H
#define __I2C_ATY_H

#include "stm32f1xx_hal.h"


/******************************* For user *************************************/
#define HI2C_N hi2c1
/******************************************************************************/


extern I2C_HandleTypeDef HI2C_N;
/**
* @brief Read I2C with HAL lib function
* @param addr       - Start address
* @param pData      - Data
* @param size       - Size to write or read
*/
void I2C_Read(uint16_t addr, uint8_t *pData, uint16_t size)
{
    HAL_I2C_Mem_Read(&HI2C_N, 0xA0, addr, I2C_MEMADD_SIZE_8BIT, pData, size, 100);
}
/**
* @brief Write I2C with HAL lib function
* @param addr       - Start address
* @param pData      - Data
* @param size       - Size to write or read
*/
void I2C_Write(uint16_t addr, uint8_t *pData, uint16_t size)
{
    uint16_t firstWrite=0,i=0;

    HAL_I2C_Mem_Write(&HI2C_N, 0xA1, addr, I2C_MEMADD_SIZE_8BIT, pData, size, 100);
    HAL_Delay(5);

    firstWrite=8-(addr%8);                        //How long left of this page
    if((addr/8) != ((addr+size)/8))
    {
        for(i=0; i<(((addr+size)/8)-(addr/8)); i++)
        {
//            HAL_IWDG_Refresh(&hiwdg);
            HAL_I2C_Mem_Write(&HI2C_N, 0xA1, addr+firstWrite+(i*8), I2C_MEMADD_SIZE_8BIT,
                              pData+firstWrite+(i*8), size-firstWrite-(i*8), 100);
            HAL_Delay(5);
        }
    }
}

#define WRITE_LENGTH    5
/**
* @brief A template to use I2C function for AT24C02
*/
void I2C_Template(void)
{
    uint8_t tmpWriteData[WRITE_LENGTH]={0};
    uint8_t tmpAddr=0,tmpReadData=0;
    uint16_t i=0;

    I2C_Read(0, &tmpAddr, 1);
    if(tmpAddr>=(256-WRITE_LENGTH))
    {
        tmpAddr=0;
    }
    tmpAddr+=WRITE_LENGTH;
    I2C_Write(0, &tmpAddr, 1);

    tmpWriteData[0]+=tmpAddr;
    for(i=0;i<(WRITE_LENGTH-1);i++)
    {
//        HAL_IWDG_Refresh(&hiwdg);
        tmpWriteData[i+1]=tmpWriteData[i]+1;
    }
    I2C_Write(tmpAddr, tmpWriteData, WRITE_LENGTH);

    for(i=0;i<(tmpAddr+WRITE_LENGTH);i++)
    {
//        HAL_IWDG_Refresh(&hiwdg);
        I2C_Read(i, &tmpReadData, 1);
        printf("%d ", tmpReadData);
    }
    printf("\n\n");

//  I2C_Read(tmpAddr, tmpBuf+2, WRITE_LENGTH);         //tmpBuf can be a pointer like a aarry
}


/**
* @brief Eliminate HAL_I2C bug
* @warning Put "__HAL_RCC_I2C1_CLK_ENABLE();" before GPIO init
*/
//void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c)
//{
//  GPIO_InitTypeDef GPIO_InitStruct = {0};
//  if(hi2c->Instance==I2C1)
//  {
//  /* USER CODE BEGIN I2C1_MspInit 0 */
//  __HAL_RCC_I2C1_CLK_ENABLE();
//  /* USER CODE END I2C1_MspInit 0 */
//
//    __HAL_RCC_GPIOB_CLK_ENABLE();
//    /**I2C1 GPIO Configuration
//    PB6     ------> I2C1_SCL
//    PB7     ------> I2C1_SDA
//    */
//    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
//    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
//    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
//    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
//
//    /* Peripheral clock enable */
//    //__HAL_RCC_I2C1_CLK_ENABLE();
//  /* USER CODE BEGIN I2C1_MspInit 1 */
//
//  /* USER CODE END I2C1_MspInit 1 */
//  }
//
//}


#endif  /* __I2C_ATY_H */

/******************************** End Of File *********************************/

L_74HC165_ATY.h

/**
* @file L_74HC165_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of L_74HC165 for all codes
*
* @par Update
*       - 1_01_200525 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200525 > ATY
*           -# Add Conditional Compilation
*           -# Add user port
**********************************************************************************
*/


#ifndef __L_74HC165_ATY_H
#define __L_74HC165_ATY_H

#include "stm32f1xx_hal.h"

/******************************* For user *************************************/
#define CLK_W_H     HAL_GPIO_WritePin(L_74HC165_CLK_GPIO_Port, L_74HC165_CLK_Pin, GPIO_PIN_SET)
#define CLK_W_L     HAL_GPIO_WritePin(L_74HC165_CLK_GPIO_Port, L_74HC165_CLK_Pin, GPIO_PIN_RESET)
#define SH_W_H      HAL_GPIO_WritePin(L_74HC165_SH_GPIO_Port, L_74HC165_SH_Pin, GPIO_PIN_SET)
#define SH_W_L      HAL_GPIO_WritePin(L_74HC165_SH_GPIO_Port, L_74HC165_SH_Pin, GPIO_PIN_RESET)
#defien DATA_R_H    (HAL_GPIO_ReadPin(L_74HC165_DATA_GPIO_Port, L_74HC165_DATA_Pin) == GPIO_PIN_SET)
#define DATA_R_L    (HAL_GPIO_ReadPin(L_74HC165_DATA_GPIO_Port, L_74HC165_DATA_Pin) == GPIO_PIN_RESET)
/******************************************************************************/


/**
* @brief Get value of L_74HC165
* @param size       - Size to read
* @return Value of L_74HC165
* @warning L_74HC165 reading data unstable at high temperature(about 80 celsius degree),
*          so it's better to read at the begining only
*/
uint32_t L_74HC165_Get(uint32_t size)
{
    uint32_t scanValue=0,i_L_74HC165_Get=0;

    CLK_W_H;
    SH_W_L;     //Start read
    SH_W_H;     //Stop read

    for(i_L_74HC165_Get=0; i_L_74HC165_Get<size; i_L_74HC165_Get++)
    {
        scanValue = scanValue << 1;
        if(DATA_R_H)
            scanValue |= 0x01;
        CLK_W_L;
        __nop();
        CLK_W_H;
    }

    CLK_W_L;

    return scanValue;
}

#endif  /* __L_74HC165_ATY_H */

/******************************** End Of File *********************************/

PID_ATY.h

/**
* @file PID_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_200318 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200318 > ATY
*           -# Add Conditional Compilation
*           -# Add user port
**********************************************************************************
*/


#ifndef __PID_ATY_H
#define __PID_ATY_H

#include "stm32f1xx_hal.h"
#include "string.h"


/******************************* For user *************************************/
/******************************************************************************/


double pidSetNum=0,pidCurNum=0;

typedef struct PID{
    double SetPoint;            //Set point desired value
    double Proportion;          //Proportional const
    double Integral;            //Integral const
    double Derivative;          //Derivative const
    double LastError;           //Error[-1]
    double PrevError;           //Error[-2]
    double SumError;            //Sums of errors
}PID;

/**
* @brief Calculate rOut
* @param pidStruct      - pidStruct
* @param nextPoint      - nextPoint
* @return pidStruct
*/
double PidCalc(PID *pidStruct, double nextPoint)
{
    double dError,Error;
    Error=pidStruct->SetPoint-nextPoint;                        //Deviation
    pidStruct->SumError+=Error;                                 //Integral
    dError=pidStruct->LastError-pidStruct->PrevError;           //Current differential
    pidStruct->PrevError=pidStruct->LastError;
    pidStruct->LastError=Error;
    return (pidStruct->Proportion *Error                        //Proportional
                    +pidStruct->Integral *pidStruct->SumError   //Integral item
                    +pidStruct->Derivative *dError );           //Differential item
}

/**
* @brief Init pid
* @param pidStruct      - pidStruct
*/
void PidInit (PID *pidStruct)
{
    memset(pidStruct, 0, sizeof(PID));
}

/**
* @brief Calculate pidCurNum
* @param rDelta     - rDelta
* @return
*/
void Actuator(double rDelta)
{
    pidCurNum+=rDelta;
}

/**
* @brief Pid control
*/
void PidControl(void)
{
    PID sPID[2];                                                //PID Control Struct
    double rOut[2];                                             //PID Response (Output)
    double rIn[2];                                              //PID Feedback (Input)
    uint8_t i=0;

    PidInit(&sPID[0]);                                          //Initialize Struct
    sPID[0].Proportion=0.5;                                     //Set PID Coefficients
    sPID[0].Integral=0.5;
    sPID[0].Derivative=0;
    sPID[0].SetPoint=pidSetNum;                                 //Set PID Setpoint (Goal)

    while(1)                                                    //Better torite in timer interrupt call back function
    {                                                           //Mock Up of PID processing
        if(i>50)
        {
            i=0;
            pidSetNum+=10;
            if(pidSetNum>100)
                pidSetNum=0;
        }
        i++;

        sPID[0].SetPoint=pidSetNum;

        rIn[0]=pidCurNum;                                       //Reads the input variable function (Read Input )
        rOut[0]=PidCalc(&sPID[0], rIn[0]);                      //PID calculation function (Perform PID Interation)
        Actuator(rOut[0]);                                      //Output variable control function (Effect Needed Changes)

//      printf("In: %f\nOut: %f\nPidCur: %f\n\n", rIn[0], rOut[0], pidCurNum);
        printf("%f\n", pidCurNum);

        HAL_Delay(100);
    }
}


#endif  /* __PID_ATY_H */

/******************************** End Of File *********************************/

RTC_ATY.h

/**
* @file RTC_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_200317 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200318 > ATY
*           -# Add RTC_Set and RTC_GetShowHex()
*       - 1_03_200319 > ATY
*           -# Add RTC_UartSet()
*           -# Add RTC_FormatToUnix32()
*           -# Add RTC_Unix32ToFormat()
**********************************************************************************
*/


#ifndef __RTC_ATY_H
#define __RTC_ATY_H

#include "stm32f1xx_hal.h"
#include "time.h"


/******************************* For user *************************************/
#define RTC_N   hrtc
// #define SET_IN_UART
/******************************************************************************/


extern RTC_HandleTypeDef RTC_N;
RTC_DateTypeDef rtcDateStructure;
RTC_TimeTypeDef rtcTimeStructure;

/**
* @brief Init rtc date and time
*/
void RTC_Init(void)
{
    rtcDateStructure.Year=20;
    rtcDateStructure.Month=3;
    rtcDateStructure.Date=16;
    rtcTimeStructure.Hours=17;
    rtcTimeStructure.Minutes=12;
    rtcTimeStructure.Seconds=00;
    HAL_RTC_SetDate(&RTC_N, &rtcDateStructure, RTC_FORMAT_BIN);
    HAL_RTC_SetTime(&RTC_N, &rtcTimeStructure, RTC_FORMAT_BIN);
}

/**
* @brief Set rtc date and time
* @param year           - Year
* @param month          - Month
* @param date           - Date
* @param hours          - Hours
* @param minutes        - Minutes
* @param seconds        - Seconds
*/
void RTC_Set(uint8_t year, uint8_t month, uint8_t date,
            uint8_t hours, uint8_t minutes, uint8_t seconds)
{
    rtcDateStructure.Year=year;
    rtcDateStructure.Month=month;
    rtcDateStructure.Date=date;
    rtcTimeStructure.Hours=hours;
    rtcTimeStructure.Minutes=minutes;
    rtcTimeStructure.Seconds=seconds;
    HAL_RTC_SetDate(&RTC_N, &rtcDateStructure, RTC_FORMAT_BIN);
    HAL_RTC_SetTime(&RTC_N, &rtcTimeStructure, RTC_FORMAT_BIN);
}

/**
* @brief Determine if it's a leap year
* @param year       - Year
* @return Is leap year or not
* @brief
*           Month         01 02 03 04 05 06 07 08 09 10 11 12
*           IsLeapYear    31 29 31 30 31 30 31 31 30 31 30 31
*           NotLeapYear   31 28 31 30 31 30 31 31 30 31 30 31
*/
uint8_t IsLeapYear(uint16_t year)
{
    if(year%4==0)
    {
        if(year%100==0)
        {
            /*- It has to be divisible by 400 if the year end with 00 */
            if(year%400==0)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        else
        {
            return 1;
        }
    }
    else
    {
        return 0;
    }
}


/**
* @brief Get rtc date time and convert to unix
* @param show       - Chose to print or not
* @return Time data in unix32
* @warning Must get time before get date
*/
uint32_t RTC_FormatToUnix32(uint8_t show)
{
    uint32_t unixTime;
    struct tm stmT;

    HAL_RTC_GetTime(&hrtc, &rtcTimeStructure, RTC_FORMAT_BIN);
    HAL_RTC_GetDate(&hrtc, &rtcDateStructure, RTC_FORMAT_BIN);

    stmT.tm_year=rtcDateStructure.Year+100;
    stmT.tm_mon=rtcDateStructure.Month-1;
    stmT.tm_mday=rtcDateStructure.Date;
    stmT.tm_hour=rtcTimeStructure.Hours-8;
    stmT.tm_min=rtcTimeStructure.Minutes;
    stmT.tm_sec=rtcTimeStructure.Seconds;

    unixTime=mktime(&stmT);
    if(show)
    {
        printf("UTC:%d\n",unixTime);
    }
    return unixTime;
}

/**
* @brief Detect whether the key is pressed and how to press
* @param unixTime       - Time data in unix32
* @param show           - Chose to print or not
*/
void RTC_Unix32ToFormat(uint32_t unixTime, uint8_t show)
{
    struct tm *stmU;

    stmU=localtime(&unixTime);

    rtcDateStructure.Year=stmU->tm_year-100;
    rtcDateStructure.Month=stmU->tm_mon+1;
    rtcDateStructure.Date=stmU->tm_mday;
    rtcTimeStructure.Hours=stmU->tm_hour+8;
    rtcTimeStructure.Minutes=stmU->tm_min;
    rtcTimeStructure.Seconds=stmU->tm_sec;

    HAL_RTC_SetDate(&hrtc, &rtcDateStructure, RTC_FORMAT_BIN);
    HAL_RTC_SetTime(&hrtc, &rtcTimeStructure, RTC_FORMAT_BIN);

    if(show)
    {
        printf("%02d/%02d/%02d\n", 2000+rtcDateStructure.Year, rtcDateStructure.Month, rtcDateStructure.Date);
        printf("%02d:%02d:%02d\n\n", rtcTimeStructure.Hours, rtcTimeStructure.Minutes, rtcTimeStructure.Seconds);
    }
}

uint8_t dateTimeShow[6]={0};
/**
* @brief Get rtc date time and print to uart
* @param show       - Chose to print or not
* @warning Must get time before get date
*/
void RTC_GetShow(uint8_t show)
{
    HAL_RTC_GetTime(&RTC_N, &rtcTimeStructure, RTC_FORMAT_BIN);
    HAL_RTC_GetDate(&RTC_N, &rtcDateStructure, RTC_FORMAT_BIN);

    if(show)
    {
        dateTimeShow[0]=RTC_FormatToUnix32(0)>>24;
        dateTimeShow[1]=RTC_FormatToUnix32(0)>>16;
        dateTimeShow[2]=RTC_FormatToUnix32(0)>>8;
        dateTimeShow[3]=RTC_FormatToUnix32(0);
        dateTimeShow[4]=0x00;
        dateTimeShow[5]=0x00;
//        dateTimeShow[0]=rtcDateStructure.Year;
//        dateTimeShow[1]=rtcDateStructure.Month;
//        dateTimeShow[2]=rtcDateStructure.Date;
//        dateTimeShow[3]=rtcTimeStructure.Hours;
//        dateTimeShow[4]=rtcTimeStructure.Minutes;
//        dateTimeShow[5]=rtcTimeStructure.Seconds;
//        /* Display date Format : yy-mm-dd */
        printf("\n%02d-%02d-%02d\n",2000+rtcDateStructure.Year,
                                   rtcDateStructure.Month,
                                   rtcDateStructure.Date);
//        /* Display time Format : hh:mm:ss */
        printf("%02d:%02d:%02d\n",rtcTimeStructure.Hours,
                             rtcTimeStructure.Minutes,
                             rtcTimeStructure.Seconds);
    }
}

/**
* @brief Get rtc date time and print to uart in hexadecimal
* @param show       - Chose to print or not
* @warning Must get time before get date
*/
void RTC_GetShowHex(uint8_t show)
{
    uint32_t dateHex=0,timeHex=0;

    HAL_RTC_GetTime(&RTC_N, &rtcTimeStructure, RTC_FORMAT_BIN);
    HAL_RTC_GetDate(&RTC_N, &rtcDateStructure, RTC_FORMAT_BIN);

    timeHex=(rtcTimeStructure.Hours<<16)+(rtcTimeStructure.Minutes<<8)+rtcTimeStructure.Seconds;
    dateHex=(rtcDateStructure.Year<<16)+(rtcDateStructure.Month<<8)+rtcDateStructure.Date;

    if(show)
    {
        printf("\n%08x\n",dateHex);
        printf("%08x\n",timeHex);
    }
}

void RTC_GetShowUnix32(uint8_t show)
{

}

#ifdef SET_IN_UART
/**
* @brief Use uart set RTC time
* @brief Temp: 200318083000 - 2020/03/18 08:30:00
*/
void RTC_SetInUart(void)
{
    if(uart1GetCount >0)
    {
        rtcDateStructure.Year=((uart1GetStr[0]-48)*10)+(uart1GetStr[1]-48);
        rtcDateStructure.Month=((uart1GetStr[2]-48)*10)+(uart1GetStr[3]-48);
        rtcDateStructure.Date=((uart1GetStr[4]-48)*10)+(uart1GetStr[5]-48);
        rtcTimeStructure.Hours=((uart1GetStr[6]-48)*10)+(uart1GetStr[7]-48);
        rtcTimeStructure.Minutes=((uart1GetStr[8]-48)*10)+(uart1GetStr[9]-48);
        rtcTimeStructure.Seconds=((uart1GetStr[10]-48)*10)+(uart1GetStr[11]-48);
        HAL_RTC_SetTime(&RTC_N, &rtcTimeStructure, RTC_FORMAT_BIN);
        HAL_RTC_SetDate(&RTC_N, &rtcDateStructure, RTC_FORMAT_BIN);
        memset(uart1GetStr, 0, sizeof(uart1GetStr));
        uart1GetCount=0;
    }
}
#endif  /* SET_IN_UART */


#endif  /* __RTC_ATY_H */

/******************************** End Of File *********************************/

TIMER_ATY.h

/**
* @file TIMER_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_200317 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200318 > ATY
*           -# Add Conditional Compilation
*           -# Add user port
*       - 1_03_200319 > ATY
*           -# Add RTC delay_s()
*       - 1_04_200401 > ATY
*           -# Add delay_s() for other types
*           -# Add delayTest()
*           -# Fix Timer type function bug
*       - 1_05_200423 > ATY
*           -# Add TEST_ATY()
**********************************************************************************
*/


#ifndef __TIMER_ATY_H
#define __TIMER_ATY_H

#include "stm32f1xx_hal.h"


/******************************* For user *************************************/
//#define SYS_ATY
//#define HAL_ATY
#define TIM_ATY
#define HTIM_N  htim2
//#define RTC_ATY
//#define HRTC_N  hrtc

//#define TEST_ATY
/******************************************************************************/


/****************************** Use SysTick ***********************************/
#ifdef SYS_ATY
#define F0_BASE_NUM_SYS 6
#define F1_BASE_NUM_SYS 9
#define BASE_NUM_SYS    F1_BASE_NUM_SYS
/**
* @brief Delay n us with SysTick
* @param us     - us
* @brief SysTick is a 24-bit timer, max count number is 16777215;
*        F0: 48MHz/8 -> 6 -> 6 numbers per us -> 2796ms max;
*        F1: 72MHz/8 -> 9 -> 9 numbers per us -> 1864ms max;
*/
void delay_us(uint32_t us)
{
    uint32_t temp;
    SysTick->LOAD=BASE_NUM_SYS*us;
    SysTick->VAL=0X00;
    SysTick->CTRL=0X01;
    do
    {
        temp=SysTick->CTRL;
    }while((temp&0x01)&&(!(temp&(1<<16))));

    SysTick->CTRL=0x00;
    SysTick->VAL=0X00;
}
/**
* @brief Delay n ms with SysTick
* @param ms     - ms
*/
void delay_ms(uint16_t ms)
{
    uint32_t temp;
    SysTick->LOAD=BASE_NUM_SYS*1000*ms;
    SysTick->VAL=0X00;
    SysTick->CTRL=0X01;
    do
    {
        temp=SysTick->CTRL;
    }while((temp&0x01)&&(!(temp&(1<<16))));

    SysTick->CTRL=0x00;
    SysTick->VAL=0X00;
}
/**
* @brief Delay n s with SysTick
* @param s     - s
*/
void delay_s(uint32_t s)
{
    for(;s>0;s--)
    {
        delay_ms(1000);
    }
}
#endif	/* SYS_ATY */


/**************************** Change Hal_Delay() ******************************/
#ifdef HAL_ATY
/**
* @brief Delay n us in changing RCC clock
* @param us     - us
*/
void delay_us(uint32_t us)
{
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000000);
    HAL_Delay(us);
}
/**
* @brief Delay n ms in changing RCC clock
* @param ms     - ms
* @return
*/
void delay_ms(uint16_t ms)
{
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
    HAL_Delay(ms);
}
/**
* @brief Delay n s in changing RCC clock
* @param s     - s
*/
void delay_s(uint32_t s)
{
    for(;s>0;s--)
    {
        delay_ms(1000);
    }
}

#endif  /* HAL_ATY */


/********************************* Use Timer **********************************/
#ifdef TIM_ATY
extern TIM_HandleTypeDef HTIM_N;
/**
* @brief Delay n us with TimerN
* @param us     - us
* @brief Commonly used in RTOS microsecond delay;
*        F1 -> 72Mhz -> Prescaler=71 -> 1us per count,
*                       Prescaler=719 -> 10us per count,
*                       Prescaler=7199 -> 100us per count,
*        so Period init number need to be larger than max us,
*        and Prescaler init must be 71 if use this type delay function
* @warning Be easily disturbed by other interrupt;
*/
void delay_us(uint16_t us)
{
    uint16_t timerCounter=0xffff-us-5;
    HAL_TIM_Base_Start(&HTIM_N);
    __HAL_TIM_SET_COUNTER(&HTIM_N,timerCounter);
    while(timerCounter<0xffff-5)
    {
        timerCounter=__HAL_TIM_GET_COUNTER(&HTIM_N);
    }
    HAL_TIM_Base_Stop(&HTIM_N);
}
/**
* @brief Delay n ms with TimerN
* @param ms     - ms
*/
void delay_ms(uint32_t ms)
{
    for(;ms>0;ms--)
    {
        delay_us(1000);
    }
}
/**
* @brief Delay n s with TimerN
* @param s     - s
*/
void delay_s(uint32_t s)
{
    for(;s>0;s--)
    {
        delay_ms(1000);
    }
}
#endif  /* TIM_ATY */


/********************************* Use RTC ************************************/
#ifdef RTC_ATY
extern RTC_HandleTypeDef HRTC_N;
/**
* @brief Get counter number of rtc
* @param hrtc       - hrtc
*/
uint32_t RTC_ReadTimeCounter(RTC_HandleTypeDef *hrtc)
{
    uint16_t highFirst=0U,low=0U,highSecond=0U;
    uint32_t timeCounter=0U;
    highFirst=READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
    low=READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT);
    highSecond=READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);

    if(highFirst!=highSecond)
    {
        /*- In this case the counter roll over during reading of CNTL and CNTH registers,
        read again CNTL register then return the counter value */
        timeCounter=(((uint32_t)highSecond<<16U) |
                    READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT));
    }
    else
    {
        /*- No counter roll over during reading of CNTL and CNTH registers,
        counter value is equal to first value of CNTL and CNTH */
        timeCounter=(((uint32_t)highFirst<<16U) | low);
    }

    return timeCounter;
}

/**
* @brief Delay n us
*/
void delay_us(void){}
/**
* @brief Delay n ms
*/
void delay_ms(void){}

/**
* @FunctionName: delay_s
* @Descriptions: Delay n seconds with RTC timeCounter
* @Parameters: seconds
* @ReturnedValue: none
* @Instruction:
*/
void delay_s(uint32_t s)
{
    s+=RTC_ReadTimeCounter(&HRTC_N);
    while(s>RTC_ReadTimeCounter(&HRTC_N)){}
}
#endif  /* RTC_ATY */

#ifdef TEST_ATY
/**
* @brief A simple test function for delay_us/ms/s
* @brief Heartbeat LED need to be defined at GPIO_ATY.h
*/
void delayTest(void)
{
    HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
    delay_ms(1000);
    HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
    for(i_ATY=0;i_ATY<1000;i_ATY++)
        delay_us(1000);
    HAL_GPIO_TogglePin(HeartbeatLedPort, HeartbeatLedPin);
    delay_s(5);

}
#endif  /* TEST_ATY */

#endif  /* __TIMER_ATY_H */

/******************************** End Of File *********************************/

L_TPIC6B595_ATY.h

/**
* @file L_TPIC6B595_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of L_TPIC6B595 for all codes
*
* @par Update
*       - 1_01_200825 > ATY
*           -# Preliminary version, first Release
**********************************************************************************
*/


#ifndef __L_TPIC6B595_ATY_H
#define __L_TPIC6B595_ATY_H

#include "stm32f1xx_hal.h"

/******************************* For user *************************************/
#define SERIN_W_H       HAL_GPIO_WritePin(L_TPIC6B595_SERIN_GPIO_Port, L_TPIC6B595_SERIN_Pin, GPIO_PIN_SET)
#define SERIN_W_L       HAL_GPIO_WritePin(L_TPIC6B595_SERIN_GPIO_Port, L_TPIC6B595_SERIN_Pin, GPIO_PIN_RESET)
#define RSCK_W_H        HAL_GPIO_WritePin(L_TPIC6B595_RSCK_GPIO_Port, L_TPIC6B595_RSCK_Pin, GPIO_PIN_SET)
#define RSCK_W_L        HAL_GPIO_WritePin(L_TPIC6B595_RSCK_GPIO_Port, L_TPIC6B595_RSCK_Pin, GPIO_PIN_RESET)
#defien SCK_W_H         HAL_GPIO_WritePin(L_TPIC6B595_SCK_GPIO_Port, L_TPIC6B595_SCK_Pin, GPIO_PIN_SET)
#define SCK_W_L         HAL_GPIO_WritePin(L_TPIC6B595_SCK_GPIO_Port, L_TPIC6B595_SCK_Pin, GPIO_PIN_RESET)
/******************************************************************************/


/**
* @brief Set value of L_TPIC6B595
* @param data       - Data to write
* @param size       - Size of data
*/
void L_TPIC6B595_Set(uint32_t data, uint32_t size)
{
    uint32_t i_L_TPIC6B595_Set=0;

    SCK_W_L;
    RSCK_W_L;

    for(i_L_TPIC6B595_Set=0; i_L_TPIC6B595_Set<size; i_L_TPIC6B595_Set++)
    {
        if(data&0X01)
            SERIN_W_H;
        else
            SERIN_W_L;
        __nop();__nop();
        SCK_W_L;
        __nop();__nop();
        SCK_W_H;
        __nop();__nop();
        data>>=1;
    }

    RSCK_W_L;
    __nop();__nop();
    RSCK_W_H;
    __nop();__nop();
    RSCK_W_L;
}

#endif  /* __L_TPIC6B595_ATY_H */

/******************************** End Of File *********************************/

UART_ATY.h

/**
* @file UART_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @attention
*       - "UartInit_ATY();" need to be added at main()
*
* @par Update
*       - 1_01_200317 > ATY
*           -# Preliminary version, first Release
*       - 1_02_200318 > ATY
*           -# Add Conditional Compilation
*           -# Add user port
*       - 1_03_200401 > ATY
*           -# Fix UartControlTemplate()
*           -# Change UartSend() to use string and size
*           -# Test uart 1-5 in normal IT
*           -# Change DMA all function
*           -# Test uart 1-4 in DMA IT
*           -# (Might be the last version)
*       - 1_04_200423 > ATY
*           -# Add TEST_ATY()
*       - 1_05_200429 > ATY
*           -# Change to uart1-5 independent function
**********************************************************************************
*/


#ifndef __UART_ATY_H
#define __UART_ATY_H

#include "stm32f1xx_hal.h"
#include "stdio.h"                      //For "FILE"
#include "string.h"                     //For memset etc.


/******************************* For user *************************************/
// #define TEST_IT_ATY
// #define TEST_DMA_ATY

//#define HUART_N huart2                  //For printf();

#define UART1_NIT_ATY
// #define UART1_DMA_ATY
#define UART1_GET_SIZE   4
#define UART1_SEND_SIZE  8

#define UART2_NIT_ATY
// #define UART2_DMA_ATY
#define UART2_GET_SIZE   11
#define UART2_SEND_SIZE  8

#define UART3_NIT_ATY
// #define UART3_DMA_ATY
#define UART3_GET_SIZE   13
#define UART3_SEND_SIZE  255

// #define UART4_NIT_ATY
// #define UART4_DMA_ATY
// #define UART4_GET_SIZE   8
// #define UART4_SEND_SIZE  8

// #define UART5_NIT_ATY
// #define UART5_DMA_ATY
// #define UART5_GET_SIZE   8
// #define UART5_SEND_SIZE  8
/******************************************************************************/


#ifdef UART1_NIT_ATY
uint8_t uart1GetByte=0;
uint8_t uart1GetCount=0;
uint8_t uart1GetStr[UART1_GET_SIZE];
uint8_t uart1SendStr[UART1_SEND_SIZE];
#endif  /* UART1_NIT_ATY */

#ifdef UART2_NIT_ATY
uint8_t uart2GetByte=0;
uint8_t uart2GetCount=0;
uint8_t uart2GetStr[UART2_GET_SIZE];
uint8_t uart2SendStr[UART2_SEND_SIZE];
#endif  /* UART2_NIT_ATY */

#ifdef UART3_NIT_ATY
uint8_t uart3GetByte=0;
uint8_t uart3GetCount=0;
uint8_t uart3GetStr[UART3_GET_SIZE];
uint8_t uart3SendStr[UART3_SEND_SIZE];
#endif  /* UART3_NIT_ATY */

#ifdef UART4_NIT_ATY
uint8_t uart4GetByte=0;
uint8_t uart4GetCount=0;
uint8_t uart4GetStr[UART4_GET_SIZE];
uint8_t uart4SendStr[UART4_SEND_SIZE];
#endif  /* UART4_NIT_ATY */

#ifdef UART5_NIT_ATY
uint8_t uart5GetByte=0;
uint8_t uart5GetCount=0;
uint8_t uart5GetStr[UART5_GET_SIZE];
uint8_t uart5SendStr[UART5_SEND_SIZE];
#endif  /* UART5_NIT_ATY */


#ifdef UART1_DMA_ATY
uint8_t uart1GetByte=0;
uint8_t uart1GetCount=0;
uint8_t uart1GetStr[UART1_GET_SIZE];
uint8_t uart1SendStr[UART1_SEND_SIZE];
uint16_t uart1DmaSendFlag=0;
volatile uint8_t uart1RecvEndFlag=0;
static __IO ITStatus uart1Ready=RESET;
extern DMA_HandleTypeDef hdma_usart1_rx;
#endif  /* UART1_DMA_ATY */


#ifdef UART2_DMA_ATY
uint8_t uart2GetByte=0;
uint8_t uart2GetCount=0;
uint8_t uart2GetStr[UART2_GET_SIZE];
uint8_t uart2SendStr[UART2_SEND_SIZE];
uint16_t uart2DmaSendFlag=0;
volatile uint8_t uart2RecvEndFlag=0;
static __IO ITStatus uart2Ready=RESET;
extern DMA_HandleTypeDef hdma_usart2_rx;
#endif  /* UART2_DMA_ATY */


#ifdef UART3_DMA_ATY
uint8_t uart3GetByte=0;
uint8_t uart3GetCount=0;
uint8_t uart3GetStr[UART3_GET_SIZE];
uint8_t uart3SendStr[UART3_SEND_SIZE];
uint16_t uart3DmaSendFlag=0;
volatile uint8_t uart3RecvEndFlag=0;
static __IO ITStatus uart3Ready=RESET;
extern DMA_HandleTypeDef hdma_usart3_rx;
#endif  /* UART3_DMA_ATY */


#ifdef UART4_DMA_ATY
uint8_t uart4GetByte=0;
uint8_t uart4GetCount=0;
uint8_t uart4GetStr[UART4_GET_SIZE];
uint8_t uart4SendStr[UART4_SEND_SIZE];
uint16_t uart4DmaSendFlag=0;
volatile uint8_t uart4RecvEndFlag=0;
static __IO ITStatus uart4Ready=RESET;
extern DMA_HandleTypeDef hdma_usart4_rx;
#endif  /* UART4_DMA_ATY */


#ifdef UART5_DMA_ATY
uint8_t uart5GetByte=0;
uint8_t uart5GetCount=0;
uint8_t uart5GetStr[UART5_GET_SIZE];
uint8_t uart5SendStr[UART5_SEND_SIZE];
uint16_t uart5DmaSendFlag=0;
volatile uint8_t uart5RecvEndFlag=0;
static __IO ITStatus uart5Ready=RESET;
extern DMA_HandleTypeDef hdma_usart5_rx;
#endif  /* UART5_DMA_ATY */


/**
* @brief Rewrite "printf();"
*/
//extern UART_HandleTypeDef HUART_N;
//int fputc(int ch, FILE *f)
//{
//    HAL_UART_Transmit(&HUART_N, (uint8_t*)&ch, 1, 1000);
//    return ch;
//}


/**
* @brief Init uart interrupt
*/
void UartInit_ATY(void)
{
#ifdef UART1_NIT_ATY
    HAL_UART_Receive_IT(&huart1, &uart1GetByte, 1);
#endif  /* UART1_NIT_ATY */

#ifdef UART2_NIT_ATY
    HAL_UART_Receive_IT(&huart2, &uart2GetByte, 1);
#endif  /* UART2_NIT_ATY */

#ifdef UART3_NIT_ATY
    HAL_UART_Receive_IT(&huart3, &uart3GetByte, 1);
#endif  /* UART3_NIT_ATY */

#ifdef UART4_NIT_ATY
    HAL_UART_Receive_IT(&huart4, &uart4GetByte, 1);
#endif  /* UART4_NIT_ATY */

#ifdef UART5_NIT_ATY
    HAL_UART_Receive_IT(&huart5, &uart5GetByte, 1);
#endif  /* UART5_NIT_ATY */


#ifdef UART1_DMA_ATY
    __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart1, uart1GetStr, UART1_GET_SIZE);
#endif  /* UART1_DMA_ATY */

#ifdef UART2_DMA_ATY
    __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart2, uart2GetStr, UART2_GET_SIZE);
#endif  /* UART2_DMA_ATY */

#ifdef UART3_DMA_ATY
    __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart3, uart3GetStr, UART3_GET_SIZE);
#endif  /* UART3_DMA_ATY */

#ifdef UART4_DMA_ATY
    __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart4, uart4GetStr, UART4_GET_SIZE);
#endif  /* UART4_DMA_ATY */

#ifdef UART5_DMA_ATY
    __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart5, uart5GetStr, UART5_GET_SIZE);
#endif  /* UART5_DMA_ATY */
}

/******************************* Normal IT Type *******************************/
#ifdef UART1_NIT_ATY
/**
* @brief Send data from uart
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart1Send(uint8_t *pData, uint16_t Size)
{
    HAL_UART_Transmit_IT(&huart1, (uint8_t*)pData, Size);
}
/**
* @brief Receive data from uart with IT
*/
void Uart1Recv(void)
{
    if(uart1GetCount<UART1_GET_SIZE)
    {
        uart1GetStr[uart1GetCount++]=uart1GetByte;
    }
    else
    {
        uart1GetCount=0;
    }
    while(HAL_UART_Receive_IT(&huart1, &uart1GetByte, 1)==HAL_OK);
}
#endif  /* UART1_NIT_ATY */


#ifdef UART2_NIT_ATY
/**
* @brief Send data from uart
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart2Send(uint8_t *pData, uint16_t Size)
{
    HAL_UART_Transmit_IT(&huart2, (uint8_t*)pData, Size);
}
/**
* @brief Receive data from uart with IT
*/
void Uart2Recv(void)
{
    if(uart2GetCount<UART2_GET_SIZE)
    {
        uart2GetStr[uart2GetCount++]=uart2GetByte;
    }
    else
    {
        uart2GetCount=0;
    }
    while(HAL_UART_Receive_IT(&huart2, &uart2GetByte, 1)==HAL_OK);
}
#endif  /* UART2_NIT_ATY */


#ifdef UART3_NIT_ATY
/**
* @brief Send data from uart
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart3Send(uint8_t *pData, uint16_t Size)
{
    HAL_UART_Transmit_IT(&huart3, (uint8_t*)pData, Size);
}
/**
* @brief Receive data from uart with IT
*/
void Uart3Recv(void)
{
    if(uart3GetCount<UART3_GET_SIZE)
    {
        uart3GetStr[uart3GetCount++]=uart3GetByte;
    }
    else
    {
        uart3GetCount=0;
    }
    while(HAL_UART_Receive_IT(&huart3, &uart3GetByte, 1)==HAL_OK);
}
#endif  /* UART3_NIT_ATY */


#ifdef UART4_NIT_ATY
/**
* @brief Send data from uart
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart4Send(uint8_t *pData, uint16_t Size)
{
    HAL_UART_Transmit_IT(&huart4, (uint8_t*)pData, Size);
}
/**
* @brief Receive data from uart with IT
*/
void Uart4Recv(void)
{
    if(uart4GetCount<UART4_GET_SIZE)
    {
        uart4GetStr[uart4GetCount++]=uart4GetByte;
    }
    else
    {
        uart4GetCount=0;
    }
    while(HAL_UART_Receive_IT(&huart4, &uart4GetByte, 1)==HAL_OK);
}
#endif  /* UART4_NIT_ATY */


#ifdef UART5_NIT_ATY
/**
* @brief Send data from uart
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart5Send(uint8_t *pData, uint16_t Size)
{
    HAL_UART_Transmit_IT(&huart5, (uint8_t*)pData, Size);
}
/**
* @brief Receive data from uart with IT
*/
void Uart5Recv(void)
{
    if(uart5GetCount<UART5_GET_SIZE)
    {
        uart5GetStr[uart5GetCount++]=uart5GetByte;
    }
    else
    {
        uart5GetCount=0;
    }
    while(HAL_UART_Receive_IT(&huart5, &uart5GetByte, 1)==HAL_OK);
}
#endif  /* UART5_NIT_ATY */


#if defined(UART1_NIT_ATY) \
    || defined(UART2_NIT_ATY) \
    || defined(UART3_NIT_ATY) \
    || defined(UART4_NIT_ATY) \
    || defined(UART5_NIT_ATY)
/**
* @brief Rewrite uart rx interrupt call-back function
* @param huart      - huart
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
#ifdef UART1_NIT_ATY
    if(huart==&huart1)
    {
        Uart1Recv();
    }
#endif  /* UART1_NIT_ATY */

#ifdef UART2_NIT_ATY
    if(huart==&huart2)
    {
        Uart2Recv();
    }
#endif  /* UART2_NIT_ATY */

#ifdef UART3_NIT_ATY
    if(huart==&huart3)
    {
        Uart3Recv();
    }
#endif  /* UART3_NIT_ATY */

#ifdef UART4_NIT_ATY
    if(huart==&huart4)
    {
        Uart4Recv();
    }
#endif  /* UART4_NIT_ATY */

#ifdef UART5_NIT_ATY
    if(huart==&huart5)
    {
        Uart5Recv();
    }
#endif  /* UART5_NIT_ATY */
}
#endif  /* UART1-5_NIT_ATY */


#ifdef TEST_NIT_ATY
/**
* @brief A template function of using uart raceive
* @brief 50ms is the min interval time when tested at 9600 baud rate
*/
void UartControlTemplate(void)
{
    HAL_UART_Receive_IT(&HUART_N, &uartByte, 1);
    if(uartBufCount>0)
    {
        if(memcmp(uartBuf, "Hello STM32F1!", 14)==0)
        {
            printf("Getted! - printf\n");
            UartSend("Getted! - send\n", 15);
            uartBufCount=0;
            memset(uartBuf, 0, sizeof(uartBuf));
        }
    }
}
#endif  /* TEST_NIT_ATY */


/******************************** DMA IT Type *********************************/
#if defined(UART1_DMA_ATY) \
    || defined(UART2_DMA_ATY) \
    || defined(UART3_DMA_ATY) \
    || defined(UART4_DMA_ATY) \
    || defined(UART5_DMA_ATY)
/**
* @brief Uart tx DMA interrupt call back
* @param huart      - huart
*/
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
#ifdef UART1_DMA_ATY
    if(huart==&huart1)
        uart1Ready=SET;
#endif  /* UART1_DMA_ATY */

#ifdef UART2_DMA_ATY
    if(huart==&huart2)
        uart2Ready=SET;
#endif  /* UART2_DMA_ATY */

#ifdef UART3_DMA_ATY
    if(huart==&huart3)
        uart3Ready=SET;
#endif  /* UART3_DMA_ATY */

#ifdef UART4_DMA_ATY
    if(huart==&huart4)
        uart4Ready=SET;
#endif  /* UART4_DMA_ATY */

#ifdef UART5_DMA_ATY
    if(huart==&huart5)
        uart5Ready=SET;
#endif  /* UART5_DMA_ATY */
}
/**
* @brief Uart tx DMA interrupt call back
* @param huart      - huart
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
#ifdef UART1_DMA_ATY
    if(huart==&huart1)
        uart1Ready=SET;
#endif  /* UART1_DMA_ATY */

#ifdef UART2_DMA_ATY
    if(huart==&huart2)
        uart2Ready=SET;
#endif  /* UART2_DMA_ATY */

#ifdef UART3_DMA_ATY
    if(huart==&huart3)
        uart3Ready=SET;
#endif  /* UART3_DMA_ATY */

#ifdef UART4_DMA_ATY
    if(huart==&huart4)
        uart4Ready=SET;
#endif  /* UART4_DMA_ATY */

#ifdef UART5_DMA_ATY
    if(huart==&huart5)
        uart5Ready=SET;
#endif  /* UART5_DMA_ATY */
}
#endif  /* UART1-5_DMA_ATY */


#ifdef UART1_DMA_ATY
/**
* @brief Send data with DMA
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart1SendDMA(uint8_t *pData, uint16_t Size)
{
    if(HAL_UART_Transmit_DMA(&huart1, pData, Size)!=HAL_OK)
    {
        Error_Handler();
    }
    while(uart1Ready!=SET){}
    uart1Ready=RESET;
    uart1DmaSendFlag=0;
}
/**
* @brief Uart interrupt function, use to get data
*/
void USART1_IRQHandler(void)                    //\Src\stm32f1xx_it.c
{
    uint32_t tmpFlag=0;
    uint32_t temp;
    tmpFlag=__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE);
    if((tmpFlag!=RESET))
    {
        __HAL_UART_CLEAR_IDLEFLAG(&huart1);
        temp=huart1.Instance->SR;
        temp=huart1.Instance->DR;
        HAL_UART_DMAStop(&huart1);
        temp=hdma_usart1_rx.Instance->CNDTR;
        uart1GetCount=UART1_GET_SIZE-temp;
        uart1RecvEndFlag=1;
    }
    HAL_UART_IRQHandler(&huart1);
    HAL_UART_Receive_DMA(&huart1, uart1GetStr, UART1_GET_SIZE);
}
#endif  /* UART1_DMA_ATY */


#ifdef UART2_DMA_ATY
/**
* @brief Send data with DMA
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart2SendDMA(uint8_t *pData, uint16_t Size)
{
    if(HAL_UART_Transmit_DMA(&huart2, pData, Size)!=HAL_OK)
    {
        Error_Handler();
    }
    while(uart2Ready!=SET){}
    uart2Ready=RESET;
    uart2DmaSendFlag=0;
}
/**
* @brief Uart interrupt function, use to get data
*/
void USART2_IRQHandler(void)                    //\Src\stm32f1xx_it.c
{
    uint32_t tmpFlag=0;
    uint32_t temp;
    tmpFlag=__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE);
    if((tmpFlag!=RESET))
    {
        __HAL_UART_CLEAR_IDLEFLAG(&huart2);
        temp=huart2.Instance->SR;
        temp=huart2.Instance->DR;
        HAL_UART_DMAStop(&huart2);
        temp=hdma_usart2_rx.Instance->CNDTR;
        uart2GetCount=UART2_GET_SIZE-temp;
        uart2RecvEndFlag=1;
    }
    HAL_UART_IRQHandler(&huart2);
    HAL_UART_Receive_DMA(&huart2, uart2GetStr, UART2_GET_SIZE);
}
#endif  /* UART2_DMA_ATY */


#ifdef UART3_DMA_ATY
/**
* @brief Send data with DMA
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart3SendDMA(uint8_t *pData, uint16_t Size)
{
    if(HAL_UART_Transmit_DMA(&huart3, pData, Size)!=HAL_OK)
    {
        Error_Handler();
    }
    while(uart3Ready!=SET){}
    uart3Ready=RESET;
    uart3DmaSendFlag=0;
}
/**
* @brief Uart interrupt function, use to get data
*/
void USART3_IRQHandler(void)                    //\Src\stm32f1xx_it.c
{
    uint32_t tmpFlag=0;
    uint32_t temp;
    tmpFlag=__HAL_UART_GET_FLAG(&huart3, UART_FLAG_IDLE);
    if((tmpFlag!=RESET))
    {
        __HAL_UART_CLEAR_IDLEFLAG(&huart3);
        temp=huart3.Instance->SR;
        temp=huart3.Instance->DR;
        HAL_UART_DMAStop(&huart3);
        temp=hdma_usart3_rx.Instance->CNDTR;
        uart3GetCount=UART3_GET_SIZE-temp;
        uart3RecvEndFlag=1;
    }
    HAL_UART_IRQHandler(&huart3);
    HAL_UART_Receive_DMA(&huart3, uart3GetStr, UART3_GET_SIZE);
}
#endif  /* UART3_DMA_ATY */


#ifdef UART4_DMA_ATY
/**
* @brief Send data with DMA
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart4SendDMA(uint8_t *pData, uint16_t Size)
{
    if(HAL_UART_Transmit_DMA(&huart4, pData, Size)!=HAL_OK)
    {
        Error_Handler();
    }
    while(uart4Ready!=SET){}
    uart4Ready=RESET;
    uart4DmaSendFlag=0;
}
/**
* @brief Uart interrupt function, use to get data
*/
void USART4_IRQHandler(void)                    //\Src\stm32f1xx_it.c
{
    uint32_t tmpFlag=0;
    uint32_t temp;
    tmpFlag=__HAL_UART_GET_FLAG(&huart4, UART_FLAG_IDLE);
    if((tmpFlag!=RESET))
    {
        __HAL_UART_CLEAR_IDLEFLAG(&huart4);
        temp=huart4.Instance->SR;
        temp=huart4.Instance->DR;
        HAL_UART_DMAStop(&huart4);
        temp=hdma_usart4_rx.Instance->CNDTR;
        uart4GetCount=UART4_GET_SIZE-temp;
        uart4RecvEndFlag=1;
    }
    HAL_UART_IRQHandler(&huart4);
    HAL_UART_Receive_DMA(&huart4, uart4GetStr, UART4_GET_SIZE);
}
#endif  /* UART4_DMA_ATY */


#ifdef UART5_DMA_ATY
/**
* @brief Send data with DMA
* @param pData      - Data to send
* @param Size       - Size of data
*/
void Uart5SendDMA(uint8_t *pData, uint16_t Size)
{
    if(HAL_UART_Transmit_DMA(&huart5, pData, Size)!=HAL_OK)
    {
        Error_Handler();
    }
    while(uart5Ready!=SET){}
    uart5Ready=RESET;
    uart5DmaSendFlag=0;
}
/**
* @brief Uart interrupt function, use to get data
*/
void USART5_IRQHandler(void)                    //\Src\stm32f1xx_it.c
{
    uint32_t tmpFlag=0;
    uint32_t temp;
    tmpFlag=__HAL_UART_GET_FLAG(&huart5, UART_FLAG_IDLE);
    if((tmpFlag!=RESET))
    {
        __HAL_UART_CLEAR_IDLEFLAG(&huart5);
        temp=huart5.Instance->SR;
        temp=huart5.Instance->DR;
        HAL_UART_DMAStop(&huart5);
        temp=hdma_usart5_rx.Instance->CNDTR;
        uart5GetCount=UART5_GET_SIZE-temp;
        uart5RecvEndFlag=1;
    }
    HAL_UART_IRQHandler(&huart5);
    HAL_UART_Receive_DMA(&huart5, uart5GetStr, UART5_GET_SIZE);
}
#endif  /* UART5_DMA_ATY */


#ifdef TEST_DMA_ATY
/**
* @brief A template function of using uart raceive with DMA
* @brief 50ms is the min interval time when tested at 9600 baud rate;
*        shorter time is unstable, but better than narmal IT type
*/
void UartControlTemplate(void)
{
    if(uart1RecvEndFlag)
    {
        if(memcmp(uart1GetStr, "Hello STM32F1!", 14)==0)
        {
            printf("Getted! - printf\n");
            Uart1SendDMA("Getted! - send\n", 15);
            memset(uart1GetStr, 0, sizeof(uart1GetStr));
            uart1GetCount=0;
        }
        uart1RecvEndFlag=0;
    }
}
#endif  /* TEST_DMA_ATY */


#endif  /* __UART_ATY_H */

/******************************** End Of File *********************************/

UARTIO_ATY.h - 整理中

/**
* @file UARTIO_ATY.h
* @par Project
*       - ATYSTMLIB_HAL
*
* @author
*       - ATY
*
* @copyright
*       - Copyright © 2020 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*       - 您的使用行为将视为已接受本声明各项条款。
*
* @par Descriptions
*       - Familiar functions of CRC for all codes
*
* @par Update
*       - 1_01_20722 > ATY
*           -# Preliminary version, first Release
**********************************************************************************
*/

#ifndef __UART_ATY_H
#define __UART_ATY_H

#include "stm32f1xx_hal.h"
#include "stdio.h"                      //For "FILE"
#include "string.h"                     //For memset etc.


/******************************* For user *************************************/

/******************************************************************************/

#endif  /* __UART_ATY_H */

/******************************** End Of File *********************************/