new year first

AD5245_ATY.c

@@ -21,6 +21,10 @@
 * @version
 *       - 1_01_220927 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
@@ -35,28 +39,80 @@
 
 /**
  * @brief   set AD5245 value
+ *
  * @param   value value of resistor
+ * @param   dev device
+ * @return  uint8_t
  */
-void AD5245_SetValue(uint8_t value)
+uint8_t AD5245_SetValue(uint8_t value, struct AD5245_ATY_Dev* dev)
 {
+    uint8_t errCode = 0;
     uint8_t data_t[2] = {0};
-    data_t[0] = 0;
-    data_t[1] = value;
-    // data_t[1] = (0xFF - value);
-    I2C_Write(AD5245_ADDRESS, data_t, 2);
-#ifdef __DEBUG_AD5245_ATY
-    printf("\r\nAD5245 ResSet:  %03d | %1.5fKOhm", value, (0xFF - value) * 1.0 * 10 / 256);
-    printf("\r\nAD5245 set:     %03d | %03d", data_t[0], data_t[1]);
-#endif /* __DEBUG_AD5245_ATY */
-#ifdef AD5245_READBACK
-    I2C_Read(AD5245_ADDRESS, data_t, 2);
-#endif /* AD5245_READBACK */
-#ifdef __DEBUG_AD5245_ATY
-    printf("\r\nAD5245 receive: %03d | %03d", data_t[0], data_t[1]);
-#endif /* __DEBUG_AD5245_ATY */
+    __ATY_LOCK(dev);
+    // data_t[1] = value;
+    data_t[1] = (0xFF - value);
+
+    if(dev->addr != 0x2C && dev->addr != 0x2D)
+        dev->addr = (0x2C | dev->ad0);
+
+    errCode = dev->i2cProcess(dev->addr, data_t, 2, _ATY_RW_W);
+
+    if(dev->debugEnable == 1){
+        dev->LOG("\r\nAD5245 %02X ResSet:  %03d | %d Ohm", dev->addr, value, (uint16_t)(((0xFF - value) * 1.0f * 10.0f / 256.0f) * 1000));
+        dev->LOG("\r\nAD5245 %02X set : %03d | %03d", dev->addr, data_t[0], data_t[1]);
+    }
+    __ATY_UNLOCK(dev);
+    return errCode;
 }
 
+/**
+ * @brief   get AD5245 value
+ *
+ * @param   value value of resistor
+ * @param   dev device
+ * @return  uint8_t
+ */
+uint8_t AD5245_GetValue(uint8_t* value, struct AD5245_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    uint8_t data_t[2] = {0};
+    __ATY_LOCK(dev);
+    if(dev->addr != 0x2C && dev->addr != 0x2D)
+        dev->addr = (0x2C | dev->ad0);
+
+    errCode = dev->i2cProcess(dev->addr, data_t, 2, _ATY_RW_R);
+    *value = data_t[1];
+
+    if(dev->debugEnable == 1)
+        dev->LOG("\r\nAD5245 %02X receive: %03d | %03d", dev->addr, data_t[0], data_t[1]);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
 
 #endif /* __AD5245_ATY_C */
 
+/************************************ etc *************************************/
+// void LOG_ALL(uint8_t* str){ printf((const char*)str); }
+
+/* init */
+// uint8_t AD5245_1_I2C(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W)
+//         return (uint8_t)HAL_I2C_Master_Transmit(&hi2c1, (addr << 1 | 0), data_t, len, 1000);
+//     else if(rw == _ATY_RW_R)
+//         return (uint8_t)HAL_I2C_Master_Receive(&hi2c1, (addr << 1 | 1), data_t, len, 1000);
+// }
+
+// struct AD5245_ATY_Dev AD5245_ATY_t_1 = {
+//     .addr = AD5245_ADDRESS,
+//     .i2cProcess = AD5245_1_I2C,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+
+/* use */
+// AD5245_SetValue(0xF0, &AD5245_ATY_t_1);
+// AD5245_GetValue(&getValue, &AD5245_ATY_t_1);
+/******************************************************************************/
+
 /******************************** End Of File *********************************/

AD5245_ATY.h

@@ -21,6 +21,10 @@
 * @version
 *       - 1_01_220927 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
@@ -28,24 +32,30 @@
 #define __AD5245_ATY_H
 
 #include "INCLUDE_ATY.h"
-#include "HW_I2C_ATY.h"
 
 /******************************* For user *************************************/
 // Set AD0 voltage level for device address
 #define AD5245_AD0 1
-
-#define AD5245_READBACK
-
-#define __DEBUG_AD5245_ATY
+// 0 1 0 1 1 0 AD0 R/W
+#define AD5245_ADDRESS  (0x2C | AD5245_AD0)
 
 /******************************************************************************/
 
+struct AD5245_ATY_Dev
+{
+    uint8_t ad0;
+    uint8_t addr;
 
-// 0 1 0 1 1 0 AD0 R/W
-#define AD5245_ADDRESS  (0x2C | AD5245_AD0)
+    uint8_t(*i2cProcess)(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    int (*LOG)();
+};
 
-void AD5245_SetValue(uint8_t value);
 
+uint8_t AD5245_SetValue(uint8_t value, struct AD5245_ATY_Dev* dev);
+uint8_t AD5245_GetValue(uint8_t* value, struct AD5245_ATY_Dev* dev);
 
 
 #endif /* __AD5245_ATY_H */

AD5933_ATY.c

@@ -0,0 +1,195 @@
+/**
+* @file AD5933_ATY.c
+*
+* @param Project DEVICE_GENERAL_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of AD5933 for all embedded device
+*
+* @version
+*       - 1_01_24015 > ATY
+*           -# Preliminary version, first Release
+********************************************************************************
+*/
+
+#ifndef __AD5933_ATY_C
+#define __AD5933_ATY_C
+
+#include "AD5933_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+
+uint8_t AD5933_Write(uint8_t addr, uint8_t* data_t, uint8_t len, struct AD5933_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    __ATY_LOCK(dev);
+    errCode = dev->i2cProcess(dev->addr, data_t, len, _ATY_RW_W);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+uint8_t AD5933_Read(uint8_t addr, uint8_t* data_t, uint8_t len, struct AD5933_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    __ATY_LOCK(dev);
+    errCode = dev->i2cProcess(dev->addr, data_t, len, _ATY_RW_R);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+uint8_t AD5933_WriteReg(uint8_t reg, uint8_t data, struct AD5933_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    uint8_t data_t[2] = {reg, data};
+    errCode = AD5933_Write(dev->addr, data_t, 2, dev);
+    return errCode;
+}
+
+uint8_t AD5933_ReadReg(uint8_t reg, uint8_t* data, struct AD5933_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    uint8_t data_t[2] = {reg, 0xB0};
+    errCode = AD5933_Write(dev->addr, data_t, 2, dev);
+    errCode = AD5933_Read(dev->addr, data_t, 2, dev);
+    *data = data_t[1];
+    return errCode;
+}
+void AD5933_Init(struct AD5933_ATY_Dev* dev)
+{
+    // Transmit	to start frequency register
+    // program 30khz start frequency assuming internal osc of 16.776Khz
+    AD5933_WriteReg(0x84, 0x45, dev);
+    AD5933_WriteReg(0x83, 0xA6, dev);
+    AD5933_WriteReg(0x82, 0x0E, dev);
+
+    // Transmit to frequency increment register
+    // program 1Khz frequency increment assuming internal osc of 16.776Khz
+    AD5933_WriteReg(0x87, 0x02, dev);
+    AD5933_WriteReg(0x86, 0x7D, dev);
+    AD5933_WriteReg(0x85, 0x00, dev);
+
+    // Transmit to NUMBER OF INCREMENTS register
+    // program 10 frequency increments
+    AD5933_WriteReg(0x89, 0x0A, dev);
+    AD5933_WriteReg(0x88, 0x00, dev);
+
+    // Transmit to settling time cycles register
+    // program 15 output cycles at each frequency before a adc conversion
+    AD5933_WriteReg(0x8B, 0x0F, dev);
+    AD5933_WriteReg(0x8A, 0x00, dev);
+
+
+    // Transmit to CONTROL register
+    // place the AD5933 in standby mode
+    AD5933_WriteReg(0x80, 0xB0, dev);
+
+    // Choose the internal system clock
+    AD5933_WriteReg(0x81, 0x00, dev);
+
+    // Choose range 1 (2vp-p, 1.6v) PGA = x1
+    AD5933_WriteReg(0x80, 0x01, dev);
+
+    // initialise the sensor with contents of start frequency regsister with range 1 (2vp-p, 1.6v) PGA = x1
+    AD5933_WriteReg(0x80, 0x10, dev);
+    // start of frequency swee, devp  (2vp-p, 1.6v) PGA = x1
+    AD5933_WriteReg(0x80, 0x20, dev);
+    // initialise the sweep sequence
+    AD5933_Measure(dev);
+
+    // //issue a measure temperature command to the control register
+    // AD5933_WriteReg(0x80, 0x90, dev);
+    // // read the temperature data and send to uart
+    // Measure_Temp(dev);
+
+}
+
+// status reg D0 = valid temp, D1 = valid real/imag data, D2 = frequency sweep complete
+void AD5933_Measure(struct AD5933_ATY_Dev* dev)
+{
+    while(1){
+        // D1 status reg loop
+        uint8_t status = 0;
+        AD5933_ReadReg(0x8F, &status, dev);
+        status = (status & 0x02);                // mask off the valid data bit
+        for(uint16_t i = 0; i < 10000; i++){}
+        // printf("Status: %02X\r\n", status);
+        if(((status) | 0xFD) == 0xFF)  // valid data should be present after start freqy command
+        {
+            // D1 true condition
+            AD5933_ReadReg(0x8F, &status, dev);
+            if((status | 0xFB) != 0xFF)// D2 test condition
+            {
+                uint8_t real_byte_high = 0, real_byte_low = 0, imag_byte_high = 0, imag_byte_low = 0;
+                AD5933_ReadReg(0x94, &real_byte_high, dev);
+                AD5933_ReadReg(0x95, &real_byte_low, dev);
+                AD5933_ReadReg(0x96, &imag_byte_high, dev);
+                AD5933_ReadReg(0x97, &imag_byte_low, dev);
+
+                uint16_t real_data = ((real_byte_high << 8) | real_byte_low);
+                uint16_t imag_data = ((imag_byte_high << 8) | imag_byte_low);
+
+                // printf("Original real register = 0x%02x\r\n", (unsigned int)((unsigned short)real_data));
+                // printf("Orocessed real register = %d(decimal equivilant)\r\n", (int)real_data);
+
+                // printf("Original imag register = 0x%02X\r\n", (unsigned int)((unsigned short)imag_data));
+                // printf("Orocessed imag register = %d(decimal equivilant)\r\n", (int)imag_data);
+
+                printf("%d %d\r\n", (uint16_t)real_data, (uint16_t)imag_data);
+
+                // increment to the next frequency
+                status = 0x30;
+                AD5933_WriteReg(0x80, status, dev);
+
+            }
+            else // End of frequency sweep exit loop
+            {
+                // printf("Status: %02X\r\n", status);
+                // printf("end sweep\r\n");
+                break;
+            }
+        }
+    }
+}
+
+#endif /* __AD5933_ATY_C */
+
+/************************************ etc *************************************/
+// void LOG_ALL(uint8_t* str){ printf((const char*)str); }
+
+/* init */
+// uint8_t AD5933_1_I2C(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W)
+//         return (uint8_t)HAL_I2C_Master_Transmit(&hi2c1, (addr << 1 | 0), data_t, len, 1000);
+//     else if(rw == _ATY_RW_R)
+//         return (uint8_t)HAL_I2C_Master_Receive(&hi2c1, (addr << 1 | 1), data_t, len, 1000);
+// }
+
+// struct AD5933_ATY_Dev AD5933_ATY_t_1 = {
+//     .addr = AD5933_ADDRESS,
+//     .i2cProcess = AD5933_1_I2C,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+
+/* use */
+// AD5933_SetValue(0xF0, &AD5933_ATY_t_1);
+// AD5933_GetValue(&getValue, &AD5933_ATY_t_1);
+/******************************************************************************/
+
+/******************************** End Of File *********************************/

AD5933_ATY.h

@@ -0,0 +1,138 @@
+/**
+* @file AD5933_ATY.h
+*
+* @param Project DEVICE_GENERAL_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of AD5933 for all embedded device
+*
+* @version
+*       - 1_01_24015 > ATY
+*           -# Preliminary version, first Release
+********************************************************************************
+*/
+
+#ifndef __AD5933_ATY_H
+#define __AD5933_ATY_H
+
+#include "INCLUDE_ATY.h"
+
+/******************************* For user *************************************/
+// 0 0 0 1 1 0 1 R/W
+#define AD5933_ADDRESS  (0x0D)
+
+/******************************************************************************/
+
+struct AD5933_ATY_Dev
+{
+    uint8_t addr;
+
+    uint8_t(*i2cProcess)(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    int (*LOG)();
+};
+
+
+void AD5933_Init(struct AD5933_ATY_Dev* dev);
+void AD5933_Measure(struct AD5933_ATY_Dev* dev);
+
+
+// Device address and address pointer
+#define AD5933_ADDR     (0x0D)
+#define ADDR_PTR        (0xB0)
+// Control Register
+#define CTRL_REG1       (0x80)
+#define CTRL_REG2       (0x81)
+// Start Frequency Register
+#define START_FREQ_1    (0x82)
+#define START_FREQ_2    (0x83)
+#define START_FREQ_3    (0x84)
+// Frequency increment register
+#define INC_FREQ_1      (0x85)
+#define INC_FREQ_2      (0x86)
+#define INC_FREQ_3      (0x87)
+// Number of increments register
+#define NUM_INC_1       (0x88)
+#define NUM_INC_2       (0x89)
+// Number of settling time cycles register
+#define NUM_SCYCLES_1   (0x8A)
+#define NUM_SCYCLES_2   (0x8B)
+// Status register
+#define STATUS_REG      (0x8F)
+// Temperature data register
+#define TEMP_DATA_1     (0x92)
+#define TEMP_DATA_2     (0x93)
+// Real data register
+#define REAL_DATA_1     (0x94)
+#define REAL_DATA_2     (0x95)
+// Imaginary data register
+#define IMAG_DATA_1     (0x96)
+#define IMAG_DATA_2     (0x97)
+
+/**
+ * Constants
+ *  Constants for use with the AD5933 library class.
+ */
+// Temperature measuring
+#define TEMP_MEASURE    (CTRL_TEMP_MEASURE)
+#define TEMP_NO_MEASURE (CTRL_NO_OPERATION)
+// Clock sources
+#define CLOCK_INTERNAL  (CTRL_CLOCK_INTERNAL)
+#define CLOCK_EXTERNAL  (CTRL_CLOCK_EXTERNAL)
+// PGA gain options
+#define PGA_GAIN_X1     (CTRL_PGA_GAIN_X1)
+#define PGA_GAIN_X5     (CTRL_PGA_GAIN_X5)
+// Power modes
+#define POWER_STANDBY   (CTRL_STANDBY_MODE)
+#define POWER_DOWN      (CTRL_POWER_DOWN_MODE)
+#define POWER_ON        (CTRL_NO_OPERATION)
+// I2C result success/fail
+#define I2C_RESULT_SUCCESS       (0)
+#define I2C_RESULT_DATA_TOO_LONG (1)
+#define I2C_RESULT_ADDR_NAK      (2)
+#define I2C_RESULT_DATA_NAK      (3)
+#define I2C_RESULT_OTHER_FAIL    (4)
+// Control output voltage range options
+#define CTRL_OUTPUT_RANGE_1		(0b00000000)
+#define CTRL_OUTPUT_RANGE_2		(0b00000110)
+#define CTRL_OUTPUT_RANGE_3		(0b00000100)
+#define CTRL_OUTPUT_RANGE_4		(0b00000010)
+// Control register options
+#define CTRL_NO_OPERATION       (0b00000000)
+#define CTRL_INIT_START_FREQ    (0b00010000)
+#define CTRL_START_FREQ_SWEEP   (0b00100000)
+#define CTRL_INCREMENT_FREQ     (0b00110000)
+#define CTRL_REPEAT_FREQ        (0b01000000)
+#define CTRL_TEMP_MEASURE       (0b10010000)
+#define CTRL_POWER_DOWN_MODE    (0b10100000)
+#define CTRL_STANDBY_MODE       (0b10110000)
+#define CTRL_RESET              (0b00010000)
+#define CTRL_CLOCK_EXTERNAL     (0b00001000)
+#define CTRL_CLOCK_INTERNAL     (0b00000000)
+#define CTRL_PGA_GAIN_X1        (0b00000001)
+#define CTRL_PGA_GAIN_X5        (0b00000000)
+// Status register options
+#define STATUS_TEMP_VALID       (0x01)
+#define STATUS_DATA_VALID       (0x02)
+#define STATUS_SWEEP_DONE       (0x04)
+#define STATUS_ERROR            (0xFF)
+// Frequency sweep parameters
+#define SWEEP_DELAY             (1)
+
+#endif /* __AD5933_ATY_H */
+
+/******************************** End Of File *********************************/

AD7124_ATY.c

@@ -21,7 +21,10 @@
 * @version
 *       - 1_01_230828 > ATY
 *           -# Preliminary version, first Release
-*       - Undone
+*       - 1_02_231229 > ATY
+*           -# add multy addr and dev->channel
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
@@ -34,7 +37,657 @@
 
 /******************************************************************************/
 
+/**
+ * @brief
+ *
+ * @param   data
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_WriteRead(uint8_t* data, uint8_t len, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    __ATY_LOCK(dev);
+    dev->nssSet(_ATY_HL_L);
+    if(dev->debugEnable == 1){
+        for(int i = 0; i < len; i++) dev->LOG("%02X", data[i]);
+        dev->LOG(" ");
+    }
+    errCode = dev->spiProcess(data, len, _ATY_RW_RW);
+    if(dev->debugEnable == 1){
+        for(int i = 0; i < len; i++) dev->LOG("%02X", data[i]);
+        dev->LOG(" ");
+    }
+    dev->nssSet(_ATY_HL_H);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+
+/**
+ * @brief
+ *
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_Reset(struct AD7124_ATY_Dev* dev)
+{
+    uint8_t errCode = 0, resetBuf[9] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    __ATY_LOCK(dev);
+    dev->syncSet(_ATY_HL_H);
+    // dev->delay(10);
+    dev->nssSet(_ATY_HL_H);
+    dev->delay(10);
+    __ATY_UNLOCK(dev);
+
+    // write more than 64 bits to reset AD7124
+    errCode = AD7124_WriteRead(resetBuf, 9, dev);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   id
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_ReadId(uint8_t* id, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t errCode = 0, groupTrans[2] = {0};
+    groupTrans[0] = 0x45;
+    groupTrans[1] = 0;
+    errCode = AD7124_WriteRead(groupTrans, 2, dev);
+    dev->id = groupTrans[1];
+    *id = dev->id;
+    if(dev->debugEnable == 1)
+        dev->LOG("AD7124_ID: %02X\r\n", dev->id);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   regAddr
+ * @param   data
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
+ * @note    AD7124_ERR_REG_SPI_IGNORE_ERR only for crc trans
+ */
+uint8_t AD7124_WriteReg(uint8_t regAddr, uint32_t data, uint8_t len, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t errCode = 0, i = 0, groupTrans[4] = {0};
+    groupTrans[0] = AD7124_COMM_REG_WA(regAddr);
+    for(i = 0; i < len; i++){
+        groupTrans[len - i] = data & 0xFF;
+        data = data >> 8;
+    }
+    if(dev->debugEnable == 1){
+        for(i = 0; i < len + 1; i++)
+            dev->LOG("%02X", groupTrans[i]);
+        dev->LOG(" ");
+    }
+    errCode = AD7124_WriteRead(groupTrans, len + 1, dev);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   regAddr
+ * @param   data
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_ReadReg(uint8_t regAddr, uint32_t* data, uint8_t len, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t errCode = 0, i = 0, groupTrans[4] = {0};
+    groupTrans[0] = AD7124_COMM_REG_RA(regAddr);
+    errCode = AD7124_WriteRead(groupTrans, len + 1, dev);
+    if(len == 1)
+        *data = groupTrans[1];
+    else if(len == 2)
+        *data = (groupTrans[1] + (groupTrans[2] << 8));
+    else if(len == 3)
+        *data = (groupTrans[1] + (groupTrans[2] << 8) + (groupTrans[3] << 16));
+    if(dev->debugEnable == 1){
+        for(i = 0; i < len + 1; i++)
+            dev->LOG("%X", data);
+        dev->LOG(" ");
+    }
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   data
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_ReadData(uint8_t* data, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t errCode = 0, i = 0;
+    data[0] = AD7124_COMM_REG_RA(AD7124_DATA_REG);
+    errCode = AD7124_WriteRead(data, 5, dev);
+    if(dev->debugEnable == 1){
+        dev->LOG("Data: 0x");
+        for(i = 0; i < 5; i++)
+            dev->LOG("%02X", data[i]);
+        dev->LOG(" ");
+    }
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   status
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_ReadStatus(uint8_t* status, struct AD7124_ATY_Dev* dev)
+{
+    if(AD7124_ReadReg(AD7124_STATUS_REG, (uint32_t*)status, 1, dev)){
+        if(dev->debugEnable == 1)
+            dev->LOG("AD7124_ERR: STATE %02X%02X\r\n",
+                status[0], status[1]);
+        return 1;
+    }
+    dev->delay(10);
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   data
+ * @param   resolution
+ * @param   refRes
+ * @param   gain
+ * @return  float
+ */
+float AD7124_DataToRes(uint32_t data, uint8_t resolution, float refRes, uint8_t gain)
+{
+    uint32_t tempNum = 1;
+    uint8_t i = 0;
+    for(i = 0; i < resolution - 1; i++)
+        tempNum *= 2;
+    return (float)((((float)data - (float)tempNum) * refRes) / ((float)gain * (float)tempNum));
+}
+
+/**
+ * @brief
+ *
+ * @param   data
+ * @return  float
+ */
+float AD7124_DataToResDefault(uint32_t data)
+{
+    return (float)((((float)data - 8388608.0f) * 5110.0f) / (16.0f * 8388608.0f));
+}
+
+/**
+ * @brief
+ *
+ * @param   cfg
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_Init(struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t id = 0, status[2] = {0};
+    dev->enSet(_ATY_HL_H);
+    if(AD7124_Reset(dev)){
+        if(dev->debugEnable == 1)
+            dev->LOG("AD7124_ERR: RST\r\n");
+        return 1;
+    }
+    if(AD7124_ReadId(&id, dev)){
+        if(dev->debugEnable == 1)
+            dev->LOG("AD7124_ERR: ID\r\n");
+        return 2;
+    }
+    if(AD7124_ReadStatus(status, dev)){
+        if(dev->debugEnable == 1)
+            dev->LOG("AD7124_ERR: Status\r\n");
+        return 3;
+    }
+    if(AD7124_Config(cfg, dev)){
+        if(dev->debugEnable == 1)
+            dev->LOG("AD7124_ERR: CFG\r\n");
+        return 4;
+    }
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   cfg
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_Config(struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev)
+{
+    if(cfg->AD7124_ADC_CTRL_REG_t) AD7124_WriteReg(AD7124_ADC_CTRL_REG, cfg->AD7124_ADC_CTRL_REG_t, 2, dev);
+    if(cfg->AD7124_IO_CTRL1_REG_t) AD7124_WriteReg(AD7124_IO_CTRL1_REG, cfg->AD7124_IO_CTRL1_REG_t, 3, dev);
+    if(cfg->AD7124_IO_CTRL2_REG_t) AD7124_WriteReg(AD7124_IO_CTRL2_REG, cfg->AD7124_IO_CTRL2_REG_t, 2, dev);
+    if(cfg->AD7124_ERREN_REG_t) AD7124_WriteReg(AD7124_ERREN_REG, cfg->AD7124_ERREN_REG_t, 3, dev);
+
+    if(cfg->AD7124_CH0_MAP_REG_t) AD7124_WriteReg(AD7124_CH0_MAP_REG, cfg->AD7124_CH0_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH1_MAP_REG_t) AD7124_WriteReg(AD7124_CH1_MAP_REG, cfg->AD7124_CH1_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH2_MAP_REG_t) AD7124_WriteReg(AD7124_CH2_MAP_REG, cfg->AD7124_CH2_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH3_MAP_REG_t) AD7124_WriteReg(AD7124_CH3_MAP_REG, cfg->AD7124_CH3_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH4_MAP_REG_t) AD7124_WriteReg(AD7124_CH4_MAP_REG, cfg->AD7124_CH4_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH5_MAP_REG_t) AD7124_WriteReg(AD7124_CH5_MAP_REG, cfg->AD7124_CH5_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH6_MAP_REG_t) AD7124_WriteReg(AD7124_CH6_MAP_REG, cfg->AD7124_CH6_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH7_MAP_REG_t) AD7124_WriteReg(AD7124_CH7_MAP_REG, cfg->AD7124_CH7_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH8_MAP_REG_t) AD7124_WriteReg(AD7124_CH8_MAP_REG, cfg->AD7124_CH8_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH9_MAP_REG_t) AD7124_WriteReg(AD7124_CH9_MAP_REG, cfg->AD7124_CH9_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH10_MAP_REG_t) AD7124_WriteReg(AD7124_CH10_MAP_REG, cfg->AD7124_CH10_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH11_MAP_REG_t) AD7124_WriteReg(AD7124_CH11_MAP_REG, cfg->AD7124_CH11_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH12_MAP_REG_t) AD7124_WriteReg(AD7124_CH12_MAP_REG, cfg->AD7124_CH12_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH13_MAP_REG_t) AD7124_WriteReg(AD7124_CH13_MAP_REG, cfg->AD7124_CH13_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH14_MAP_REG_t) AD7124_WriteReg(AD7124_CH14_MAP_REG, cfg->AD7124_CH14_MAP_REG_t, 2, dev);
+    if(cfg->AD7124_CH15_MAP_REG_t) AD7124_WriteReg(AD7124_CH15_MAP_REG, cfg->AD7124_CH15_MAP_REG_t, 2, dev);
+
+    if(cfg->AD7124_CFG0_REG_t) AD7124_WriteReg(AD7124_CFG0_REG, cfg->AD7124_CFG0_REG_t, 2, dev);
+    if(cfg->AD7124_CFG1_REG_t) AD7124_WriteReg(AD7124_CFG1_REG, cfg->AD7124_CFG1_REG_t, 2, dev);
+    if(cfg->AD7124_CFG2_REG_t) AD7124_WriteReg(AD7124_CFG2_REG, cfg->AD7124_CFG2_REG_t, 2, dev);
+    if(cfg->AD7124_CFG3_REG_t) AD7124_WriteReg(AD7124_CFG3_REG, cfg->AD7124_CFG3_REG_t, 2, dev);
+    if(cfg->AD7124_CFG4_REG_t) AD7124_WriteReg(AD7124_CFG4_REG, cfg->AD7124_CFG4_REG_t, 2, dev);
+    if(cfg->AD7124_CFG5_REG_t) AD7124_WriteReg(AD7124_CFG5_REG, cfg->AD7124_CFG5_REG_t, 2, dev);
+    if(cfg->AD7124_CFG6_REG_t) AD7124_WriteReg(AD7124_CFG6_REG, cfg->AD7124_CFG6_REG_t, 2, dev);
+    if(cfg->AD7124_CFG7_REG_t) AD7124_WriteReg(AD7124_CFG7_REG, cfg->AD7124_CFG7_REG_t, 2, dev);
+
+    if(cfg->AD7124_FILT0_REG_t) AD7124_WriteReg(AD7124_FILT0_REG, cfg->AD7124_FILT0_REG_t, 3, dev);
+    if(cfg->AD7124_FILT1_REG_t) AD7124_WriteReg(AD7124_FILT1_REG, cfg->AD7124_FILT1_REG_t, 3, dev);
+    if(cfg->AD7124_FILT2_REG_t) AD7124_WriteReg(AD7124_FILT2_REG, cfg->AD7124_FILT2_REG_t, 3, dev);
+    if(cfg->AD7124_FILT3_REG_t) AD7124_WriteReg(AD7124_FILT3_REG, cfg->AD7124_FILT3_REG_t, 3, dev);
+    if(cfg->AD7124_FILT4_REG_t) AD7124_WriteReg(AD7124_FILT4_REG, cfg->AD7124_FILT4_REG_t, 3, dev);
+    if(cfg->AD7124_FILT5_REG_t) AD7124_WriteReg(AD7124_FILT5_REG, cfg->AD7124_FILT5_REG_t, 3, dev);
+    if(cfg->AD7124_FILT6_REG_t) AD7124_WriteReg(AD7124_FILT6_REG, cfg->AD7124_FILT6_REG_t, 3, dev);
+    if(cfg->AD7124_FILT7_REG_t) AD7124_WriteReg(AD7124_FILT7_REG, cfg->AD7124_FILT7_REG_t, 3, dev);
+
+    if(cfg->AD7124_OFFS0_REG_t) AD7124_WriteReg(AD7124_OFFS0_REG, cfg->AD7124_OFFS0_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS1_REG_t) AD7124_WriteReg(AD7124_OFFS1_REG, cfg->AD7124_OFFS1_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS2_REG_t) AD7124_WriteReg(AD7124_OFFS2_REG, cfg->AD7124_OFFS2_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS3_REG_t) AD7124_WriteReg(AD7124_OFFS3_REG, cfg->AD7124_OFFS3_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS4_REG_t) AD7124_WriteReg(AD7124_OFFS4_REG, cfg->AD7124_OFFS4_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS5_REG_t) AD7124_WriteReg(AD7124_OFFS5_REG, cfg->AD7124_OFFS5_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS6_REG_t) AD7124_WriteReg(AD7124_OFFS6_REG, cfg->AD7124_OFFS6_REG_t, 3, dev);
+    if(cfg->AD7124_OFFS7_REG_t) AD7124_WriteReg(AD7124_OFFS7_REG, cfg->AD7124_OFFS7_REG_t, 3, dev);
+
+    if(cfg->AD7124_GAIN0_REG_t) AD7124_WriteReg(AD7124_GAIN0_REG, cfg->AD7124_GAIN0_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN1_REG_t) AD7124_WriteReg(AD7124_GAIN1_REG, cfg->AD7124_GAIN1_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN2_REG_t) AD7124_WriteReg(AD7124_GAIN2_REG, cfg->AD7124_GAIN2_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN3_REG_t) AD7124_WriteReg(AD7124_GAIN3_REG, cfg->AD7124_GAIN3_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN4_REG_t) AD7124_WriteReg(AD7124_GAIN4_REG, cfg->AD7124_GAIN4_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN5_REG_t) AD7124_WriteReg(AD7124_GAIN5_REG, cfg->AD7124_GAIN5_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN6_REG_t) AD7124_WriteReg(AD7124_GAIN6_REG, cfg->AD7124_GAIN6_REG_t, 3, dev);
+    if(cfg->AD7124_GAIN7_REG_t) AD7124_WriteReg(AD7124_GAIN7_REG, cfg->AD7124_GAIN7_REG_t, 3, dev);
+
+    if(dev->debugEnable == 1)
+        dev->LOG("\r\n");
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   calibrateType b1111
+ * @param   cfg
+ * @param   dev
+ * @return  uint8_t
+ * @note    0001 int full cal at mid power
+            0010 int zero cal at full power
+            0100 sys full cal
+            1000 sys zero cal
+ */
+uint8_t AD7124_Calibrate(uint8_t calibrateType, struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev)
+{
+    uint32_t regTrans = 0;
+    AD7124_WriteReg(AD7124_OFFS0_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS1_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS2_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS3_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS4_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS5_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS6_REG, 0x800000, 3, dev);
+    AD7124_WriteReg(AD7124_OFFS7_REG, 0x800000, 3, dev);
+
+    if(calibrateType & AD7124_CALIBRATE_INT_FULL){
+        AD7124_WriteReg(AD7124_ADC_CTRL_REG, 0x0058, 2, dev);                   // int full cal at mid power
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+        dev->delay(1500);    // 1300ms min
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+    }
+    if(calibrateType & AD7124_CALIBRATE_INT_ZERO){
+        AD7124_WriteReg(AD7124_ADC_CTRL_REG, 0x0094, 2, dev);                   // int zero cal at full power
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+        dev->delay(100);     // 80ms min
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+    }
+    if(calibrateType & AD7124_CALIBRATE_SYS_FULL){
+        AD7124_WriteReg(AD7124_ADC_CTRL_REG, 0x00A0, 2, dev);                   // sys full cal
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+        dev->delay(100);     // 80ms min
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+    }
+    if(calibrateType & AD7124_CALIBRATE_SYS_ZERO){
+        AD7124_WriteReg(AD7124_ADC_CTRL_REG, 0x009C, 2, dev);                   // sys zero cal
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+        dev->delay(100);     // 80ms min
+        AD7124_ReadReg(AD7124_ADC_CTRL_REG, &regTrans, 2, dev);
+    }
+
+    AD7124_WriteReg(AD7124_ADC_CTRL_REG, cfg->AD7124_ADC_CTRL_REG_t, 2, dev);   // detect mode
+    if(dev->debugEnable == 1)
+        dev->LOG("\r\n");
+    dev->delay(1);
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t AD7124_ReadAllReg(struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev)
+{
+    uint8_t i = 0;
+    uint32_t* p = (uint32_t*)cfg;
+    if(dev->debugEnable == 1)
+        dev->LOG("Regs %d\r\n", (sizeof(struct AD7124_ATY_Cfg) / sizeof(uint32_t)));
+    for(i = 0; i < (sizeof(struct AD7124_ATY_Cfg) / sizeof(uint32_t)); i++){    // 0x00~0x38
+        if(dev->debugEnable == 1)
+            dev->LOG("Reg 0x%02X: ", i);
+        AD7124_ReadReg(i, (p + i), 3, dev);
+        if(dev->debugEnable == 1)
+            dev->LOG("\r\n");
+    }
+    // AD7124_ReadReg(AD7124_ADC_CTRL_REG, groupTrans, 2, dev);
+
+    if(dev->debugEnable == 1)
+        dev->LOG("\r\n");
+    return 0;
+}
 
 #endif /* __AD7124_ATY_C */
 
+/************************************ etc *************************************/
+/* init */
+// void AD7124_1_NSS_SET(uint8_t level){
+//     if(level == _ATY_HL_L)
+//         GPIO_SET_L(SPI2_NSS_GPIO_Port, SPI2_NSS_Pin);
+//     else if(level == _ATY_HL_H)
+//         GPIO_SET_H(SPI2_NSS_GPIO_Port, SPI2_NSS_Pin);
+// }
+// void AD7124_1_EN_SET(uint8_t level){ }
+// void AD7124_1_SYNC_SET(uint8_t level){ }
+// uint8_t AD7124_1_SPI(uint8_t* data_t, uint16_t len, uint8_t rw){
+//     if(rw == _ATY_RW_RW)
+//         return HAL_SPI_TransmitReceive(&hspi2, (uint8_t*)data_t, (uint8_t*)data_t, len, 1000);
+//     return 0;
+// }
+
+// struct AD7124_ATY_Dev AD7124_ATY_Dev_1 = {
+//     .id = 0,
+//     .nssSet = AD7124_1_NSS_SET,
+//     .enSet = AD7124_1_EN_SET,
+//     .syncSet = AD7124_1_SYNC_SET,
+//     .spiProcess = AD7124_1_SPI,
+//     .delay = HAL_Delay,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+// struct AD7124_ATY_Cfg AD7124_ATY_Cfg_RTD4_1 = {
+//     .AD7124_ADC_CTRL_REG_t = 0x0480,
+//     .AD7124_IO_CTRL1_REG_t = 0x000400,
+//     // .AD7124_ERREN_REG_t = 0x06FFFF,
+
+//     .AD7124_CFG0_REG_t = 0x09E4,
+//     .AD7124_FILT0_REG_t = 0x0060180,
+//     .AD7124_GAIN0_REG_t = 0x5558CC,
+//     .AD7124_CH0_MAP_REG_t = 0x9211, //IC Temp
+
+//     .AD7124_CFG1_REG_t = 0x09E4,
+//     .AD7124_FILT1_REG_t = 0x0060180,
+//     .AD7124_GAIN1_REG_t = 0x05558CC,
+//     .AD7124_CH1_MAP_REG_t = 0x9022,
+// };
+// struct AD7124_ATY_Cfg AD7124_ATY_Cfg_NTC1_1 = {
+//     .AD7124_ADC_CTRL_REG_t = 0x0480,
+//     .AD7124_IO_CTRL1_REG_t = 0x002040,
+
+//     .AD7124_CFG1_REG_t = 0x09E1,
+//     .AD7124_FILT1_REG_t = 0x0060180,
+//     .AD7124_GAIN1_REG_t = 0x05558CC,
+//     .AD7124_CH2_MAP_REG_t = 0x90A6,     // 500uA * 5.11K = 2.5Vref, 1K gain 2 max
+// };
+// struct AD7124_ATY_Cfg AD7124_ATY_Cfg_NTC10_1 = {
+//     .AD7124_ADC_CTRL_REG_t = 0x0580,
+
+//     .AD7124_CFG1_REG_t = 0x09F0,
+//     .AD7124_FILT1_REG_t = 0x0060180,
+//     .AD7124_GAIN1_REG_t = 0x5558CC,
+
+//     .AD7124_CH3_MAP_REG_t = 0x918D,
+//     .AD7124_CH4_MAP_REG_t = 0x91CF,
+// };
+// struct AD7124_ATY_Cfg AD7124_ATY_Cfg_TC_1 = {
+//     .AD7124_ADC_CTRL_REG_t = 0x0580,
+//     .AD7124_IO_CTRL2_REG_t = 0x0500,
+
+//     .AD7124_CFG1_REG_t = 0x09F7,
+//     .AD7124_FILT1_REG_t = 0x0060180,
+//     .AD7124_GAIN1_REG_t = 0x5558CC,
+
+//     .AD7124_CH5_MAP_REG_t = 0x9109,
+//     .AD7124_CH6_MAP_REG_t = 0x914B,
+// };
+
+
+/* use */
+// uint8_t group_AD7124_Data[5] = {0};
+// if(adInitFlag == 0){
+//     adInitFlag = 1;
+//     AD7124_Init(&AD7124_ATY_Cfg_RTD4_1, &AD7124_ATY_Dev_1);
+//     AD7124_Calibrate(AD7124_CALIBRATE_INT_FULL | AD7124_CALIBRATE_INT_ZERO,
+//         &AD7124_ATY_Cfg_RTD4_1, &AD7124_ATY_Dev_1);
+// }
+// AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+// AD7124_Calc(group_AD7124_Data);
+
+// // IC Temp
+// fastTempCalc = ((float)(ad7124Code - 0x800000) / 13584.0f) - 272.5f;
+
+// // RTD4
+// calcRes = AD7124_DataToRes(ad7124Code, 24, 5110.0f, 16);
+// fastTempCalc = ALGO_Temp_RTD_Res_Fast(calcRes);
+// aboveTempCalc = ALGO_Temp_RTD_Res_Above(calcRes);
+// belowTempCalc = ALGO_Temp_RTD_Res_Below(calcRes);
+
+// // NTC1K
+// calcRes = AD7124_DataToRes(ad7124Code, 24, 5110.0f, 2);
+// fastTempCalc = ALGO_ResToKelvinTemp((calcRes / 1000.0f), 1.0f, 3950);
+// // NTC10K
+// calcVol = (((float)ad7124Code - 8388608.0f) * 2500.0f / (1.0f * 8388608.0f));
+// calcRes = ((calcVol * 10.0f) / (2500.0f - calcVol));
+// fastTempCalc = ALGO_ResToKelvinTemp(calcRes, 10.0f, 3380);
+
+// // TC
+// calcVol = (((float)ad7124Code - 8388608.0f) * 2500.0f / (128.0f * 8388608.0f));
+// float coldTemp = 25.0f;
+// float calcVolCold = ALGO_Temp_TC_TempToVol('T', coldTemp);
+// calcVol += calcVolCold;
+// aboveTempCalc = ALGO_Temp_TC_VolToTemp('T', calcVol);
+// belowTempCalc = ALGO_Temp_TC_VolToTemp('T', calcVol);
+// fastTempCalc = aboveTempCalc;
+
+
+
+
+// ALGO_Kalman1D_S kfp1D_BT[2] = {{0, 0, 1, 1, 1, 1e-7, 1e-6}, {0, 0, 1, 1, 1, 1e-7, 1e-6}};
+// rcPara_t rcfp_BT[2] = {{0.02262, 0}, {0.036, 0}};
+// uint8_t group_AD7124_Data[5] = {0};
+
+// uint8_t adDetectType = 6;   // 0: IC temp, 1: RTD, 2: NTC1K, 34: NTC10K, 56: TC
+// uint8_t adInitFlag = 0;
+
+// void AD7124_Calc(uint8_t* codeGroup)
+// {
+//     if((codeGroup[4] & 0x80) != 0)
+//         return;
+
+//     if((codeGroup[4] & 0x0F) != adDetectType)
+//         return;
+
+//     uint32_t ad7124Code = (codeGroup[3] + (codeGroup[2] << 8) + (codeGroup[1] << 16));
+//     static uint32_t lastAd7124Code = 0;
+//     if(lastAd7124Code == ad7124Code)
+//         return;
+//     lastAd7124Code = ad7124Code;
+
+//     float calcVol = 0, calcRes = 0, fastTempCalc = 0, aboveTempCalc = 0, belowTempCalc = 0;
+//     if((codeGroup[4] & 0x0F) == 0){                                             // IC Temp
+//         fastTempCalc = ((float)(ad7124Code - 0x800000) / 13584.0f) - 272.5f;
+//     }
+//     if((codeGroup[4] & 0x0F) == 1){                                             // RTD4
+//         calcRes = AD7124_DataToRes(ad7124Code, 24, 5110.0f, 16);
+//         fastTempCalc = ALGO_Temp_RTD_Res_Fast(calcRes);
+//         aboveTempCalc = ALGO_Temp_RTD_Res_Above(calcRes);
+//         belowTempCalc = ALGO_Temp_RTD_Res_Below(calcRes);
+//     }
+//     if((codeGroup[4] & 0x0F) == 2){                                             // NTC1K
+//         calcRes = AD7124_DataToRes(ad7124Code, 24, 5110.0f, 2);
+//         fastTempCalc = ALGO_ResToKelvinTemp((calcRes / 1000.0f), 1.0f, 3950);
+//     }
+//     if(((codeGroup[4] & 0x0F) == 3) || ((codeGroup[4] & 0x0F) == 4)){           // NTC10K
+//         calcVol = (((float)ad7124Code - 8388608.0f) * 2500.0f / (1.0f * 8388608.0f));
+//         calcRes = ((calcVol * 10.0f) / (2500.0f - calcVol));
+//         if((codeGroup[4] & 0x0F) == 3)
+//             fastTempCalc = ALGO_ResToKelvinTemp(calcRes, 10.0f, 3380);
+//         else if((codeGroup[4] & 0x0F) == 4)
+//             fastTempCalc = ALGO_ResToKelvinTemp(calcRes, 10.0f, 3950);
+//     }
+//     if(((codeGroup[4] & 0x0F) == 5) || ((codeGroup[4] & 0x0F) == 6)){           // TC
+//         calcVol = (((float)ad7124Code - 8388608.0f) * 2500.0f / (128.0f * 8388608.0f));
+//         float coldTemp = 25.0f;
+//         float calcVolCold = ALGO_Temp_TC_TempToVol('T', coldTemp);
+//         calcVol += calcVolCold;
+//         aboveTempCalc = ALGO_Temp_TC_VolToTemp('T', calcVol);
+//         belowTempCalc = ALGO_Temp_TC_VolToTemp('T', calcVol);
+//         fastTempCalc = belowTempCalc;
+//     }
+
+//     float rcTemp[2] = {0};
+//     rcTemp[0] = rcLpFiter(&rcfp_BT[0], belowTempCalc);
+//     rcTemp[1] = rcLpFiter(&rcfp_BT[1], rcTemp[0]);
+//     if(ALGO_ABS(belowTempCalc - rcTemp[0]) > 0.1) {
+//         rcfp_BT[0].lVal = belowTempCalc;
+//         rcfp_BT[1].lVal = belowTempCalc;
+//     }
+
+//     float kalmanBelowTemp[2] = {0};
+//     kalmanBelowTemp[0] = ALGO_KalmanFilter1D(&kfp1D_BT[0], rcTemp[1]);
+//     kalmanBelowTemp[1] = ALGO_KalmanFilter1D(&kfp1D_BT[1], kalmanBelowTemp[0]);
+//     if(ALGO_ABS(kalmanBelowTemp[0] - belowTempCalc) > 0.1){
+//         kfp1D_BT[0].X = belowTempCalc;
+//         kfp1D_BT[1].X = belowTempCalc;
+//         kalmanBelowTemp[0] = belowTempCalc;
+//         kalmanBelowTemp[1] = belowTempCalc;
+//     }
+
+// #define AD7124_DBG
+// #ifdef AD7124_DBG
+//     printf("C %02d: ", (codeGroup[4] & 0x0F));
+//     printf("%02X%02X%02X%02X%02X ",
+//         codeGroup[0], codeGroup[1],
+//         codeGroup[2], codeGroup[3],
+//         codeGroup[4]);
+//     printf("%.09f ", calcVol);
+//     printf("%.09f ", calcRes);
+//     printf("%.09f ", fastTempCalc);
+//     printf("%.09f ", aboveTempCalc);
+//     printf("%.09f ", belowTempCalc);
+//     // printf("%.09f ", rcTemp[0]);
+//     // printf("%.09f ", rcTemp[1]);
+//     // printf("%.09f ", kalmanBelowTemp[0]);
+//     // printf("%.09f ", kalmanBelowTemp[1]);
+//     printf("\r\n");
+// #endif
+// }
+
+// void AD7124_Detect(void)
+// {
+//     static uint8_t lastChannel = 0;
+//     if(lastChannel != adDetectType){
+//         lastChannel = adDetectType;
+//         adInitFlag = 0;
+//     }
+//     switch(adDetectType)
+//     {
+//         case 0:
+//         case 1:
+//             if(adInitFlag == 0){
+//                 adInitFlag = 1;
+//                 AD7124_Init(&AD7124_ATY_Cfg_RTD4_1, &AD7124_ATY_Dev_1);
+//                 AD7124_Calibrate(AD7124_CALIBRATE_INT_FULL | AD7124_CALIBRATE_INT_ZERO,
+//                     &AD7124_ATY_Cfg_RTD4_1, &AD7124_ATY_Dev_1);
+//             }
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             break;
+//         case 2:
+//             if(adInitFlag == 0){
+//                 adInitFlag = 1;
+//                 AD7124_Init(&AD7124_ATY_Cfg_NTC1_1, &AD7124_ATY_Dev_1);
+//                 AD7124_Calibrate(AD7124_CALIBRATE_INT_FULL | AD7124_CALIBRATE_INT_ZERO,
+//                     &AD7124_ATY_Cfg_NTC1_1, &AD7124_ATY_Dev_1);
+//             }
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             break;
+//         case 3:
+//         case 4:
+//             if(adInitFlag == 0){
+//                 adInitFlag = 1;
+//                 AD7124_Init(&AD7124_ATY_Cfg_NTC10_1, &AD7124_ATY_Dev_1);
+//                 AD7124_Calibrate(AD7124_CALIBRATE_INT_FULL | AD7124_CALIBRATE_INT_ZERO,
+//                     &AD7124_ATY_Cfg_NTC10_1, &AD7124_ATY_Dev_1);
+//             }
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             break;
+//         case 5:
+//         case 6:
+//             if(adInitFlag == 0){
+//                 adInitFlag = 1;
+//                 AD7124_Init(&AD7124_ATY_Cfg_TC_1, &AD7124_ATY_Dev_1);
+//                 AD7124_Calibrate(AD7124_CALIBRATE_INT_FULL | AD7124_CALIBRATE_INT_ZERO,
+//                     &AD7124_ATY_Cfg_TC_1, &AD7124_ATY_Dev_1);
+//             }
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             AD7124_ReadData(group_AD7124_Data, &AD7124_ATY_Dev_1);
+//             AD7124_Calc(group_AD7124_Data);
+//             break;
+//         default:
+//             break;
+//     }
+// }
+
+/******************************************************************************/
+
 /******************************** End Of File *********************************/

AD7124_ATY.h

@@ -21,7 +21,10 @@
 * @version
 *       - 1_01_230828 > ATY
 *           -# Preliminary version, first Release
-*       - Undone
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
@@ -34,165 +37,271 @@
 
 /******************************************************************************/
 
+
+struct AD7124_ATY_Cfg
+{
+    uint32_t AD7124_STATUS_REG_t;           // r
+    uint32_t AD7124_ADC_CTRL_REG_t;
+    uint32_t AD7124_DATA_REG_t;             // r
+    uint32_t AD7124_IO_CTRL1_REG_t;
+    uint32_t AD7124_IO_CTRL2_REG_t;
+    uint32_t AD7124_ID_REG_t;               // r
+    uint32_t AD7124_ERR_REG_t;              // r
+    uint32_t AD7124_ERREN_REG_t;
+    uint32_t AD7124_MCLK_COUNT_REG_t;       // r
+
+    uint32_t AD7124_CH0_MAP_REG_t;
+    uint32_t AD7124_CH1_MAP_REG_t;
+    uint32_t AD7124_CH2_MAP_REG_t;
+    uint32_t AD7124_CH3_MAP_REG_t;
+    uint32_t AD7124_CH4_MAP_REG_t;
+    uint32_t AD7124_CH5_MAP_REG_t;
+    uint32_t AD7124_CH6_MAP_REG_t;
+    uint32_t AD7124_CH7_MAP_REG_t;
+    uint32_t AD7124_CH8_MAP_REG_t;
+    uint32_t AD7124_CH9_MAP_REG_t;
+    uint32_t AD7124_CH10_MAP_REG_t;
+    uint32_t AD7124_CH11_MAP_REG_t;
+    uint32_t AD7124_CH12_MAP_REG_t;
+    uint32_t AD7124_CH13_MAP_REG_t;
+    uint32_t AD7124_CH14_MAP_REG_t;
+    uint32_t AD7124_CH15_MAP_REG_t;
+
+    uint32_t AD7124_CFG0_REG_t;
+    uint32_t AD7124_CFG1_REG_t;
+    uint32_t AD7124_CFG2_REG_t;
+    uint32_t AD7124_CFG3_REG_t;
+    uint32_t AD7124_CFG4_REG_t;
+    uint32_t AD7124_CFG5_REG_t;
+    uint32_t AD7124_CFG6_REG_t;
+    uint32_t AD7124_CFG7_REG_t;
+
+    uint32_t AD7124_FILT0_REG_t;
+    uint32_t AD7124_FILT1_REG_t;
+    uint32_t AD7124_FILT2_REG_t;
+    uint32_t AD7124_FILT3_REG_t;
+    uint32_t AD7124_FILT4_REG_t;
+    uint32_t AD7124_FILT5_REG_t;
+    uint32_t AD7124_FILT6_REG_t;
+    uint32_t AD7124_FILT7_REG_t;
+
+    uint32_t AD7124_OFFS0_REG_t;
+    uint32_t AD7124_OFFS1_REG_t;
+    uint32_t AD7124_OFFS2_REG_t;
+    uint32_t AD7124_OFFS3_REG_t;
+    uint32_t AD7124_OFFS4_REG_t;
+    uint32_t AD7124_OFFS5_REG_t;
+    uint32_t AD7124_OFFS6_REG_t;
+    uint32_t AD7124_OFFS7_REG_t;
+
+    uint32_t AD7124_GAIN0_REG_t;
+    uint32_t AD7124_GAIN1_REG_t;
+    uint32_t AD7124_GAIN2_REG_t;
+    uint32_t AD7124_GAIN3_REG_t;
+    uint32_t AD7124_GAIN4_REG_t;
+    uint32_t AD7124_GAIN5_REG_t;
+    uint32_t AD7124_GAIN6_REG_t;
+    uint32_t AD7124_GAIN7_REG_t;
+};
+
+struct AD7124_ATY_Dev
+{
+    uint8_t addr;
+    uint8_t id;
+
+    void (*nssSet)(uint8_t level);
+    void (*enSet)(uint8_t level);
+    void (*syncSet)(uint8_t level);
+
+    uint8_t(*spiProcess)(uint8_t* data_t, uint16_t len, uint8_t rw);
+
+    void (*delay)(uint32_t t);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    void (*LOG)();
+};
+
+uint8_t AD7124_WriteRead(uint8_t* data, uint8_t len, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_Reset(struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_ReadId(uint8_t* id, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_WriteReg(uint8_t regAddr, uint32_t data, uint8_t len, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_ReadReg(uint8_t regAddr, uint32_t* data, uint8_t len, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_ReadData(uint8_t* data, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_ReadStatus(uint8_t* status, struct AD7124_ATY_Dev* dev);
+float AD7124_DataToRes(uint32_t data, uint8_t resolution, float refRes, uint8_t gain);
+float AD7124_DataToResDefault(uint32_t data);
+uint8_t AD7124_Init(struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_Config(struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev);
+uint8_t AD7124_ReadAllReg(struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev);
+
+uint8_t AD7124_Calibrate(uint8_t calibrateType, struct AD7124_ATY_Cfg* cfg, struct AD7124_ATY_Dev* dev);
+#define AD7124_CALIBRATE_INT_FULL 0x01
+#define AD7124_CALIBRATE_INT_ZERO 0x02
+#define AD7124_CALIBRATE_SYS_FULL 0x04
+#define AD7124_CALIBRATE_SYS_ZERO 0x08
+
+
 /******************* Register map and register definitions ********************/
 #define	AD7124_RW 1   /* Read and Write */
 #define	AD7124_R  2   /* Read only */
 #define AD7124_W  3   /* Write only */
 
 /* AD7124 Register Map */
-#define AD7124_COMM_REG      0x00
-#define AD7124_STATUS_REG    0x00
-#define AD7124_ADC_CTRL_REG  0x01
-#define AD7124_DATA_REG      0x02
-#define AD7124_IO_CTRL1_REG  0x03
-#define AD7124_IO_CTRL2_REG  0x04
-#define AD7124_ID_REG        0x05
-#define AD7124_ERR_REG       0x06
-#define AD7124_ERREN_REG     0x07
-#define AD7124_CH0_MAP_REG   0x09
-#define AD7124_CH1_MAP_REG   0x0A
-#define AD7124_CH2_MAP_REG   0x0B
-#define AD7124_CH3_MAP_REG   0x0C
-#define AD7124_CH4_MAP_REG   0x0D
-#define AD7124_CH5_MAP_REG   0x0E
-#define AD7124_CH6_MAP_REG   0x0F
-#define AD7124_CH7_MAP_REG   0x10
-#define AD7124_CH8_MAP_REG   0x11
-#define AD7124_CH9_MAP_REG   0x12
-#define AD7124_CH10_MAP_REG  0x13
-#define AD7124_CH11_MAP_REG  0x14
-#define AD7124_CH12_MAP_REG  0x15
-#define AD7124_CH13_MAP_REG  0x16
-#define AD7124_CH14_MAP_REG  0x17
-#define AD7124_CH15_MAP_REG  0x18
-#define AD7124_CFG0_REG      0x19
-#define AD7124_CFG1_REG      0x1A
-#define AD7124_CFG2_REG      0x1B
-#define AD7124_CFG3_REG      0x1C
-#define AD7124_CFG4_REG      0x1D
-#define AD7124_CFG5_REG      0x1E
-#define AD7124_CFG6_REG      0x1F
-#define AD7124_CFG7_REG      0x20
-#define AD7124_FILT0_REG     0x21
-#define AD7124_FILT1_REG     0x22
-#define AD7124_FILT2_REG     0x23
-#define AD7124_FILT3_REG     0x24
-#define AD7124_FILT4_REG     0x25
-#define AD7124_FILT5_REG     0x26
-#define AD7124_FILT6_REG     0x27
-#define AD7124_FILT7_REG     0x28
-#define AD7124_OFFS0_REG     0x29
-#define AD7124_OFFS1_REG     0x2A
-#define AD7124_OFFS2_REG     0x2B
-#define AD7124_OFFS3_REG     0x2C
-#define AD7124_OFFS4_REG     0x2D
-#define AD7124_OFFS5_REG     0x2E
-#define AD7124_OFFS6_REG     0x2F
-#define AD7124_OFFS7_REG     0x30
-#define AD7124_GAIN0_REG     0x31
-#define AD7124_GAIN1_REG     0x32
-#define AD7124_GAIN2_REG     0x33
-#define AD7124_GAIN3_REG     0x34
-#define AD7124_GAIN4_REG     0x35
-#define AD7124_GAIN5_REG     0x36
-#define AD7124_GAIN6_REG     0x37
-#define AD7124_GAIN7_REG     0x38
+#define AD7124_COMM_REG         0x00
+#define AD7124_STATUS_REG       0x00
+#define AD7124_ADC_CTRL_REG     0x01
+#define AD7124_DATA_REG         0x02
+#define AD7124_IO_CTRL1_REG     0x03
+#define AD7124_IO_CTRL2_REG     0x04
+#define AD7124_ID_REG           0x05
+#define AD7124_ERR_REG          0x06
+#define AD7124_ERREN_REG        0x07
+#define AD7124_MCLK_COUNT_REG   0x08
+#define AD7124_CH0_MAP_REG      0x09
+#define AD7124_CH1_MAP_REG      0x0A
+#define AD7124_CH2_MAP_REG      0x0B
+#define AD7124_CH3_MAP_REG      0x0C
+#define AD7124_CH4_MAP_REG      0x0D
+#define AD7124_CH5_MAP_REG      0x0E
+#define AD7124_CH6_MAP_REG      0x0F
+#define AD7124_CH7_MAP_REG      0x10
+#define AD7124_CH8_MAP_REG      0x11
+#define AD7124_CH9_MAP_REG      0x12
+#define AD7124_CH10_MAP_REG     0x13
+#define AD7124_CH11_MAP_REG     0x14
+#define AD7124_CH12_MAP_REG     0x15
+#define AD7124_CH13_MAP_REG     0x16
+#define AD7124_CH14_MAP_REG     0x17
+#define AD7124_CH15_MAP_REG     0x18
+#define AD7124_CFG0_REG         0x19
+#define AD7124_CFG1_REG         0x1A
+#define AD7124_CFG2_REG         0x1B
+#define AD7124_CFG3_REG         0x1C
+#define AD7124_CFG4_REG         0x1D
+#define AD7124_CFG5_REG         0x1E
+#define AD7124_CFG6_REG         0x1F
+#define AD7124_CFG7_REG         0x20
+#define AD7124_FILT0_REG        0x21
+#define AD7124_FILT1_REG        0x22
+#define AD7124_FILT2_REG        0x23
+#define AD7124_FILT3_REG        0x24
+#define AD7124_FILT4_REG        0x25
+#define AD7124_FILT5_REG        0x26
+#define AD7124_FILT6_REG        0x27
+#define AD7124_FILT7_REG        0x28
+#define AD7124_OFFS0_REG        0x29
+#define AD7124_OFFS1_REG        0x2A
+#define AD7124_OFFS2_REG        0x2B
+#define AD7124_OFFS3_REG        0x2C
+#define AD7124_OFFS4_REG        0x2D
+#define AD7124_OFFS5_REG        0x2E
+#define AD7124_OFFS6_REG        0x2F
+#define AD7124_OFFS7_REG        0x30
+#define AD7124_GAIN0_REG        0x31
+#define AD7124_GAIN1_REG        0x32
+#define AD7124_GAIN2_REG        0x33
+#define AD7124_GAIN3_REG        0x34
+#define AD7124_GAIN4_REG        0x35
+#define AD7124_GAIN5_REG        0x36
+#define AD7124_GAIN6_REG        0x37
+#define AD7124_GAIN7_REG        0x38
 
 /* Communication Register bits */
-#define AD7124_COMM_REG_WEN    (0 << 7)
-#define AD7124_COMM_REG_WR     (0 << 6)
-#define AD7124_COMM_REG_RD     (1 << 6)
-#define AD7124_COMM_REG_RA(x)  ((x) | 0x40)     // read reg at address (x)
-#define AD7124_COMM_REG_WA(x)  ((x) & 0x3F)     // write reg at address (x)
+#define AD7124_COMM_REG_WEN                    (0 << 7)
+#define AD7124_COMM_REG_WR                     (0 << 6)
+#define AD7124_COMM_REG_RD                     (1 << 6)
+#define AD7124_COMM_REG_RA(x)                  ((x) | 0x40)         // read reg at address (x)
+#define AD7124_COMM_REG_WA(x)                  ((x) & 0x3F)         // write reg at address (x)
 
 /* Status Register bits */
-#define AD7124_STATUS_REG_RDY          (1 << 7)
-#define AD7124_STATUS_REG_ERROR_FLAG   (1 << 6)
-#define AD7124_STATUS_REG_POR_FLAG     (1 << 4)
-#define AD7124_STATUS_REG_CH_ACTIVE(x) ((x) & 0xF)
+#define AD7124_STATUS_REG_RDY                  (1 << 7)
+#define AD7124_STATUS_REG_ERROR_FLAG           (1 << 6)
+#define AD7124_STATUS_REG_POR_FLAG             (1 << 4)
+#define AD7124_STATUS_REG_CH_ACTIVE(x)         ((x) & 0xF)
 
 /* ADC_Control Register bits */
-#define AD7124_ADC_CTRL_REG_DOUT_RDY_DEL   (1 << 12)
-#define AD7124_ADC_CTRL_REG_CONT_READ      (1 << 11)
-#define AD7124_ADC_CTRL_REG_DATA_STATUS    (1 << 10)
-#define AD7124_ADC_CTRL_REG_CS_EN          (1 << 9)
-#define AD7124_ADC_CTRL_REG_REF_EN         (1 << 8)
-#define AD7124_ADC_CTRL_REG_POWER_MODE(x)  (((x) & 0x3) << 6)
-#define AD7124_ADC_CTRL_REG_MODE(x)        (((x) & 0xF) << 2)
-#define AD7124_ADC_CTRL_REG_CLK_SEL(x)     (((x) & 0x3) << 0)
+#define AD7124_ADC_CTRL_REG_DOUT_RDY_DEL       (1 << 12)
+#define AD7124_ADC_CTRL_REG_CONT_READ          (1 << 11)
+#define AD7124_ADC_CTRL_REG_DATA_STATUS        (1 << 10)
+#define AD7124_ADC_CTRL_REG_CS_EN              (1 << 9)
+#define AD7124_ADC_CTRL_REG_REF_EN             (1 << 8)
+#define AD7124_ADC_CTRL_REG_POWER_MODE(x)      (((x) & 0x3) << 6)
+#define AD7124_ADC_CTRL_REG_MODE(x)            (((x) & 0xF) << 2)
+#define AD7124_ADC_CTRL_REG_CLK_SEL(x)         (((x) & 0x3) << 0)
 
 /* IO_Control_1 Register bits */
-#define AD7124_IO_CTRL1_REG_GPIO_DAT2     (1 << 23)
-#define AD7124_IO_CTRL1_REG_GPIO_DAT1     (1 << 22)
-#define AD7124_IO_CTRL1_REG_GPIO_CTRL2    (1 << 19)
-#define AD7124_IO_CTRL1_REG_GPIO_CTRL1    (1 << 18)
-#define AD7124_IO_CTRL1_REG_PDSW          (1 << 15)
-#define AD7124_IO_CTRL1_REG_IOUT1(x)      (((x) & 0x7) << 11)
-#define AD7124_IO_CTRL1_REG_IOUT0(x)      (((x) & 0x7) << 8)
-#define AD7124_IO_CTRL1_REG_IOUT_CH1(x)   (((x) & 0xF) << 4)
-#define AD7124_IO_CTRL1_REG_IOUT_CH0(x)   (((x) & 0xF) << 0)
+#define AD7124_IO_CTRL1_REG_GPIO_DAT2          (1 << 23)
+#define AD7124_IO_CTRL1_REG_GPIO_DAT1          (1 << 22)
+#define AD7124_IO_CTRL1_REG_GPIO_CTRL2         (1 << 19)
+#define AD7124_IO_CTRL1_REG_GPIO_CTRL1         (1 << 18)
+#define AD7124_IO_CTRL1_REG_PDSW               (1 << 15)
+#define AD7124_IO_CTRL1_REG_IOUT1(x)           (((x) & 0x7) << 11)
+#define AD7124_IO_CTRL1_REG_IOUT0(x)           (((x) & 0x7) << 8)
+#define AD7124_IO_CTRL1_REG_IOUT_CH1(x)        (((x) & 0xF) << 4)
+#define AD7124_IO_CTRL1_REG_IOUT_CH0(x)        (((x) & 0xF) << 0)
 
 /* IO_Control_1 AD7124-8 specific bits */
-#define AD7124_8_IO_CTRL1_REG_GPIO_DAT4     (1 << 23)
-#define AD7124_8_IO_CTRL1_REG_GPIO_DAT3     (1 << 22)
-#define AD7124_8_IO_CTRL1_REG_GPIO_DAT2     (1 << 21)
-#define AD7124_8_IO_CTRL1_REG_GPIO_DAT1     (1 << 20)
-#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL4    (1 << 19)
-#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL3    (1 << 18)
-#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL2    (1 << 17)
-#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL1    (1 << 16)
+#define AD7124_8_IO_CTRL1_REG_GPIO_DAT4        (1 << 23)
+#define AD7124_8_IO_CTRL1_REG_GPIO_DAT3        (1 << 22)
+#define AD7124_8_IO_CTRL1_REG_GPIO_DAT2        (1 << 21)
+#define AD7124_8_IO_CTRL1_REG_GPIO_DAT1        (1 << 20)
+#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL4       (1 << 19)
+#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL3       (1 << 18)
+#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL2       (1 << 17)
+#define AD7124_8_IO_CTRL1_REG_GPIO_CTRL1       (1 << 16)
 
 /* IO_Control_2 Register bits */
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS7   (1 << 15)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS6   (1 << 14)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS5   (1 << 11)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS4   (1 << 10)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS3   (1 << 5)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS2   (1 << 4)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS1   (1 << 1)
-#define AD7124_IO_CTRL2_REG_GPIO_VBIAS0   (1 << 0)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS7        (1 << 15)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS6        (1 << 14)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS5        (1 << 11)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS4        (1 << 10)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS3        (1 << 5)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS2        (1 << 4)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS1        (1 << 1)
+#define AD7124_IO_CTRL2_REG_GPIO_VBIAS0        (1 << 0)
 
 /* IO_Control_2 AD7124-8 specific bits */
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS15  (1 << 15)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS14  (1 << 14)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS13  (1 << 13)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS12  (1 << 12)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS11  (1 << 11)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS10  (1 << 10)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS9   (1 << 9)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS8   (1 << 8)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS7   (1 << 7)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS6   (1 << 6)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS5   (1 << 5)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS4   (1 << 4)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS3   (1 << 3)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS2   (1 << 2)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS1   (1 << 1)
-#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS0   (1 << 0)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS15     (1 << 15)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS14     (1 << 14)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS13     (1 << 13)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS12     (1 << 12)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS11     (1 << 11)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS10     (1 << 10)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS9      (1 << 9)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS8      (1 << 8)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS7      (1 << 7)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS6      (1 << 6)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS5      (1 << 5)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS4      (1 << 4)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS3      (1 << 3)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS2      (1 << 2)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS1      (1 << 1)
+#define AD7124_8_IO_CTRL2_REG_GPIO_VBIAS0      (1 << 0)
 
 /* ID Register bits */
-#define AD7124_ID_REG_DEVICE_ID(x)   (((x) & 0xF) << 4)
-#define AD7124_ID_REG_SILICON_REV(x) (((x) & 0xF) << 0)
+#define AD7124_ID_REG_DEVICE_ID(x)             (((x) & 0xF) << 4)
+#define AD7124_ID_REG_SILICON_REV(x)           (((x) & 0xF) << 0)
 
 /* Error Register bits */
-#define AD7124_ERR_REG_LDO_CAP_ERR        (1 << 19)
-#define AD7124_ERR_REG_ADC_CAL_ERR        (1 << 18)
-#define AD7124_ERR_REG_ADC_CONV_ERR       (1 << 17)
-#define AD7124_ERR_REG_ADC_SAT_ERR        (1 << 16)
-#define AD7124_ERR_REG_AINP_OV_ERR        (1 << 15)
-#define AD7124_ERR_REG_AINP_UV_ERR        (1 << 14)
-#define AD7124_ERR_REG_AINM_OV_ERR        (1 << 13)
-#define AD7124_ERR_REG_AINM_UV_ERR        (1 << 12)
-#define AD7124_ERR_REG_REF_DET_ERR        (1 << 11)
-#define AD7124_ERR_REG_DLDO_PSM_ERR       (1 << 9)
-#define AD7124_ERR_REG_ALDO_PSM_ERR       (1 << 7)
-#define AD7124_ERR_REG_SPI_IGNORE_ERR     (1 << 6)
-#define AD7124_ERR_REG_SPI_SLCK_CNT_ERR   (1 << 5)
-#define AD7124_ERR_REG_SPI_READ_ERR       (1 << 4)
-#define AD7124_ERR_REG_SPI_WRITE_ERR      (1 << 3)
-#define AD7124_ERR_REG_SPI_CRC_ERR        (1 << 2)
-#define AD7124_ERR_REG_MM_CRC_ERR         (1 << 1)
-#define AD7124_ERR_REG_ROM_CRC_ERR        (1 << 0)
+#define AD7124_ERR_REG_LDO_CAP_ERR             (1 << 19)
+#define AD7124_ERR_REG_ADC_CAL_ERR             (1 << 18)
+#define AD7124_ERR_REG_ADC_CONV_ERR            (1 << 17)
+#define AD7124_ERR_REG_ADC_SAT_ERR             (1 << 16)
+#define AD7124_ERR_REG_AINP_OV_ERR             (1 << 15)
+#define AD7124_ERR_REG_AINP_UV_ERR             (1 << 14)
+#define AD7124_ERR_REG_AINM_OV_ERR             (1 << 13)
+#define AD7124_ERR_REG_AINM_UV_ERR             (1 << 12)
+#define AD7124_ERR_REG_REF_DET_ERR             (1 << 11)
+#define AD7124_ERR_REG_DLDO_PSM_ERR            (1 << 9)
+#define AD7124_ERR_REG_ALDO_PSM_ERR            (1 << 7)
+#define AD7124_ERR_REG_SPI_IGNORE_ERR          (1 << 6)
+#define AD7124_ERR_REG_SPI_SLCK_CNT_ERR        (1 << 5)
+#define AD7124_ERR_REG_SPI_READ_ERR            (1 << 4)
+#define AD7124_ERR_REG_SPI_WRITE_ERR           (1 << 3)
+#define AD7124_ERR_REG_SPI_CRC_ERR             (1 << 2)
+#define AD7124_ERR_REG_MM_CRC_ERR              (1 << 1)
+#define AD7124_ERR_REG_ROM_CRC_ERR             (1 << 0)
 
 /* Error_En Register bits */
 #define AD7124_ERREN_REG_MCLK_CNT_EN           (1 << 22)
@@ -219,99 +328,27 @@
 #define AD7124_ERREN_REG_ROM_CRC_ERR_EN        (1 << 0)
 
 /* Channel Registers 0-15 bits */
-#define AD7124_CH_MAP_REG_CH_ENABLE    (1 << 15)
-#define AD7124_CH_MAP_REG_SETUP(x)     (((x) & 0x7) << 12)
-#define AD7124_CH_MAP_REG_AINP(x)      (((x) & 0x1F) << 5)
-#define AD7124_CH_MAP_REG_AINM(x)      (((x) & 0x1F) << 0)
+#define AD7124_CH_MAP_REG_CH_ENABLE            (1 << 15)
+#define AD7124_CH_MAP_REG_SETUP(x)             (((x) & 0x7) << 12)
+#define AD7124_CH_MAP_REG_AINP(x)              (((x) & 0x1F) << 5)
+#define AD7124_CH_MAP_REG_AINM(x)              (((x) & 0x1F) << 0)
 
 /* Configuration Registers 0-7 bits */
-#define AD7124_CFG_REG_BIPOLAR     (1 << 11)
-#define AD7124_CFG_REG_BURNOUT(x)  (((x) & 0x3) << 9)
-#define AD7124_CFG_REG_REF_BUFP    (1 << 8)
-#define AD7124_CFG_REG_REF_BUFM    (1 << 7)
-#define AD7124_CFG_REG_AIN_BUFP    (1 << 6)
-#define AD7124_CFG_REG_AINN_BUFM   (1 << 5)
-#define AD7124_CFG_REG_REF_SEL(x)  ((x) & 0x3) << 3
-#define AD7124_CFG_REG_PGA(x)      (((x) & 0x7) << 0)
+#define AD7124_CFG_REG_BIPOLAR                 (1 << 11)
+#define AD7124_CFG_REG_BURNOUT(x)              (((x) & 0x3) << 9)
+#define AD7124_CFG_REG_REF_BUFP                (1 << 8)
+#define AD7124_CFG_REG_REF_BUFM                (1 << 7)
+#define AD7124_CFG_REG_AIN_BUFP                (1 << 6)
+#define AD7124_CFG_REG_AINN_BUFM               (1 << 5)
+#define AD7124_CFG_REG_REF_SEL(x)              ((x) & 0x3) << 3
+#define AD7124_CFG_REG_PGA(x)                  (((x) & 0x7) << 0)
 
 /* Filter Register 0-7 bits */
-#define AD7124_FILT_REG_FILTER(x)         (((x) & 0x7) << 21)
-#define AD7124_FILT_REG_REJ60             (1 << 20)
-#define AD7124_FILT_REG_POST_FILTER(x)    (((x) & 0x7) << 17)
-#define AD7124_FILT_REG_SINGLE_CYCLE      (1 << 16)
-#define AD7124_FILT_REG_FS(x)             (((x) & 0x7FF) << 0)
-
-/*************************** Types Declarations *******************************/
-
-/*! Device register info */
-struct ad7124_st_reg {
-	int32_t addr;
-	int32_t value;
-	int32_t size;
-	int32_t rw;
-};
-
-/*! AD7124 registers list*/
-enum ad7124_registers {
-	AD7124_Status = 0x00,
-	AD7124_ADC_Control,
-	AD7124_Data,
-	AD7124_IOCon1,
-	AD7124_IOCon2,
-	AD7124_ID,
-	AD7124_Error,
-	AD7124_Error_En,
-	AD7124_Mclk_Count,
-	AD7124_Channel_0,
-	AD7124_Channel_1,
-	AD7124_Channel_2,
-	AD7124_Channel_3,
-	AD7124_Channel_4,
-	AD7124_Channel_5,
-	AD7124_Channel_6,
-	AD7124_Channel_7,
-	AD7124_Channel_8,
-	AD7124_Channel_9,
-	AD7124_Channel_10,
-	AD7124_Channel_11,
-	AD7124_Channel_12,
-	AD7124_Channel_13,
-	AD7124_Channel_14,
-	AD7124_Channel_15,
-	AD7124_Config_0,
-	AD7124_Config_1,
-	AD7124_Config_2,
-	AD7124_Config_3,
-	AD7124_Config_4,
-	AD7124_Config_5,
-	AD7124_Config_6,
-	AD7124_Config_7,
-	AD7124_Filter_0,
-	AD7124_Filter_1,
-	AD7124_Filter_2,
-	AD7124_Filter_3,
-	AD7124_Filter_4,
-	AD7124_Filter_5,
-	AD7124_Filter_6,
-	AD7124_Filter_7,
-	AD7124_Offset_0,
-	AD7124_Offset_1,
-	AD7124_Offset_2,
-	AD7124_Offset_3,
-	AD7124_Offset_4,
-	AD7124_Offset_5,
-	AD7124_Offset_6,
-	AD7124_Offset_7,
-	AD7124_Gain_0,
-	AD7124_Gain_1,
-	AD7124_Gain_2,
-	AD7124_Gain_3,
-	AD7124_Gain_4,
-	AD7124_Gain_5,
-	AD7124_Gain_6,
-	AD7124_Gain_7,
-	AD7124_REG_NO
-};
+#define AD7124_FILT_REG_FILTER(x)              (((x) & 0x7) << 21)
+#define AD7124_FILT_REG_REJ60                  (1 << 20)
+#define AD7124_FILT_REG_POST_FILTER(x)         (((x) & 0x7) << 17)
+#define AD7124_FILT_REG_SINGLE_CYCLE           (1 << 16)
+#define AD7124_FILT_REG_FS(x)                  (((x) & 0x7FF) << 0)
 
 /******************* AD7124 Constants *****************************************/
 #define AD7124_CRC8_POLYNOMIAL_REPRESENTATION 0x07 /* x8 + x2 + x + 1 */

ADS1112_ATY.c

@@ -21,7 +21,8 @@
 * @version
 *       - 1_01_230828 > ATY
 *           -# Preliminary version, first Release
-*       - Undone
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -36,12 +37,14 @@
 
 /**
  * @brief   Set ADS1112 paramas
- * @param   channelP channel type, default 0 -> C0-C1
+ * @param   adChannel channel type, default 0 -> C0-C1
  * @param   conversion conversion, default 0
  * @param   resolution resolution, higher resolution with lower data rate, default 3
  * @param   gain gain, default 0
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-uint8_t ADS1112_Setting(uint8_t channel, uint8_t conversion, uint8_t resolution, uint8_t gain)
+uint8_t ADS1112_Setting(uint8_t adChannel, uint8_t conversion, uint8_t resolution, uint8_t gain, uint8_t addr, uint8_t channel)
 {
     /* INP controls which two of the four analog inputs are used to measure data in the ADC.
         INP1   INP0   V IN+   V IN-
@@ -68,42 +71,62 @@ uint8_t ADS1112_Setting(uint8_t channel, uint8_t conversion, uint8_t resolution,
         1       1       8
     */
     uint8_t tempReg = (1 << 7 |
-        channel << 5 |
+        adChannel << 5 |
         conversion << 4 |
         resolution << 2 |
         gain);
-    return I2C_Write(ADS1112_ADDRESS, &tempReg, 1);
+    return I2C_Write(addr, &tempReg, 1, channel);
 }
-// ADS1112_Setting(CHANNEL_0_3, CONVERSION_CONTINUOUS, RESOLUTION_16BIT, GAIN_1);
 
 /**
  * @brief   read data from ADS1112
- * @param   chipAddr chip address
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  uint16_t data value
  */
-uint16_t ADS1112_Read(uint8_t chipAddr)
+uint16_t ADS1112_Read(uint8_t addr, uint8_t channel)
 {
     uint8_t errCount = 11;
     uint8_t tempRealValue[3] = {0};
     I2C_Read(chipAddr, tempRealValue, 3);
     while(errCount--){
         if((tempRealValue[2] & (uint8_t)0x80) != 0)
-            I2C_Read(chipAddr, tempRealValue, 3);
+            I2C_Read(addr, tempRealValue, 3, channel);
     }
     if(errCount <= 1)
         return 0;
     return (uint16_t)((uint16_t)((uint16_t)tempRealValue[0] << 8) | (uint16_t)tempRealValue[1]);
 }
-// ADS1112_Read(ADS1112_ADDRESS);
 
-float ADS1112_Voltage(uint16_t u16Data)
+/**
+ * @brief
+ * @param u16Data chip return data
+ * @return float voltage value
+ */
+float ADS1112_VoltageConvert(uint16_t u16Data)
 {
     if(u16Data > 0x7FFF)
         return ((((float)(u16Data - 0x8000) / 65536.0f) * 2.048f * 2) + (VREF_COM - 2.048f));
     else
         return ((((float)(u16Data + 0x8000) / 65536.0f) * 2.048f * 2) + (VREF_COM - 2.048f));
 }
-// ADS1112_Voltage(ADS1112_Read(ADS1112_ADDRESS));
+
+
+// void main()
+// {
+//     while(1)
+//     {
+//         float result = 0;
+//         ADS1112_Setting(CHANNEL_0_3, CONVERSION_CONTINUOUS, RESOLUTION_16BIT, GAIN_1, ADS1112_ADDRESS, ADS1112_I2C);
+//         result = ADS1112_VoltageConvert(ADS1112_Read(ADS1112_ADDRESS, ADS1112_I2C));
+//         printf(result);
+//         DelayMs(1000);
+//         ADS1112_Setting(CHANNEL_1_3, CONVERSION_CONTINUOUS, RESOLUTION_16BIT, GAIN_1, ADS1112_ADDRESS, ADS1112_I2C);
+//         result = ADS1112_VoltageConvert(ADS1112_Read(ADS1112_ADDRESS, ADS1112_I2C));
+//         printf(result);
+//         DelayMs(1000);
+//     }
+// }
 
 #endif /* __ADS1112_ATY_C */
 

ADS1112_ATY.h

@@ -21,6 +21,8 @@
 * @version
 *       - 1_01_230828 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -34,10 +36,6 @@
 // Set AD0/AD1 voltage level for device address, 0 for low, 1 for high, 2 for float
 #define ADS1112_AD0 0
 #define ADS1112_AD1 0
-#define VREF_COM    1.24f
-// #define __DEBUG_ADS1112_ATY
-
-/******************************************************************************/
 
 #if ((ADS1112_AD0 == 0) && (ADS1112_AD1 == 0))
 #define ADS1112_ADDRESS  (0x48)
@@ -57,6 +55,12 @@
 #define ADS1112_ADDRESS  (0x4F)
 #endif
 
+#define VREF_COM    1.24f
+// #define __DEBUG_ADS1112_ATY
+// #define ADS1112_I2C I2C_C1
+
+/******************************************************************************/
+
 #define CHANNEL_0_1 0
 #define CHANNEL_2_3 1
 #define CHANNEL_0_3 2
@@ -72,9 +76,9 @@
 #define GAIN_4 2
 #define GAIN_8 3
 
-uint8_t ADS1112_Setting(uint8_t channel, uint8_t conversion, uint8_t resolution, uint8_t gain);
-uint16_t ADS1112_Read(uint8_t chipAddr);
-float ADS1112_Voltage(uint16_t u16Data);
+uint8_t ADS1112_Setting(uint8_t adChannel, uint8_t conversion, uint8_t resolution, uint8_t gain, uint8_t addr, uint8_t channel);
+uint16_t ADS1112_Read(uint8_t chipAddr, uint8_t addr, uint8_t channel);
+float ADS1112_VoltageConvert(uint16_t u16Data);
 
 #endif /* __ADS1112_ATY_H */
 

AHT20_ATY.c

@@ -23,6 +23,8 @@
 *           -# Preliminary version, first Release
 *       - 1_02_220901 > ATY
 *           -# Init tmp to zero, test AHT20_Init()
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -35,141 +37,153 @@
 
 /******************************************************************************/
 
-
 /**
  * @brief   AHT20 soft reset
+ * @param   channel chip channel
  */
-void AHT20_SoftReset(void)
+void AHT20_SoftReset(uint8_t channel)
 {
     uint8_t temp_uint8 = 0;
-    I2C_WriteReg(ATH20_ADDRESS, AHT20_SOFT_RST, &temp_uint8, 0);
+    I2C_WriteReg(ATH20_ADDRESS, AHT20_SOFT_RST, &temp_uint8, 0, channel);
 }
 
 /**
  * @brief   read AHT20 status reg
+ * @param   channel chip channel
  * @return  reg data
  */
-uint8_t AHT20_ReadStatusCmd(void)
+uint8_t AHT20_ReadStatusCmd(uint8_t channel)
 {
     uint8_t temp_uint8 = 0;
-    I2C_ReadReg(ATH20_ADDRESS, AHT20_STATUS, &temp_uint8, 1);
+    I2C_ReadReg(ATH20_ADDRESS, AHT20_STATUS, &temp_uint8, 1, channel);
     return temp_uint8;
 }
 
 /**
  * @brief   AHT20 chip initialization
+ * @param   channel chip channel
  */
-void AHT20_IcInitCmd(void)
+void AHT20_IcInitCmd(uint8_t channel)
 {
     const uint8_t temp_uint8[2] = {0x08, 0x00};
     // temp_uint8[0] = 0x00;
     // temp_uint8[1] = 0x00;
-    // I2C_WriteReg(ATH20_ADDRESS, AHT20_NOR_MODE, temp_uint8, 2);
+    // I2C_WriteReg(ATH20_ADDRESS, AHT20_NOR_MODE, temp_uint8, 2, channel);
     // temp_uint8[0] = 0x08;
     // temp_uint8[1] = 0x00;
-    I2C_WriteReg(ATH20_ADDRESS, AHT20_INIT, temp_uint8, 2);
-    // I2C_WriteReg(ATH20_ADDRESS, 0xE1, temp_uint8, 2);
+    I2C_WriteReg(ATH20_ADDRESS, AHT20_INIT, temp_uint8, 2, channel);
+    // I2C_WriteReg(ATH20_ADDRESS, 0xE1, temp_uint8, 2, channel);
 }
 
 
 /**
  * @brief   get AHT20 busy flag
+ * @param   channel chip channel
  * @return  busy flag: 1 - busy, 0 - leisure
  */
-uint8_t AHT20_ReadBusyCmd(void)
+uint8_t AHT20_ReadBusyCmd(uint8_t channel)
 {
     uint8_t temp_uint8 = 0;
-    temp_uint8 = AHT20_ReadStatusCmd();
+    temp_uint8 = AHT20_ReadStatusCmd(channel);
     return (temp_uint8 >> 7) & 0x01;
 }
 
 /**
  * @brief   read AHT20 calibration enable
+ * @param   channel chip channel
  * @return  calibration state: 1 - calibrate done, 0 - not calibrated
  */
-uint8_t AHT20_ReadCalEnableCmd(void)
+uint8_t AHT20_ReadCalEnableCmd(uint8_t channel)
 {
     uint8_t temp_uint8 = 0;
-    temp_uint8 = AHT20_ReadStatusCmd();
+    temp_uint8 = AHT20_ReadStatusCmd(channel);
     return (temp_uint8 >> 3) & 0x01;
 }
 
 /**
  * @brief   AHT20 measure command
+ * @param   channel chip channel
  */
-void AHT20_TrigMeasure(void)
+void AHT20_TrigMeasure(uint8_t channel)
 {
     const uint8_t temp_uint8[2] = {0x33, 0x00};
     // temp_uint8[0] = 0x33;
     // temp_uint8[1] = 0x00;
-    I2C_WriteReg(ATH20_ADDRESS, AHT20_TRIG_MEASURE, temp_uint8, 2);
+    I2C_WriteReg(ATH20_ADDRESS, AHT20_TRIG_MEASURE, temp_uint8, 2, channel);
 }
 
 /**
  * @brief   AHT20 measure command
  * @param   data_t group to save origin reg data
+ * @param   channel chip channel
+ * @todo    change to Write function
  */
-void AHT20_ReadData(uint8_t* data_t)
+void AHT20_ReadData(uint8_t* data_t, uint8_t channel)
 {
-    I2C_Start();
-    I2C_WriteRegByte(ATH20_ADDRESS << 1 | 1);
-    I2C_WaitAck(I2C_WAIT_ACK_TIME);
-    data_t[0] = I2C_ReadByte(1);
-    data_t[1] = I2C_ReadByte(1);
-    data_t[2] = I2C_ReadByte(1);
-    data_t[3] = I2C_ReadByte(1);
-    data_t[4] = I2C_ReadByte(1);
-    data_t[5] = I2C_ReadByte(0);
-    I2C_Stop();
+    I2C_Read(ATH20_ADDRESS, data_t, 6, channel);    // todo: not tested
+
+    // I2C_Start();
+    // I2C_WriteRegByte(ATH20_ADDRESS << 1 | 1);
+    // I2C_WaitAck(I2C_WAIT_ACK_TIME);
+    // data_t[0] = I2C_ReadByte(1);
+    // data_t[1] = I2C_ReadByte(1);
+    // data_t[2] = I2C_ReadByte(1);
+    // data_t[3] = I2C_ReadByte(1);
+    // data_t[4] = I2C_ReadByte(1);
+    // data_t[5] = I2C_ReadByte(0);
+    // I2C_Stop();
 }
 
 /**
  * @brief   reset AHT20 reg setting
- * @param   addr reg address
+ * @param   regAddr reg address
+ * @param   channel chip channel
  * @note    generally not needed
  */
-void AHT20_RegReset(uint8_t addr)
+void AHT20_RegReset(uint8_t regAddr, uint8_t channel)
 {
     uint8_t temp_uint8[3] = {0};
     temp_uint8[0] = 0x00;
     temp_uint8[1] = 0x00;
     temp_uint8[2] = 0x00;
-    I2C_WriteReg(ATH20_ADDRESS, addr, temp_uint8, 2);
+    I2C_WriteReg(ATH20_ADDRESS, regAddr, temp_uint8, 2, channel);
     DelayMs(5);
-    I2C_ReadReg(ATH20_ADDRESS, AHT20_STATUS, temp_uint8, 3);
+    I2C_ReadReg(ATH20_ADDRESS, AHT20_STATUS, temp_uint8, 3, channel);
     DelayMs(10);
-    I2C_WriteReg(ATH20_ADDRESS, 0xB0 | addr, temp_uint8 + 1, 2);
+    I2C_WriteReg(ATH20_ADDRESS, 0xB0 | regAddr, temp_uint8 + 1, 2, channel);
 }
 
 /**
  * @brief   reset AHT20 reg setting
+ * @param   channel chip channel
  * @note    generally not needed
  */
-void AHT20_RegInit(void)
+void AHT20_RegInit(uint8_t channel)
 {
-    AHT20_RegReset(0x1B);
-    AHT20_RegReset(0x1C);
-    AHT20_RegReset(0x1D);
+    AHT20_RegReset(0x1B, channel);
+    AHT20_RegReset(0x1C, channel);
+    AHT20_RegReset(0x1D, channel);
 }
 
 
 
 /**
  * @brief   AHT20 all initialize
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: error
  */
-uint8_t AHT20_Init(void)
+uint8_t AHT20_Init(uint8_t channel)
 {
     uint8_t errCount = 5;
 
     while(errCount--)
     {
         DelayMs(40);               // wait time after power on
-        if((AHT20_ReadStatusCmd() & 0x18) != 0x18)
+        if((AHT20_ReadStatusCmd(channel) & 0x18) != 0x18)
         {
-            AHT20_SoftReset();
-            AHT20_IcInitCmd();
-            AHT20_RegInit();
+            AHT20_SoftReset(channel);
+            AHT20_IcInitCmd(channel);
+            AHT20_RegInit(channel);
             DelayMs(10);
             continue;
         }
@@ -183,11 +197,11 @@ uint8_t AHT20_Init(void)
     while(errCount--)
     {
         // check if calibrate over
-        if(AHT20_ReadCalEnableCmd() == 0)
+        if(AHT20_ReadCalEnableCmd(channel) == 0)
         {
             DelayMs(10);
             // if not calibrated, reset to retry
-            AHT20_IcInitCmd();
+            AHT20_IcInitCmd(channel);
             // AHT20_SoftReset();
             DelayMs(200);          // time not sure
         }
@@ -208,21 +222,22 @@ TEM:25.2HUM:57.5
 /**
  * @brief   read and split data to origin hum & tem
  * @param   ht group to save hum & tem data
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: error
  */
-uint8_t AHT20_ReadHT(uint32_t* ht)
+uint8_t AHT20_ReadHT(uint32_t* ht, uint8_t channel)
 {
     uint8_t errCount = 5;
     uint8_t temp_uint8[6] = {0};
     uint32_t RetuData = 0;
 
-    AHT20_TrigMeasure();
+    AHT20_TrigMeasure(channel);
 
     while(errCount--)
     {
         // wait 75ms for measure finished, busy flag Bit7 set to 0
         DelayMs(80);
-        AHT20_ReadData(temp_uint8);
+        AHT20_ReadData(temp_uint8, channel);
         if((temp_uint8[0] & 0x68) == 0x08)
         {
             // origin hum data
@@ -265,14 +280,15 @@ uint8_t AHT20_CalcResult(uint32_t* ht, float* aht)
 /**
  * @brief   calculate result from 20bit origin data, RH=%, T=C
  * @param   ht data group to save th value
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: error
  */
-uint8_t AHT20_InitFlag = 0;
-uint8_t AHT20_TemHumGet(uint16_t* ht)
+uint8_t AHT20_TemHumGet(uint16_t* ht, uint8_t channel)
 {
+    static uint8_t AHT20_InitFlag = 0;
     if(AHT20_InitFlag == 0)
     {
-        if(AHT20_Init() == 1)
+        if(AHT20_Init(channel) == 1)
         {
             AHT20_InitFlag = 2;     // init fail
         }
@@ -293,7 +309,7 @@ uint8_t AHT20_TemHumGet(uint16_t* ht)
         // Init success
         uint32_t tempHT_uint32[2] = {0};
         float tempHT_f[2] = {0};
-        if(AHT20_ReadHT(tempHT_uint32) == 0)
+        if(AHT20_ReadHT(tempHT_uint32, channel) == 0)
         {
             if((tempHT_uint32[0] && tempHT_uint32[1]) != 0)
             {
@@ -325,6 +341,17 @@ uint8_t AHT20_TemHumGet(uint16_t* ht)
 }
 
 
+// todo: not tested
+// void main()
+// {
+//     SHT3X_InitBegin(addr, channel);
+//     while(1)
+//     {
+//         AHT20_TemHumGet();
+//         DelayMs(2000);
+//     }
+// }
+
 
 
 #endif /* __AHT20_ATY_C */

AHT20_ATY.h

@@ -21,6 +21,8 @@
 * @version
 *       - 1_01_220804 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -32,6 +34,7 @@
 
 /******************************* For user *************************************/
 // #ifdef __DEBUG_AHT20_ATY
+// #define AHT20_I2C I2C_C1
 
 /******************************************************************************/
 
@@ -42,7 +45,7 @@
 #define AHT20_TRIG_MEASURE  0xAC
 #define AHT20_STATUS        0x00
 
-uint8_t AHT20_TemHumGet(uint16_t* ht);
+uint8_t AHT20_TemHumGet(uint16_t* ht, uint8_t channel);
 
 
 #endif /* __AHT20_ATY_H */

ALGO_AlgorithmBase_ATY.c

@@ -254,6 +254,25 @@ float ALGO_GetRms(uint16_t currentValue, uint16_t currentNum, float sumValue, ui
 }
 
 
+
+float rcLpFiter(rcPara_t* rcPara, float val)
+{
+    rcPara->lVal = ((float)val * rcPara->k + rcPara->lVal * (1 - rcPara->k));
+    return rcPara->lVal;
+}
+
+float rcHpFiter(rcPara_t* rcPara, float val)
+{
+    rcPara->lVal = ((float)val * rcPara->k + rcPara->lVal * (1 - rcPara->k));
+    return -(val - rcPara->lVal);
+}
+
+
+
+
+
+
+
 #ifdef __DEBUG_ALGO_AlgorithmBase_ATY
 void ALGO_Swap_Test(void)
 {

ALGO_AlgorithmBase_ATY.h

@@ -382,6 +382,16 @@ void ALGO_InvertBitsN_Group(uint32_t* genBuf, uint32_t* srcBuf, uint8_t len);
 }
 
 
+//Sr-sampling rate, times/second),f-stop freq(Hz),Pi-(3.14...)
+//k=(2*Pi*f)/Sr
+typedef struct rcPara
+{
+    float k;    // filter series
+    float lVal; // last calc value
+}rcPara_t;
+
+
+
 // #define SIGMOID(x) (1.0f / (1.0f + exp(-x)))
 
 
@@ -390,9 +400,14 @@ int ALGO_MATH_POW_QUICK(int x, int n);
 float ALGO_MATH_POW(float x, int n);
 int ALGO_MATH_SQRT(int x);
 float ALGO_MATH_LogLn(float num);
+float ALGO_Sqrt_NewtonNumber(float x);
 
 float ALGO_NumberSuitScop(float valueIn, float scopMin, float scopMax, float step);
 
+float rcLpFiter(rcPara_t* rcPara, float val);
+float rcHpFiter(rcPara_t* rcPara, float val);
+
+
 #ifdef __DEBUG_ALGO_AlgorithmBase_ATY
 void ALGO_Swap_Test(void);
 void ALGO_Sort_Test(void);

ALGO_Bat_ATY.c

@@ -0,0 +1,86 @@
+/**
+* @file ALGO_Bat_ATY.c
+*
+* @param Project ALGO_Algorithm_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of Bat calc
+*
+* @version
+*       - 1_01_230107 > ATY
+*           -# Preliminary version, first Release
+********************************************************************************
+*/
+
+#ifndef __ALGO_Bat_ATY_C
+#define __ALGO_Bat_ATY_C
+
+#include "ALGO_Bat_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+/**
+ * @brief
+ *
+ * @param vin           bat vol now
+ * @param lastLevel     last bat level
+ * @param vmax          bat vol when power full
+ * @param vmin          bat vol when power empty or limitted low power
+ * @param levels        whole levels to split, start from 1(1 for empty)
+ * @param vFilter       max vol for adc noise, must lower than ((vmax - vmin) / levels)
+ * @return uint8_t
+ */
+uint8_t Bat_AD_Levels(float vin, uint8_t lastLevel, float vmax, float vmin, uint8_t levels, float vFilter)
+{
+    float vUnit = (vmax - vmin) / levels;
+    uint8_t resultLevel = lastLevel;
+
+    // input limit judgement
+    if(vmax <= vmin)
+        return 1;
+    if(vin >= vmax)
+        return levels;
+    else if(vin <= vmin)
+        return 1;
+    if(vFilter >= vUnit)
+        vFilter = vUnit / 2;
+
+    // calc
+    if(vin > (vmin + (vUnit * lastLevel) + (vFilter / 2))){
+        resultLevel++;
+    }
+    else if(vin < (vmin + (vUnit * (lastLevel - 1)) - (vFilter / 2))){
+        resultLevel--;
+    }
+    else{}
+
+    // output limit
+    if(resultLevel > levels)
+        resultLevel = levels;
+    else if(resultLevel < 1)
+        resultLevel = 1;
+
+    return resultLevel;
+}
+
+
+// mbP_CVBV = 3.2;//ADC_Get(&hadc1, ADC_CHANNEL_VREFINT) * VOL_PER_AD_ATY;
+// mbP_CVPV = Bat_AD_Levels(mbP_CVBV, mbP_CVPV, 4.18f, 3.20f, 5, 0.096f);
+
+#endif /* __ALGO_Bat_ATY_C */
+
+/******************************** End Of File *********************************/

ALGO_Bat_ATY.h

@@ -0,0 +1,42 @@
+/**
+* @file ALGO_Bat_ATY.h
+*
+* @param Project ALGO_Algorithm_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of Bat calc
+*
+* @version
+*       - 1_01_230107 > ATY
+*           -# Preliminary version, first Release
+********************************************************************************
+*/
+
+#ifndef __ALGO_Bat_ATY_H
+#define __ALGO_Bat_ATY_H
+
+#include "INCLUDE_ATY.h"
+
+/******************************* For user *************************************/
+// #define __DEBUG_ALGO_Bat_ATY
+
+/******************************************************************************/
+
+uint8_t Bat_AD_Levels(float vin, uint8_t lastLevel, float vmax, float vmin, uint8_t levels, float vFilter);
+
+
+#endif /* __ALGO_Bat_ATY_H */
+
+/******************************** End Of File *********************************/

ALGO_Temperature_ATY.c

@@ -34,7 +34,27 @@
 /******************************************************************************/
 
 /**
- * @brief   Calculate temperature from ntc resistance
+ * @brief   Calculate temperature from ntc resistance(Steinhart-Hart)
+ * @param   Rntc Current NTC resistance value
+ * @param   A A value of NTC
+ * @param   B B value of NTC
+ * @param   C C value of NTC
+ * @return  Current temperature in Celsius
+ */
+float ALGO_ResToKelvinTempABC(float Rntc, float A, float B, float C)
+{
+    float Tn = 0.0;
+    float Cn = 0.0;
+
+    Tn = (A + (B * ALGO_MATH_LogLn(Rntc)) + (C * ALGO_MATH_LogLn(Rntc) * ALGO_MATH_LogLn(Rntc) * ALGO_MATH_LogLn(Rntc)));
+    Tn = 1 / Tn;
+    Cn = ALGO_TEMP_TtoC(Tn);
+
+    return Cn;
+}
+
+/**
+ * @brief   Calculate temperature from ntc resistance(Steinhart-Hart change)
  * @param   Rntc Current NTC resistance value
  * @param   R25 NTC standard resistance value at 25C
  * @param   B B value of NTC
@@ -88,6 +108,112 @@ float ALGO_VolToKelvinTemp(float vADC, float vRef, float rRefK, float R25, float
 }
 
 
+float ALGO_Temp_RTD_Res_Fast(float rtdRes)
+{
+    return (float)((rtdRes - 100.0f) / 0.385f);
+}
+// #include "math.h"
+#include "ALGO_AlgorithmBase_ATY.h"
+float ALGO_Temp_RTD_Res_Above(float rtdRes)
+{
+    return (float)((-(3.9083e-3)
+        + ALGO_Sqrt_NewtonNumber(((3.9083e-3) * (3.9083e-3))
+        // + sqrt(((3.9083e-3) * (3.9083e-3))
+            - 4 * (-5.775e-7) * (1 - (rtdRes / 100.0f))))
+        / (2 * (-5.775e-7)));
+}
+float ALGO_Temp_RTD_Res_Below(float rtdRes)
+{
+    return (float)(-242.02f
+        + 2.2228f * rtdRes
+        + (2.5859e-3) * rtdRes * rtdRes
+        - (4.826e-6) * rtdRes * rtdRes * rtdRes
+        - (2.8183e-8) * rtdRes * rtdRes * rtdRes * rtdRes
+        + (1.5243e-10) * rtdRes * rtdRes * rtdRes * rtdRes * rtdRes);
+}
+
+/**
+ * @brief
+ *
+ * @param   type
+ * @param   Temp in Degrees Celsius
+ * @return  float in mV
+ * @note    https://srdata.nist.gov/
+ */
+float ALGO_Temp_TC_TempToVol(uint8_t type, float Temp)
+{
+    if(type == 'T'){
+        if(Temp == 0)
+            return 0;
+        else if(Temp > 0){
+            return (0
+                + ((0.387481063640e-1) * Temp)
+                + ((0.332922278800e-4) * Temp * Temp)
+                + ((0.206182434040e-6) * Temp * Temp * Temp)
+                + ((-0.218822568460e-8) * Temp * Temp * Temp * Temp)
+                + ((0.109968809280e-10) * Temp * Temp * Temp * Temp * Temp)
+                + ((-0.308157587720e-13) * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.454791352900e-16) * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((-0.275129016730e-19) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp));
+        }
+        else if(Temp < 0){
+            return (0
+                + ((0.387481063640e-01) * Temp)
+                + ((0.441944343470e-04) * Temp * Temp)
+                + ((0.118443231050e-06) * Temp * Temp * Temp)
+                + ((0.200329735540e-07) * Temp * Temp * Temp * Temp)
+                + ((0.901380195590e-09) * Temp * Temp * Temp * Temp * Temp)
+                + ((0.226511565930e-10) * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.360711542050e-12) * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.384939398830e-14) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.282135219250e-16) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.142515947790e-18) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.487686622860e-21) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.107955392700e-23) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.139450270620e-26) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp)
+                + ((0.797951539270e-30) * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp * Temp));
+        }
+    }
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   type
+ * @param   voltage in mV
+ * @return  float in Degrees Celsius
+ * @note    https://srdata.nist.gov/
+ */
+float ALGO_Temp_TC_VolToTemp(uint8_t type, float voltage)
+{
+    if(type == 'T'){
+        if(voltage == 0)
+            return 0;
+        else if(voltage > 0){
+            return (0
+                + ((2.592800e1) * voltage)
+                + ((-7.602961e-1) * voltage * voltage)
+                + ((4.637791e-2) * voltage * voltage * voltage)
+                + ((-2.165394e-3) * voltage * voltage * voltage * voltage)
+                + ((6.048144e-5) * voltage * voltage * voltage * voltage * voltage)
+                + ((-7.293422e-7) * voltage * voltage * voltage * voltage * voltage * voltage));
+        }
+        else if(voltage < 0){
+            return (0
+                + ((2.5949192e1) * voltage)
+                + ((-2.1316967e-1) * voltage * voltage)
+                + ((7.9018692e-1) * voltage * voltage * voltage)
+                + ((4.2527777e-1) * voltage * voltage * voltage * voltage)
+                + ((1.3304473e-1) * voltage * voltage * voltage * voltage * voltage)
+                + ((2.0241446e-2) * voltage * voltage * voltage * voltage * voltage * voltage)
+                + ((1.2668171e-3) * voltage * voltage * voltage * voltage * voltage * voltage * voltage));
+        }
+    }
+    return 0;
+}
+
+
 // resultTemp = ALGO_ResToKelvinTemp(ALGO_VoltageToResDown(resultTemp, vref_t, 10), 1, 3200);
 
 

ALGO_Temperature_ATY.h

@@ -63,9 +63,16 @@
 #define ALGO_VoltageToResUp(vADC, vRef, rRefK) \
     (((float)rRefK * ((float)vRef - (float)vADC)) / (float)vADC)
 
+float ALGO_ResToKelvinTempABC(float Rntc, float A, float B, float C);
 float ALGO_ResToKelvinTemp(float Rntc, float R25, float B);
 float ALGO_VolToKelvinTemp(float vADC, float vRef, float rRefK, float R25, float B, uint8_t rRefPos);
 
+float ALGO_Temp_RTD_Res_Fast(float rtdRes);
+float ALGO_Temp_RTD_Res_Above(float rtdRes);
+float ALGO_Temp_RTD_Res_Below(float rtdRes);
+float ALGO_Temp_TC_TempToVol(uint8_t type, float Temp);
+float ALGO_Temp_TC_VolToTemp(uint8_t type, float voltage);
+
 
 #endif /* __ALGO_Temperature_ATY_H */
 

AT24CXX_ATY.c

@@ -24,6 +24,8 @@
 *       - 1_01_221212 > ATY
 *           -# Change to general I2C function
 *           -# Change and remove several functions
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -38,74 +40,82 @@
 
 /**
  * @brief   Read one byte from assign address
- * @param   addr address to read data
- * @return  uint8 data at addr
+ * @param   regAddr address to read data
+ * @param   addr chip address
+ * @param   channel chip channel
+ * @return  uint8 data at regAddr
  */
-uint8_t AT24CXX_ReadByte(uint16_t addr)
+uint8_t AT24CXX_ReadByte(uint16_t regAddr, uint8_t addr, uint8_t channel)
 {
-    uint8_t temp_uint8 = 0, addrG[2] = {addr >> 8, addr % 256};
+    uint8_t temp_uint8 = 0, addrG[2] = {regAddr >> 8, regAddr % 256};
 
     if(AT24CXX_TYPE > AT24C16)
-        I2C_Write_NoStop(AT24CXX_ADDRESS, addrG, 2);
+        I2C_Write_NoStop(addr, addrG, 2, channel);
     else        // 04/08/16
-        I2C_Write_NoStop(AT24CXX_ADDRESS + ((addr / 256) << 1), addrG + 1, 1);
+        I2C_Write_NoStop(addr + ((regAddr / 256) << 1), addrG + 1, 1, channel);
 
-    I2C_Read(AT24CXX_ADDRESS, &temp_uint8, 1);
+    I2C_Read(addr, &temp_uint8, 1, channel);
 
     return temp_uint8;
 }
 
 /**
  * @brief   Write one byte to assign address
- * @param   addr address to write data
+ * @param   regAddr address to write data
  * @param   data_t data to write
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void AT24CXX_WriteByte(uint16_t addr, uint8_t data_t)
+void AT24CXX_WriteByte(uint16_t regAddr, uint8_t data_t, uint8_t addr, uint8_t channel)
 {
-    uint8_t addrG[3] = {addr >> 8, addr % 256, data_t};
+    uint8_t addrG[3] = {regAddr >> 8, regAddr % 256, data_t};
     if(AT24CXX_TYPE > AT24C16)
-        I2C_Write(AT24CXX_ADDRESS, addrG, 3);
+        I2C_Write(addr, addrG, 3, channel);
     else        // 04/08/16
-        I2C_Write(AT24CXX_ADDRESS + ((addr / 256) << 1), addrG + 1, 2);
+        I2C_Write(addr + ((regAddr / 256) << 1), addrG + 1, 2, channel);
     DelayMs(AT24CXX_WRITE_DELAY);
 }
 
 /**
  * @brief   Read series data from assign address
- * @param   addr address to start read data
+ * @param   regAddr address to start read data
  * @param   pbuf data group to save read data
  * @param   len data length to read
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void AT24CXX_Read(uint16_t addr, uint8_t* pbuf, uint16_t len)
+void AT24CXX_Read(uint16_t regAddr, uint8_t* pbuf, uint16_t len, uint8_t addr, uint8_t channel)
 {
-    uint8_t addrG[2] = {addr >> 8, addr % 256};
+    uint8_t addrG[2] = {regAddr >> 8, regAddr % 256};
 
     if(AT24CXX_TYPE > AT24C16)
-        I2C_Write_NoStop(AT24CXX_ADDRESS, addrG, 2);
+        I2C_Write_NoStop(addr, addrG, 2, channel);
     else        // 04/08/16
-        I2C_Write_NoStop(AT24CXX_ADDRESS + ((addr / 256) << 1), addrG + 1, 1);
+        I2C_Write_NoStop(addr + ((regAddr / 256) << 1), addrG + 1, 1, channel);
 
-    I2C_Read(AT24CXX_ADDRESS, pbuf, len);
+    I2C_Read(addr, pbuf, len, channel);
 }
 
 /**
  * @brief   Write series data to assign address
- * @param   addr address to start read data
+ * @param   regAddr address to start read data
  * @param   pbuf data group to write
  * @param   len data length to write
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void AT24CXX_Write(uint16_t addr, uint8_t* pbuf, uint16_t len)
+void AT24CXX_Write(uint16_t regAddr, uint8_t* pbuf, uint16_t len, uint8_t addr, uint8_t channel)
 {
     uint8_t* addrG = (uint8_t*)malloc(sizeof(uint8_t) * (len + 2));
-    addrG[0] = addr >> 8;
-    addrG[1] = addr % 256;
+    addrG[0] = regAddr >> 8;
+    addrG[1] = regAddr % 256;
     for(uint16_t i = 0; i < len; i++)
         addrG[2 + i] = pbuf[i];
 
     if(AT24CXX_TYPE > AT24C16)
-        I2C_Write(AT24CXX_ADDRESS, addrG, len + 2);
+        I2C_Write(addr, addrG, len + 2, channel);
     else        // 04/08/16
-        I2C_Write(AT24CXX_ADDRESS + ((addr / 256) << 1), addrG + 1, len + 1);
+        I2C_Write(addr + ((regAddr / 256) << 1), addrG + 1, len + 1, channel);
     free(addrG);
     DelayMs(AT24CXX_WRITE_DELAY);
 }
@@ -113,60 +123,64 @@ void AT24CXX_Write(uint16_t addr, uint8_t* pbuf, uint16_t len)
 
 /**
  * @brief   Write random data to assign address
- * @param   addr address to start read data
+ * @param   regAddr address to start read data
  * @param   pbuf data group to save read data
  * @param   len data length to write
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void AT24CXX_WriteRandom(uint16_t addr, uint8_t* pbuf, uint16_t len)
+void AT24CXX_WriteRandom(uint16_t regAddr, uint8_t* pbuf, uint16_t len, uint8_t addr, uint8_t channel)
 {
     uint16_t fullPageCount = 0;                     // whole page count
     uint16_t lastPageSize = 0;
     uint16_t firstPageSize = 0;
 
-    if(addr + len > AT24CXX_TYPE)
-        len = AT24CXX_TYPE - addr;
+    if(regAddr + len > AT24CXX_TYPE)
+        len = AT24CXX_TYPE - regAddr;
 
-    if(addr % AT24CXX_PAGE_SIZE == 0)               // addr is the page start
+    if(regAddr % AT24CXX_PAGE_SIZE == 0)               // regAddr is the page start
         firstPageSize = 0;
     else
     {
-        firstPageSize = AT24CXX_PAGE_SIZE - (addr % AT24CXX_PAGE_SIZE);
-        AT24CXX_Write(addr, pbuf, firstPageSize);
+        firstPageSize = AT24CXX_PAGE_SIZE - (regAddr % AT24CXX_PAGE_SIZE);
+        AT24CXX_Write(regAddr, pbuf, firstPageSize, addr, channel);
     }
 
-    if((addr + len) % AT24CXX_PAGE_SIZE == 0)       // location addr will be wrote too
+    if((regAddr + len) % AT24CXX_PAGE_SIZE == 0)       // location regAddr will be wrote too
         lastPageSize = 0;
     else
     {
-        lastPageSize = (addr + len) % AT24CXX_PAGE_SIZE;
-        AT24CXX_Write(addr + len - lastPageSize, pbuf + len - lastPageSize, lastPageSize);
+        lastPageSize = (regAddr + len) % AT24CXX_PAGE_SIZE;
+        AT24CXX_Write(regAddr + len - lastPageSize, pbuf + len - lastPageSize, lastPageSize, addr, channel);
     }
 
     fullPageCount = (len - firstPageSize - lastPageSize) / AT24CXX_PAGE_SIZE;
     for(uint8_t i = 0; i < fullPageCount; i++)
-        AT24CXX_Write(addr + firstPageSize + i * AT24CXX_PAGE_SIZE,
-            pbuf + firstPageSize + i * AT24CXX_PAGE_SIZE, AT24CXX_PAGE_SIZE);
+        AT24CXX_Write(regAddr + firstPageSize + i * AT24CXX_PAGE_SIZE,
+            pbuf + firstPageSize + i * AT24CXX_PAGE_SIZE, AT24CXX_PAGE_SIZE, addr, channel);
     DelayMs(AT24CXX_WRITE_DELAY);
 }
 
 
 /**
  * @brief   Check device state
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  errCode, 0: device good, !0: device has problem
  */
-uint8_t AT24CXX_Check(void)
+uint8_t AT24CXX_Check(uint8_t addr, uint8_t channel)
 {
     uint8_t temp_uint8;
     // avoid writing every boot up
-    temp_uint8 = AT24CXX_ReadByte(0xFF);
+    temp_uint8 = AT24CXX_ReadByte(0xFF, addr, channel);
 
     if(temp_uint8 == 0X68)
         return 0;
     else
     {
         // may be the first init
-        AT24CXX_WriteByte(0xFF, 0x68);
-        temp_uint8 = AT24CXX_ReadByte(0xFF);
+        AT24CXX_WriteByte(0xFF, 0x68, addr, channel);
+        temp_uint8 = AT24CXX_ReadByte(0xFF, addr, channel);
         if(temp_uint8 == 0x68)
             return 0;
     }
@@ -176,46 +190,52 @@ uint8_t AT24CXX_Check(void)
 
 /**
  * @brief   Init device
+ * @param   addr chip address
+ * @param   channel chip channel
  * @note    not useful if i2c functions good
  */
-void AT24CXX_Init(void)
+void AT24CXX_Init(uint8_t addr, uint8_t channel)
 {
 }
 
 #ifdef __DEBUG_AT24CXX_ATY
 /**
  * @brief   Test funtion(can be instead by Check function)
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: err
  */
-uint8_t AT24CXX_Test(void)
+uint8_t AT24CXX_Test(uint8_t addr, uint8_t channel)
 {
-    // AT24CXX_Init();
+    // AT24CXX_Init(addr, channel);
 
     // W/R one byte
     uint8_t startupCounte = 0;
-    startupCounte = AT24CXX_ReadByte(0xFF);
-    AT24CXX_WriteByte(0xFF, startupCounte + 1);
-    AT24CXX_ReadByte(0xFF);
+    startupCounte = AT24CXX_ReadByte(0xFF, addr, channel);
+    AT24CXX_WriteByte(0xFF, startupCounte + 1, addr, channel);
+    AT24CXX_ReadByte(0xFF, addr, channel);
 
     // W/R bytes
     uint8_t tempTestR_uint8[6] = {0, 0, 0, 0, 0, 0};
     uint8_t tempTestW_uint8[5] = {1, 2, 3, 4, 5};
-    AT24CXX_Write(0xFA, tempTestR_uint8, 0xFF - 0xFA);
-    AT24CXX_Read(0xFA, tempTestR_uint8, 0x100 - 0xFA);
-    AT24CXX_Write(0xFA, tempTestW_uint8, 0xFF - 0xFA);
-    AT24CXX_Read(0xFA, tempTestR_uint8, 0x100 - 0xFA);
+    AT24CXX_Write(0xFA, tempTestR_uint8, 0xFF - 0xFA, addr, channel);
+    AT24CXX_Read(0xFA, tempTestR_uint8, 0x100 - 0xFA, addr, channel);
+    AT24CXX_Write(0xFA, tempTestW_uint8, 0xFF - 0xFA, addr, channel);
+    AT24CXX_Read(0xFA, tempTestR_uint8, 0x100 - 0xFA, addr, channel);
 
     // W/R random
     uint8_t tempBuf[50];
     const char* str = "abcdefghijklmnopqrstuvwxyz0123456789";
-    AT24CXX_WriteRandom(100, (uint8_t*)str, strlen(str));
-    AT24CXX_Read(100, tempBuf, strlen(str));
-    printf("\r\nAT24CXX read data from addr %d at num %d: %s\r\n",
+    AT24CXX_WriteRandom(100, (uint8_t*)str, strlen(str), addr, channel);
+    AT24CXX_Read(100, tempBuf, strlen(str), addr, channel);
+    printf("\r\nAT24CXX read data from regAddr %d at num %d: %s\r\n",
         100, startupCounte, (char*)tempBuf);
     if(memcmp(str, tempBuf, strlen(str)) == 0)
         return 0;
     return 1;
 }
+
+// AT24CXX_Test(AT24CXX_ADDRESS, AT4CXX_I2C);
 #endif /* __DEBUG_AT24CXX_ATY */
 
 

AT24CXX_ATY.h

@@ -24,6 +24,8 @@
 *       - 1_01_221212 > ATY
 *           -# Change to general I2C function
 *           -# Change and remove several functions
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -84,10 +86,6 @@
 #define AT24CXX_A1 0
 #define AT24CXX_A0 0
 
-#define AT24CXX_WRITE_DELAY     16
-
-/******************************************************************************/
-
 /*
 The next 3 bits are the A2, A1 and A0 device address bits for the 2K EEPROM.
 These 3 bits must compare to their corresponding hardwired input pins.
@@ -109,6 +107,13 @@ If a compare is not made, the chip will return to a standby state.
 
 // 1 0 1 0 A2 A1 A0 R/W
 #define AT24CXX_ADDRESS         (0x50 | (AT24CXX_A2 << 2) | (AT24CXX_A1 << 1) | AT24CXX_A0)
+// #define AT4CXX_I2C I2C_C1
+
+
+#define AT24CXX_WRITE_DELAY     16
+
+/******************************************************************************/
+
 
 
 #define AT24C01                 127
@@ -138,17 +143,17 @@ If a compare is not made, the chip will return to a standby state.
 #define AT24CXX_PAGE_SIZE       256
 #endif
 
-uint8_t AT24CXX_ReadByte(uint16_t addr);
-void AT24CXX_WriteByte(uint16_t addr, uint8_t data_t);
-void AT24CXX_Read(uint16_t addr, uint8_t* pbuf, uint16_t len);
-void AT24CXX_Write(uint16_t addr, uint8_t* pbuf, uint16_t len);
-void AT24CXX_WriteRandom(uint16_t addr, uint8_t* pbuf, uint16_t len);
-uint8_t AT24CXX_Check(void);
+uint8_t AT24CXX_ReadByte(uint16_t regAddr, uint8_t addr, uint8_t channel);
+void AT24CXX_WriteByte(uint16_t regAddr, uint8_t data_t, uint8_t addr, uint8_t channel);
+void AT24CXX_Read(uint16_t regAddr, uint8_t* pbuf, uint16_t len, uint8_t addr, uint8_t channel);
+void AT24CXX_Write(uint16_t regAddr, uint8_t* pbuf, uint16_t len, uint8_t addr, uint8_t channel);
+void AT24CXX_WriteRandom(uint16_t regAddr, uint8_t* pbuf, uint16_t len, uint8_t addr, uint8_t channel);
+uint8_t AT24CXX_Check(, uint8_t addr, uint8_t channel);
 
-void AT24CXX_Init(void);
+void AT24CXX_Init(uint8_t addr, uint8_t channel);
 
 #ifdef __DEBUG_AT24CXX_ATY
-uint8_t AT24CXX_Test(void);
+uint8_t AT24CXX_Test(uint8_t addr, uint8_t channel);
 #endif /* __DEBUG_AT24CXX_ATY */
 
 

BMP280_ATY.c

@@ -21,6 +21,8 @@
 * @version
 *       - 1_01_220804 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -35,12 +37,14 @@
 
 /**
  * @brief   BMP280 read id
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  id number like 0x58, 0x88
  */
-uint8_t BMP280_ReadId(void)
+uint8_t BMP280_ReadId(uint8_t addr, uint8_t channel)
 {
     uint8_t temp_uint8;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_CHIPID_REG, &temp_uint8, 1);
+    I2C_ReadReg(addr, BMP280_CHIPID_REG, &temp_uint8, 1, channel);
     return temp_uint8;
 
 }
@@ -48,12 +52,14 @@ uint8_t BMP280_ReadId(void)
 /**
  * @brief   BMP280 get status
  * @param   status_flag the bit to get
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  1 or 0 at bit status_flag
  */
-uint8_t BMP280_GetStatus(uint8_t status_flag)
+uint8_t BMP280_GetStatus(uint8_t status_flag, uint8_t addr, uint8_t channel)
 {
     uint8_t flag;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_STATUS_REG, &flag, 1);
+    I2C_ReadReg(addr, BMP280_STATUS_REG, &flag, 1, channel);
     // status_flag = BMP280_MEASURING || BMP280_IM_UPDATE
     // if(flag & status_flag) return 1;
     // else return 0;
@@ -63,29 +69,33 @@ uint8_t BMP280_GetStatus(uint8_t status_flag)
 /**
  * @brief   BMP280 set oversamp
  * @param   config Oversample_Mode value
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void BMP280_SetOversamp(BMP280_OVERSAMPLE_MODE* config)
+void BMP280_SetOversamp(BMP280_OVERSAMPLE_MODE* config, uint8_t addr, uint8_t channel)
 {
     uint8_t temp_uint8;
     temp_uint8 = ((config->T_Osample) << 5) |
         ((config->P_Osample) << 2) |
         ((config)->WORKMODE);
 
-    I2C_WriteReg(BMP280_ADDRESS, BMP280_CTRLMEAS_REG, &temp_uint8, 1);
+    I2C_WriteReg(addr, BMP280_CTRLMEAS_REG, &temp_uint8, 1, channel);
 }
 
 /**
  * @brief   BMP280 set standby filter
  * @param   config bmp280 config
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void BMP280_SetStandbyFilter(BMP280_CONFIG* config)
+void BMP280_SetStandbyFilter(BMP280_CONFIG* config, uint8_t addr, uint8_t channel)
 {
     uint8_t temp_uint8;
     temp_uint8 = ((config->T_SB) << 5) |
         ((config->FILTER_COEFFICIENT) << 2) |
         ((config->SPI_EN));
 
-    I2C_WriteReg(BMP280_ADDRESS, BMP280_CONFIG_REG, &temp_uint8, 1);
+    I2C_WriteReg(addr, BMP280_CONFIG_REG, &temp_uint8, 1, channel);
 }
 
 
@@ -139,17 +149,19 @@ BMP280_U32_t BM280_CompensateP(BMP280_S32_t adc_P)
 
 /**
  * @brief   BMP280 get temperature
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  temperature real value in int32
  */
-BMP280_S32_t BMP280_GetTemperature(void)
+BMP280_S32_t BMP280_GetTemperature(uint8_t addr, uint8_t channel)
 {
     uint8_t xlsb, lsb, msb;
     long signed bit32;
     BMP280_S32_t temperature;
 
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_TEMPERATURE_XLSB_REG, &xlsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_TEMPERATURE_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_TEMPERATURE_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_TEMPERATURE_XLSB_REG, &xlsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_TEMPERATURE_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_TEMPERATURE_MSB_REG, &msb, 1, channel);
     // The value of a register forming a floating point number
     bit32 = ((long)(msb << 12)) | ((long)(lsb << 4)) | (xlsb >> 4);
     temperature = BM280_CompensateT(bit32);
@@ -159,17 +171,19 @@ BMP280_S32_t BMP280_GetTemperature(void)
 
 /**
  * @brief   BMP280 get pressure
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  pressure real value in uint32
  */
-BMP280_U32_t BMP280_GetPressure(void)
+BMP280_U32_t BMP280_GetPressure(uint8_t addr, uint8_t channel)
 {
     uint8_t xlsb, lsb, msb;
     long signed bit32;
     BMP280_U32_t pressure;
 
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_PRESSURE_XLSB_REG, &xlsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_PRESSURE_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_PRESSURE_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_PRESSURE_XLSB_REG, &xlsb, 1);
+    I2C_ReadReg(addr, BMP280_PRESSURE_LSB_REG, &lsb, 1);
+    I2C_ReadReg(addr, BMP280_PRESSURE_MSB_REG, &msb, 1);
     // The value of a register forming a floating point number
     bit32 = ((long)(msb << 12)) | ((long)(lsb << 4)) | (xlsb >> 4);
     pressure = BM280_CompensateP(bit32);
@@ -225,17 +239,19 @@ double BM280_CompensateP(BMP280_S32_t adc_P)
 
 /**
  * @brief   BMP280 get temperature
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  temperature real value in double
  */
-double BMP280_GetTemperature(void)
+double BMP280_GetTemperature(uint8_t addr, uint8_t channel)
 {
     uint8_t xlsb, lsb, msb;
     long signed bit32;
     double temperature;
 
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_TEMPERATURE_XLSB_REG, &xlsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_TEMPERATURE_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_TEMPERATURE_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_TEMPERATURE_XLSB_REG, &xlsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_TEMPERATURE_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_TEMPERATURE_MSB_REG, &msb, 1, channel);
     // The value of a register forming a floating point number
     bit32 = ((long)(msb << 12)) | ((long)(lsb << 4)) | (xlsb >> 4);
     temperature = BM280_CompensateT(bit32);
@@ -245,17 +261,19 @@ double BMP280_GetTemperature(void)
 
 /**
  * @brief   BMP280 get pressure
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  pressure real value in double
  */
-double BMP280_GetPressure(void)
+double BMP280_GetPressure(uint8_t addr, uint8_t channel)
 {
     uint8_t xlsb, lsb, msb;
     long signed bit32;
     double pressure;
 
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_PRESSURE_XLSB_REG, &xlsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_PRESSURE_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_PRESSURE_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_PRESSURE_XLSB_REG, &xlsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_PRESSURE_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_PRESSURE_MSB_REG, &msb, 1, channel);
     // The value of a register forming a floating point number
     bit32 = ((long)(msb << 12)) | ((long)(lsb << 4)) | (xlsb >> 4);
     pressure = BM280_CompensateP(bit32);
@@ -270,79 +288,83 @@ struct _BMP280_CC bmp280Cc = {0};  // Used to store the compensation parameters
 
 /**
  * @brief   BMP280 initialize
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void BM280_Init(void)
+void BM280_Init(uint8_t addr, uint8_t channel)
 {
     uint8_t lsb, msb;
 
     // Correction value of the temperature
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_T1_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_T1_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_T1_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_T1_MSB_REG, &msb, 1, channel);
     bmp280Cc.T1 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_T2_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_T2_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_T2_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_T2_MSB_REG, &msb, 1, channel);
     bmp280Cc.T2 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_T3_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_T3_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_T3_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_T3_MSB_REG, &msb, 1, channel);
     bmp280Cc.T3 = (((uint16_t)msb) << 8) + lsb;
 
     // Correction value of the pressure
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P1_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P1_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P1_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P1_MSB_REG, &msb, 1, channel);
     bmp280Cc.P1 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P2_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P2_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P2_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P2_MSB_REG, &msb, 1, channel);
     bmp280Cc.P2 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P3_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P3_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P3_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P3_MSB_REG, &msb, 1, channel);
     bmp280Cc.P3 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P4_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P4_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P4_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P4_MSB_REG, &msb, 1, channel);
     bmp280Cc.P4 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P5_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P5_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P5_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P5_MSB_REG, &msb, 1, channel);
     bmp280Cc.P5 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P6_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P6_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P6_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P6_MSB_REG, &msb, 1, channel);
     bmp280Cc.P6 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P7_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P7_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P7_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P7_MSB_REG, &msb, 1, channel);
     bmp280Cc.P7 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P8_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P8_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P8_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P8_MSB_REG, &msb, 1, channel);
     bmp280Cc.P8 = (((uint16_t)msb) << 8) + lsb;
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P9_LSB_REG, &lsb, 1);
-    I2C_ReadReg(BMP280_ADDRESS, BMP280_DIG_P9_MSB_REG, &msb, 1);
+    I2C_ReadReg(addr, BMP280_DIG_P9_LSB_REG, &lsb, 1, channel);
+    I2C_ReadReg(addr, BMP280_DIG_P9_MSB_REG, &msb, 1, channel);
     bmp280Cc.P9 = (((uint16_t)msb) << 8) + lsb;
 
     // Reset
-    I2C_WriteReg(BMP280_ADDRESS, BMP280_RESET_REG, (uint8_t*)BMP280_RESET_VALUE, 1);
+    I2C_WriteReg(addr, BMP280_RESET_REG, (uint8_t*)BMP280_RESET_VALUE, 1, channel);
 
     BMP280_OVERSAMPLE_MODE BMP_OVERSAMPLE_MODEStructure;
     BMP_OVERSAMPLE_MODEStructure.P_Osample = BMP280_P_MODE_3;
     BMP_OVERSAMPLE_MODEStructure.T_Osample = BMP280_T_MODE_1;
     BMP_OVERSAMPLE_MODEStructure.WORKMODE = BMP280_NORMAL_MODE;
-    BMP280_SetOversamp(&BMP_OVERSAMPLE_MODEStructure);
+    BMP280_SetOversamp(&BMP_OVERSAMPLE_MODEStructure, addr, channel);
 
     BMP280_CONFIG BMP_CONFIGStructure;
     BMP_CONFIGStructure.T_SB = BMP280_T_SB1;
     BMP_CONFIGStructure.FILTER_COEFFICIENT = BMP280_FILTER_MODE_4;
     BMP_CONFIGStructure.SPI_EN = DISABLE;
 
-    BMP280_SetStandbyFilter(&BMP_CONFIGStructure);
+    BMP280_SetStandbyFilter(&BMP_CONFIGStructure, addr, channel);
 }
 
 /**
  * @brief   BMP280 check whether the device exists
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: error
  */
-uint8_t BMP280_InitAndCheck(void)
+uint8_t BMP280_InitAndCheck(uint8_t addr, uint8_t channel)
 {
-    BM280_Init();
+    BM280_Init(addr, channel);
     DelayMs(50);
 
     uint8_t bmp280Id = 0;
-    bmp280Id = BMP280_ReadId();
+    bmp280Id = BMP280_ReadId(addr, channel);
 #ifdef __DEBUG_BMP280_ATY
     printf("\r\nBMP280 ID: 0x%02X", bmp280Id);
 #endif /* __DEBUG_BMP280_ATY */
@@ -358,14 +380,16 @@ uint8_t BMP280_InitAndCheck(void)
 /**
  * @brief   BMP280 read temperature and pressure
  * @param   tp data group to save tp value
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: error
  */
-uint8_t BMP280_ReadTP(double* tp)
+uint8_t BMP280_ReadTP(double* tp, uint8_t addr, uint8_t channel)
 {
     uint16_t errCount = 1000;
     for(uint8_t i = 0; i < errCount; i++)
     {
-        if(BMP280_GetStatus(BMP280_MEASURING) == 0)
+        if(BMP280_GetStatus(BMP280_MEASURING, addr, channel) == 0)
             break;
         if(i == errCount - 1)
             return 2;
@@ -373,14 +397,14 @@ uint8_t BMP280_ReadTP(double* tp)
     }
     for(uint8_t i = 0; i < errCount; i++)
     {
-        if(BMP280_GetStatus(BMP280_IM_UPDATE) == 0)
+        if(BMP280_GetStatus(BMP280_IM_UPDATE, addr, channel) == 0)
             break;
         if(i == errCount - 1)
             return 3;
         DelayMs(1);
     }
-    tp[0] = BMP280_GetTemperature();
-    tp[1] = BMP280_GetPressure();
+    tp[0] = BMP280_GetTemperature(addr, channel);
+    tp[1] = BMP280_GetPressure(addr, channel);
 
     return 0;
 }
@@ -391,15 +415,17 @@ uint8_t bmp280InitFlag = 0;
 /**
  * @brief   BMP280 get data flow path
  * @param   tp data group to save tp value
+ * @param   addr chip address
+ * @param   channel chip channel
  * @return  errCode, 0: success, !0: error
  */
-uint8_t BMP280_TempPreGet(uint16_t* tp)
+uint8_t BMP280_TempPreGet(uint16_t* tp, uint8_t addr, uint8_t channel)
 {
     double bmp280Value[2];
 
     if(bmp280InitFlag == 0)
     {
-        if(BMP280_InitAndCheck())
+        if(BMP280_InitAndCheck(addr, channel))
         {
             bmp280InitFlag = 2;
         }
@@ -418,7 +444,7 @@ uint8_t BMP280_TempPreGet(uint16_t* tp)
     else if(bmp280InitFlag == 1)
     {
         uint8_t errValue = 0;
-        errValue = BMP280_ReadTP(bmp280Value);
+        errValue = BMP280_ReadTP(bmp280Value, addr, channel);
         if(errValue == 0)
         {
             if(bmp280Value[1] != 0)
@@ -449,6 +475,7 @@ uint8_t BMP280_TempPreGet(uint16_t* tp)
     return 0;
 }
 
+// todo: not tested
 
 
 #endif /* __BMP280_ATY_C */

BMP280_ATY.h

@@ -21,6 +21,8 @@
 * @version
 *       - 1_01_220831 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -32,11 +34,13 @@
 
 /******************************* For user *************************************/
 // Set SDO voltage level for device address
-#define BP280_SDO 1
+#define BMP280_SDO 1
+#define BMP280_ADDRESS                      (0x76 | BMP280_SDO)
 
 // #define BMP280_USE_FIXED_POINT_COMPENSATE
 
 // #define __DEBUG_BMP280_ATY
+// #define BMP280_I2C I2C_C1
 
 /******************************************************************************/
 
@@ -44,7 +48,6 @@ typedef long signed int                     BMP280_S32_t;   // signed 32
 typedef long unsigned int                   BMP280_U32_t;   // unsigned 32
 typedef long long signed int                BMP280_S64_t;   // signed 64
 
-#define BMP280_ADDRESS                      (0x76 | BP280_SDO)
 
 #define BMP280_RESET_VALUE                  0xB6
 
@@ -173,7 +176,7 @@ extern struct _BMP280_CC bmp280Cc;
 
 extern uint8_t bmp280Id;
 extern uint8_t bmp280InitFlag;
-uint8_t BMP280_TempPreGet(uint16_t* tp);
+uint8_t BMP280_TempPreGet(uint16_t* tp, uint8_t addr, uint8_t channel);
 
 
 #endif /* __BMP280_ATY_H */

DS18B20_ATY.c

@@ -261,6 +261,7 @@ u8 DS18B20_MatchROM(void)
     return 0;
 }
 
+// todo: not tested
 
 
 #endif /* __DS18B20_ATY_C */

GP22_ATY.c

@@ -364,7 +364,7 @@ volatile uint8_t startPulseNum = 6;
 // #define GP22_MEASURE_UsWave1MHz
 
 /******************************************************************************/
-#if defined(GP22_MEASURE_UsWave1MHz)
+#if defined (GP22_MEASURE_UsWave1MHz)
 void GP22_RegInit_UsWave1MHz(void)
 {
     GP22_REG[0] = GP22_CFG_KEEP_DEFAULT0
@@ -765,6 +765,7 @@ void GP22_Process(uint32_t* gp22ProcessValue)
 
 
 
+// todo: not full tested
 
 
 

HW_ADC_ATY.c

@@ -31,7 +31,7 @@
 #include "HW_ADC_ATY.h"
 
 /******************************* For user *************************************/
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 /**
  * @brief   ADC init
  */
@@ -52,7 +52,7 @@ void ADC_Init(void)
 
 /******************************************************************************/
 
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 /**
  * @brief   ADC get mcu vref
  * @return  mcu vref data
@@ -91,7 +91,7 @@ uint16_t ADC_Get(uint8_t channel)
 }
 #elif defined(__STM32_HAL_ATY)
 #include "adc.h"
-// set channel to 0 for scnad mode
+// set channel to 0 for scand mode
 uint16_t ADC_Get(ADC_HandleTypeDef* adc, uint32_t channel)
 {
 #if defined (__STM32F4xx_ADC_H)
@@ -114,7 +114,7 @@ uint16_t ADC_Get(ADC_HandleTypeDef* adc, uint32_t channel)
     HAL_ADC_PollForConversion(adc, 1000);
     if(HAL_IS_BIT_SET(HAL_ADC_GetState(adc), HAL_ADC_STATE_REG_EOC))
         return HAL_ADC_GetValue(adc);
-    return 0;
+    return 0.1;
 }
 
 #endif /* PLATFORM */

HW_ADC_ATY.h

@@ -35,7 +35,7 @@
 
 void ADC_Init(void);
 float ADC_GetVref(void);
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 uint16_t ADC_Get(uint8_t channel);
 #elif defined(__STM32_HAL_ATY)
 uint16_t ADC_Get(ADC_HandleTypeDef* adc, uint32_t channel);

HW_GPIO_ATY.c

@@ -31,7 +31,7 @@
 #include "HW_GPIO_ATY.h"
 
 /******************************* For user *************************************/
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 
 #elif defined(__STM32_HAL_ATY)
 // void GPIO_SetOut(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)

HW_GPIO_ATY.h

@@ -30,11 +30,9 @@
 
 #include "INCLUDE_ATY.h"
 
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 #define GPIO_SET_H(Port, Pin)       Pin = 1
 #define GPIO_SET_L(Port, Pin)       Pin = 0
-#define GPIO_GET_H(Port, Pin)       Pin == 1
-#define GPIO_GET_L(Port, Pin)       Pin == 0
 #define GPIO_GET(Port, Pin)         Pin
 #define GPIO_SET_IN(Port, Pin)      Pin = 1;__NOP_ATY;__NOP_ATY
 #define GPIO_SET_OUT(Port, Pin)     Pin = 0
@@ -42,14 +40,12 @@
 #elif defined(__HC32_ATY)
 #define GPIO_SET_H(Port, Pin)       Gpio_SetIO(Port, Pin)
 #define GPIO_SET_L(Port, Pin)       Gpio_ClrIO(Port, Pin)
-#define GPIO_GET_H(Port, Pin)       Gpio_GetInputIO(Port, Pin) == 1
-#define GPIO_GET_L(Port, Pin)       Gpio_GetInputIO(Port, Pin) == 0
+#define GPIO_GET(Port, Pin)         ((Gpio_GetInputIO(Port, Pin) == 0) ? 0: 1)
 
 #elif defined(__STM32_HAL_ATY)
 #define GPIO_SET_H(Port, Pin)       HAL_GPIO_WritePin(Port, Pin, GPIO_PIN_SET)
 #define GPIO_SET_L(Port, Pin)       HAL_GPIO_WritePin(Port, Pin, GPIO_PIN_RESET)
-#define GPIO_GET_H(Port, Pin)       HAL_GPIO_ReadPin(Port, Pin) == GPIO_PIN_SET
-#define GPIO_GET_L(Port, Pin)       HAL_GPIO_ReadPin(Port, Pin) == GPIO_PIN_RESET
+#define GPIO_GET(Port, Pin)         ((HAL_GPIO_ReadPin(Port, Pin) == GPIO_PIN_RESET) ? 0: 1)
 #define GPIO_SET_IN(Port, Pin)      GPIO_SetIn(Port, Pin)
 #define GPIO_SET_OUT(Port, Pin)     GPIO_SetOut(Port, Pin)
 
@@ -81,7 +77,7 @@
 
 
 /******************************* For user *************************************/
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 #ifdef __LED_ATY_H
 #ifndef SYSLED_PORT
 #define SYSLED_PORT                 0
@@ -161,16 +157,16 @@ do{ \
 #endif /* SYSLED_PORT SYSLED_PIN */
 #endif /* __LED_ATY_H */
 
-#ifdef __MOTOR_STEP_ATY_H
+#ifdef __TMC2209_ATY_H
 #define MOTOR_EN_PORT               MO2_EN_GPIO_Port
 #define MOTOR_EN_PIN                MO2_EN_Pin
 #define MOTOR_DIR_PORT              MO2_DIR_GPIO_Port
 #define MOTOR_DIR_PIN               MO2_DIR_Pin
-#define MOTOR_STEP_PORT             MO2_STEP_GPIO_Port
-#define MOTOR_STEP_PIN              MO2_STEP_Pin
+#define TMC2209_PORT             MO2_STEP_GPIO_Port
+#define TMC2209_PIN              MO2_STEP_Pin
 #define MOTOR_DIAG_PORT             0
 #define MOTOR_DIAG_PIN              0
-#endif /* __MOTOR_STEP_ATY_H */
+#endif /* __TMC2209_ATY_H */
 
 #ifndef __I2C_HARDWARE_ATY
 #define I2C_SCL_PORT                I2C_SCL_GPIO_Port

HW_I2C_ATY.c

@@ -25,7 +25,10 @@
 *           -# Change delay flow
 *           -# Change SDA set function
 *           -# Add Read/Write function
-*           -Undone: hardware not test
+*       - 1_02_240108 > ATY
+*           -# add multy addr and channel
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
@@ -35,235 +38,255 @@
 #include "HW_I2C_ATY.h"
 
 /******************************* For user *************************************/
-void OLED_Delay(uint8_t t)
-{
-    while(t--);
-}
-/******************************************************************************/
-
-#ifndef __I2C_HARDWARE_ATY
-// 1: Out, 0: In, config default out
-uint8_t i2c_SdaDir = 1;
-
-/**
- * @brief   Set SDA output
- */
-void I2C_SDA_SetOut(void)
-{
-    if(i2c_SdaDir == 0)
-    {
-        i2c_SdaDir = 1;
-        GPIO_SET_OUT(I2C_SDA_PORT, I2C_SDA_PIN);
-    }
-}
-
-/**
- * @brief   Set SDA input
- */
-void I2C_SDA_SetIn(void)
-{
-    if(i2c_SdaDir == 1)
-    {
-        i2c_SdaDir = 0;
-        GPIO_SET_IN(I2C_SDA_PORT, I2C_SDA_PIN);
-    }
-}
 
+/******************************************************************************/
 
 /**
  * @brief   Star I2C bus
+ *
+ * @param   dev
+ * @return  uint8_t
  * @note    START:when CLK is high,DATA change form high to low
  */
-void I2C_Start(void)
+uint8_t I2C_Start(struct HW_I2C_ATY_Dev* dev)
 {
-    I2C_SDA_SET_OUT;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SDA_SET_H;
-    I2C_SCL_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SDA_SET_L;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_L;
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_O);
+    dev->delay(SHORT_DELAY);
+    dev->sdaSet('L', _ATY_HL_H);
+    dev->sclSet(_ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    dev->sdaSet('L', _ATY_HL_L);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_L);
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 /**
  * @brief   Stop I2C bus
+ *
+ * @param   dev
+ * @return  uint8_t
  * @note    STOP:when CLK is high DATA change form low to high
  */
-void I2C_Stop(void)
+uint8_t I2C_Stop(struct HW_I2C_ATY_Dev* dev)
 {
-    I2C_SDA_SET_OUT;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_L;
-    I2C_SDA_SET_L;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SDA_SET_H;
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_O);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_L);
+    dev->sdaSet('L', _ATY_HL_L);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    dev->sdaSet('L', _ATY_HL_H);
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 /**
  * @brief   I2C ack
+ *
+ * @param   dev
+ * @return  uint8_t
  */
-void I2C_Ack(void)
+uint8_t I2C_Ack(struct HW_I2C_ATY_Dev* dev)
 {
-    I2C_SDA_SET_OUT;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_L;
-    I2C_SDA_SET_L;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_L;
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_O);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_L);
+    dev->sdaSet('L', _ATY_HL_L);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_L);
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 /**
  * @brief   I2C no ack
+ *
+ * @param   dev
+ * @return  uint8_t
  */
-void I2C_NoAck(void)
+uint8_t I2C_NoAck(struct HW_I2C_ATY_Dev* dev)
 {
-    I2C_SDA_SET_OUT;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_L;
-    I2C_SDA_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_L;
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_O);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_L);
+    dev->sdaSet('L', _ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_L);
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 /**
  * @brief   Wait ack coming
+ *
  * @param   maxErrTime max time to wait until fail
+ * @param   dev
  * @return  0 success, !0: fail
  */
-uint8_t I2C_WaitAck(uint16_t maxErrTime)
+uint8_t I2C_WaitAck(uint16_t maxErrTime, struct HW_I2C_ATY_Dev* dev)
 {
     uint16_t errTime = 0;
 
-    I2C_SDA_SET_IN;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    while(I2C_SDA_GET_H)
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_I);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    while(dev->sdaGet() == 1)
     {
         errTime++;
-        OLED_Delay(2);
+        dev->delay(2);
         if(errTime > maxErrTime)
         {
-            I2C_Stop();
+            __ATY_UNLOCK(dev);
+            I2C_Stop(dev);
             return 1;
         }
     }
-    I2C_SCL_SET_L;
+    dev->sclSet(_ATY_HL_L);
 
+    __ATY_UNLOCK(dev);
     return 0;
 }
 
 /**
  * @brief   I2C send one byte
+ *
  * @param   byte data to send
+ * @param   dev
+ * @return  uint8_t
  */
-void I2C_WriteByte(uint8_t byte)
+uint8_t I2C_WriteByte(uint8_t byte, struct HW_I2C_ATY_Dev* dev)
 {
     uint8_t isb_i;
 
-    I2C_SDA_SET_OUT;
-    OLED_Delay(LONG_DELAY);
-    I2C_SCL_SET_L;
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_O);
+    dev->delay(LONG_DELAY);
+    dev->sclSet(_ATY_HL_L);
     for(isb_i = 0; isb_i < 8; isb_i++)
     {
-        OLED_Delay(SHORT_DELAY);
+        dev->delay(SHORT_DELAY);
         if((byte & 0x80) >> 7)
-            I2C_SDA_SET_H;
+            dev->sdaSet('L', _ATY_HL_H);
         else
-            I2C_SDA_SET_L;
-        OLED_Delay(SHORT_DELAY);
-        I2C_SCL_SET_H;
-        OLED_Delay(SHORT_DELAY);
-        I2C_SCL_SET_L;
+            dev->sdaSet('L', _ATY_HL_L);
+        dev->delay(SHORT_DELAY);
+        dev->sclSet(_ATY_HL_H);
+        dev->delay(SHORT_DELAY);
+        dev->sclSet(_ATY_HL_L);
         byte <<= 1;
     }
-    OLED_Delay(SHORT_DELAY);
-    I2C_SDA_SET_H;
-    OLED_Delay(SHORT_DELAY);
-    I2C_SCL_SET_H;
-    // OLED_Delay(SHORT_DELAY);
-    // I2C_SCL_SET_L;
+    dev->delay(SHORT_DELAY);
+    dev->sdaSet('L', _ATY_HL_H);
+    dev->delay(SHORT_DELAY);
+    dev->sclSet(_ATY_HL_H);
+    // dev->delay(SHORT_DELAY);
+    // dev->sclSet(_ATY_HL_L);
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 /**
  * @brief   I2C read one byte
+ *
  * @param   ack if send ACK or not
+ * @param   dev
  * @return  data to read
  */
-uint8_t I2C_ReadByte(uint8_t ack)
+uint8_t I2C_ReadByte(uint8_t ack, struct HW_I2C_ATY_Dev* dev)
 {
     uint8_t irb_i, byte = 0;
 
-    I2C_SDA_SET_IN;
-    OLED_Delay(LONG_DELAY);
+    __ATY_LOCK(dev);
+    dev->sdaSet('I', _ATY_IO_I);
+    dev->delay(LONG_DELAY);
     for(irb_i = 0; irb_i < 8; irb_i++)
     {
-        I2C_SCL_SET_L;
-        OLED_Delay(SHORT_DELAY);
-        I2C_SCL_SET_H;
-        OLED_Delay(SHORT_DELAY);
+        dev->sclSet(_ATY_HL_L);
+        dev->delay(SHORT_DELAY);
+        dev->sclSet(_ATY_HL_H);
+        dev->delay(SHORT_DELAY);
         byte <<= 1;
-        if(I2C_SDA_GET_H) byte++;
+        if(dev->sdaGet() == 1) byte++;
     }
-    I2C_SCL_SET_L;
+    dev->sclSet(_ATY_HL_L);
+    __ATY_UNLOCK(dev);
     if(ack)
-        I2C_Ack();
+        I2C_Ack(dev);
     else
-        I2C_NoAck();
+        I2C_NoAck(dev);
 
     return byte;
 }
 
 /**
  * @brief   Write serial data to reg
+ *
  * @param   addr slave machine address
  * @param   data_t data to write(uint8)
  * @param   len length of write data(uint8)
+ * @param   dev
  * @return  0: success, !0: error
  */
-uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len)
+uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev)
 {
-    uint8_t i = 0;
-    I2C_Start();
-    I2C_WriteByte(addr << 1 | 0);
-    if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
-        return 1;
-    for(i = 0; i < len; i++)
-    {
-        I2C_WriteByte(data_t[i]);
-        if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
+    if(dev->hardwareEnable == 1){
+        uint8_t errCode = 0;
+        __ATY_LOCK(dev);
+        errCode = dev->i2cProcess((addr << 1 | 0), data_t, len, _ATY_RW_W);
+        __ATY_UNLOCK(dev);
+        return errCode;
+    }
+    else{
+        uint8_t i = 0;
+        I2C_Start(dev);
+        I2C_WriteByte((addr << 1 | 0), dev);
+        if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
             return 1;
+        for(i = 0; i < len; i++)
+        {
+            I2C_WriteByte(data_t[i], dev);
+            if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
+                return 1;
+        }
+        I2C_Stop(dev);
+        return 0;
     }
-    I2C_Stop();
-    return 0;
 }
 
 /**
  * @brief   Write serial data to reg
+ *
  * @param   addr slave machine address
  * @param   data_t data to write(uint8)
  * @param   len length of write data(uint8)
+ * @param   dev
  * @return  0: success, !0: error
  */
-uint8_t I2C_Write_NoStop(uint8_t addr, uint8_t* data_t, uint8_t len)
+uint8_t I2C_Write_NoStop(uint8_t addr, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev)
 {
     uint8_t i = 0;
-    I2C_Start();
-    I2C_WriteByte(addr << 1 | 0);
-    if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
+    I2C_Start(dev);
+    I2C_WriteByte((addr << 1 | 0), dev);
+    if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
         return 1;
 
     for(i = 0; i < len; i++)
     {
-        I2C_WriteByte(data_t[i]);
-        if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
+        I2C_WriteByte(data_t[i], dev);
+        if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
             return 1;
     }
     return 0;
@@ -271,326 +294,387 @@ uint8_t I2C_Write_NoStop(uint8_t addr, uint8_t* data_t, uint8_t len)
 
 /**
  * @brief   Read serial data to reg
+ *
  * @param   addr slave machine address
  * @param   data_t data to read(uint8)
  * @param   len length of read data(uint8)
+ * @param   dev
  * @return  0: success, !0: error
  */
-uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len)
+uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev)
 {
-
-    I2C_Start();
-    I2C_WriteByte(addr << 1 | 1);
-    if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
-        return 1;
-    while(len--)
-    {
-        if(len > 0)
-            *data_t++ = I2C_ReadByte(1);
-        else
-            *data_t++ = I2C_ReadByte(0);
+    if(dev->hardwareEnable == 1){
+        uint8_t errCode = 0;
+        __ATY_LOCK(dev);
+        errCode = dev->i2cProcess((addr << 1 | 1), data_t, len, _ATY_RW_R);
+        __ATY_UNLOCK(dev);
+        return errCode;
+    }
+    else{
+        I2C_Start(dev);
+        I2C_WriteByte((addr << 1 | 1), dev);
+        if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
+            return 1;
+        while(len--)
+        {
+            if(len > 0)
+                *data_t++ = I2C_ReadByte(1, dev);
+            else
+                *data_t++ = I2C_ReadByte(0, dev);
+        }
+        I2C_Stop(dev);
+        return 0;
     }
-    I2C_Stop();
-
-    return 0;
 }
 
 /**
  * @brief   Write serial data to reg
+ *
  * @param   addr slave machine address
  * @param   reg reg addr to write
  * @param   data_t data to write(uint8)
  * @param   len length of write data(uint8)
+ * @param   dev
  * @return  0: success, !0: error
  */
-uint8_t I2C_WriteReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len)
+uint8_t I2C_WriteReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev)
 {
     uint8_t i = 0;
-    I2C_Start();
-    I2C_WriteByte(addr << 1 | 0);
-    if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
+    I2C_Start(dev);
+    I2C_WriteByte((addr << 1 | 0), dev);
+    if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
     {
-        I2C_Stop();
+        I2C_Stop(dev);
         return 1;
     }
 
     if(reg != 0)
     {
-        I2C_WriteByte(reg);
-        I2C_WaitAck(I2C_WAIT_ACK_TIME);
+        I2C_WriteByte(reg, dev);
+        I2C_WaitAck(I2C_WAIT_ACK_TIME, dev);
     }
 
     for(i = 0; i < len; i++)
     {
-        I2C_WriteByte(data_t[i]);
-        if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
+        I2C_WriteByte(data_t[i], dev);
+        if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
         {
-            I2C_Stop();
+            I2C_Stop(dev);
             return 1;
         }
     }
-    I2C_Stop();
+    I2C_Stop(dev);
     return 0;
 }
 
 /**
  * @brief   Read serial data to reg
+ *
  * @param   addr slave machine address
  * @param   reg reg addr to read
  * @param   data_t data to read(uint8)
  * @param   len length of read data(uint8)
+ * @param   dev
  * @return  0: success, !0: error
  */
-uint8_t I2C_ReadReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len)
+uint8_t I2C_ReadReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev)
 {
-    I2C_Start();
-    I2C_WriteByte(addr << 1 | 0);
-    if(I2C_WaitAck(I2C_WAIT_ACK_TIME))
+    I2C_Start(dev);
+    I2C_WriteByte((addr << 1 | 0), dev);
+    if(I2C_WaitAck(I2C_WAIT_ACK_TIME, dev))
     {
-        I2C_Stop();
+        I2C_Stop(dev);
         return 1;
     }
-    I2C_WriteByte(reg);
-    I2C_WaitAck(I2C_WAIT_ACK_TIME);
-    I2C_Stop();
+    I2C_WriteByte(reg, dev);
+    I2C_WaitAck(I2C_WAIT_ACK_TIME, dev);
+    I2C_Stop(dev);
 
-    I2C_Start();
-    I2C_WriteByte(addr << 1 | 1);
-    I2C_WaitAck(I2C_WAIT_ACK_TIME);
+    I2C_Start(dev);
+    I2C_WriteByte((addr << 1 | 1), dev);
+    I2C_WaitAck(I2C_WAIT_ACK_TIME, dev);
     while(len)
     {
         if(len == 1)
-            *data_t = I2C_ReadByte(0);
+            *data_t = I2C_ReadByte(0, dev);
         else
-            *data_t = I2C_ReadByte(1);
+            *data_t = I2C_ReadByte(1, dev);
         len--;
         data_t++;
     }
-    I2C_Stop();
+    I2C_Stop(dev);
     return 0;
 }
 
-#else
-
-#if defined(__STM32_HAL_ATY)
-#include "i2c.h"
-
-/**
-* @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 */
-//  }
-//
-//}
-
-
-/**
- * @brief   Write serial data to reg
- * @param   addr slave machine address
- * @param   data_t data to write(uint8)
- * @param   len length of write data(uint8)
- * @return  0: success, !0: error
- */
-uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len)
-{
-    uint8_t i = 3;
-    while(i--)
-    {
-        if(HAL_I2C_Master_Transmit(&I2CH_N, addr << 1 | 0, data_t, len, 1000) == HAL_OK)
-            return 0;
-    }
-    return 1;
-}
-
-/**
- * @brief   Read serial data to reg
- * @param   addr slave machine address
- * @param   data_t data to read(uint8)
- * @param   len length of read data(uint8)
- * @return  0: success, !0: error
- */
-uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len)
-{
-    uint8_t i = 3;
-    while(i--)
-    {
-        if(HAL_I2C_Master_Receive(&I2CH_N, addr << 1 | 1, data_t, len, 1000) == HAL_OK)
-            return 0;
-    }
-    return 1;
-}
-
-#elif defined(__ESP8266_RTOS_ATY)
-#include "driver/i2c.h"
-#define I2C_EXAMPLE_MASTER_SCL_IO           2                /*!< gpio number for I2C master clock */
-#define I2C_EXAMPLE_MASTER_SDA_IO           14               /*!< gpio number for I2C master data  */
-#define I2C_EXAMPLE_MASTER_NUM              I2C_NUM_0        /*!< I2C port number for master dev */
-#define I2C_EXAMPLE_MASTER_TX_BUF_DISABLE   0                /*!< I2C master do not need buffer */
-#define I2C_EXAMPLE_MASTER_RX_BUF_DISABLE   0                /*!< I2C master do not need buffer */
-
-/**
- * @brief i2c master initialization
- */
-static esp_err_t i2c_example_master_init()
-{
-    int i2c_master_port = I2CH_N;
-    i2c_config_t conf;
-    conf.mode = I2C_MODE_MASTER;
-    conf.sda_io_num = I2C_EXAMPLE_MASTER_SDA_IO;
-    conf.sda_pullup_en = 1;
-    conf.scl_io_num = I2C_EXAMPLE_MASTER_SCL_IO;
-    conf.scl_pullup_en = 1;
-    conf.clk_stretch_tick = 300; // 300 ticks, Clock stretch is about 210us, you can make changes according to the actual situation.
-    ESP_ERROR_CHECK(i2c_driver_install(i2c_master_port, conf.mode));
-    ESP_ERROR_CHECK(i2c_param_config(i2c_master_port, &conf));
-    return ESP_OK;
-}
-
-/**
- * @brief   Write serial data to reg
- * @param   addr slave machine address
- * @param   data_t data to write(uint8)
- * @param   len length of write data(uint8)
- * @return  0: success, !0: error
- */
-uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len)
-{
-    int ret;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, addr << 1 | 0, ACK_CHECK_EN);
-    i2c_master_write(cmd, data_t, len, ACK_CHECK_EN);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(I2CH_N, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-
-    return ret;
-}
-
-/**
- * @brief   Read serial data to reg
- * @param   addr slave machine address
- * @param   data_t data to read(uint8)
- * @param   len length of read data(uint8)
- * @return  0: success, !0: error
- */
-uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len)
-{
-    int ret;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, addr << 1 | 0, ACK_CHECK_EN);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(I2CH_N, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-
-    if(ret != ESP_OK) {
-        return ret;
-    }
-
-    cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, addr << 1 | 1, ACK_CHECK_EN);
-    i2c_master_read(cmd, data_t, len, LAST_NACK_VAL);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-
-    return ret;
-}
+#endif /* __HW_I2C_ATY_C */
 
-// void Wait()
-// {
-//     while(!(I2CMSST & 0x40));
-//     I2CMSST &= ~0x40;
+/************************************ etc *************************************/
+/* init */
+// void I2C_1_SCL_SET(uint8_t level){ }
+// void I2C_1_SDA_SET(uint8_t cmd, uint8_t param){ }
+// uint8_t I2C_1_SDA_GET(void){ return 0; }
+
+// // STM32 HAL
+// uint8_t I2C_1(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W)
+//         return (uint8_t)HAL_I2C_Master_Transmit(&hi2c1, (addr << 1 | 0), data_t, len, 1000);
+//     else if(rw == _ATY_RW_R)
+//         return (uint8_t)HAL_I2C_Master_Receive(&hi2c1, (addr << 1 | 1), data_t, len, 1000);
+//     else if(rw == _ATY_RW_RW)    // todo: no stop
+//         return 0;
+//     return 0;
 // }
 
-// void Start()
+// // 51 // todo: not tested
+// uint8_t I2C_1(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw)
 // {
-//     I2CMSCR = 0x01;                             //发送START命令
-//     Wait();
+//     if(rw == _ATY_RW_W){
+//         uint8_t i = 0;
+//         uint16_t errCount = 1000;
+//         // Start();
+//         I2CMSCR = 0x01;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         // SendData((addr << 1 | 0));
+//         I2CTXD = (addr << 1 | 0);
+//         I2CMSCR = 0x02;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         // RecvACK();
+//         I2CMSCR = 0x03;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         for(i = 0; i < len; i++){
+//             // SendData(data_t[i]);
+//             I2CTXD = data_t[i];
+//             I2CMSCR = 0x02;
+//             // RecvACK();
+//             I2CMSCR = 0x03;
+//             while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//             if(errCount == 0) return 1; else errCount = 1000;
+//             I2CMSST &= ~0x40;
+//         }
+//         // Stop();
+//         I2CMSCR = 0x06;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         if(errCount == 0) return 1;
+//         return 0;
+//     }
+//     else if(rw == _ATY_RW_R){
+//         uint8_t i = 0;
+//         // Start();
+//         I2CMSCR = 0x01;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         // SendData((addr << 1 | 0));
+//         I2CTXD = (addr << 1 | 0);
+//         I2CMSCR = 0x02;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         // RecvACK();
+//         I2CMSCR = 0x03;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         for(i = 0; i < len; i++){
+//             // data_t[i] = RecvData();
+//             I2CMSCR = 0x04;
+//             while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//             if(errCount == 0) return 1; else errCount = 1000;
+//             I2CMSST &= ~0x40;
+//             data_t[i] = I2CRXD;
+//             if(i == len - 1){
+//                 // SendNAK();
+//                 I2CMSST = 0x01;
+//                 I2CMSCR = 0x05;
+//                 while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//                 if(errCount == 0) return 1; else errCount = 1000;
+//                 I2CMSST &= ~0x40;
+//             }
+//             else{
+//                 // SendACK();
+//                 I2CMSST = 0x00;
+//                 I2CMSCR = 0x05;
+//                 while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//                 if(errCount == 0) return 1; else errCount = 1000;
+//                 I2CMSST &= ~0x40;
+//             }
+//         }
+//         // Stop();
+//         I2CMSCR = 0x06;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         if(errCount == 0) return 1;
+//         return 0;
+//     }
+//     else if(rw == _ATY_RW_RW){
+//         uint8_t i = 0;
+//         // Start();
+//         I2CMSCR = 0x01;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         // SendData((addr << 1 | 0));
+//         I2CTXD = (addr << 1 | 0);
+//         I2CMSCR = 0x02;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         // RecvACK();
+//         I2CMSCR = 0x03;
+//         while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+//         I2CMSST &= ~0x40;
+//         for(i = 0; i < len; i++){
+//             // SendData(data_t[i]);
+//             I2CTXD = data_t[i];
+//             I2CMSCR = 0x02;
+//             // RecvACK();
+//             I2CMSCR = 0x03;
+//             while((!(I2CMSST & 0x40)) && errCount) errCount--;
+//             if(errCount == 0) return 1; else errCount = 1000;
+//             I2CMSST &= ~0x40;
+//         }
+//         if(errCount == 0) return 1;
+//         return 0;
+//     }
 // }
 
-// void SendData(char dat)
+// // ESP8266_RTOS // todo: not tested
+// #include "driver/i2c.h"
+// #define I2C_EXAMPLE_MASTER_SCL_IO           2                /*!< gpio number for I2C master clock */
+// #define I2C_EXAMPLE_MASTER_SDA_IO           14               /*!< gpio number for I2C master data  */
+// #define I2C_EXAMPLE_MASTER_NUM              I2C_NUM_0        /*!< I2C port number for master dev */
+// #define I2C_EXAMPLE_MASTER_TX_BUF_DISABLE   0                /*!< I2C master do not need buffer */
+// #define I2C_EXAMPLE_MASTER_RX_BUF_DISABLE   0                /*!< I2C master do not need buffer */
+
+// /**
+//  * @brief i2c master initialization
+//  */
+// static esp_err_t i2c_example_master_init()
 // {
-//     I2CTXD = dat;                               //写数据到数据缓冲区
-//     I2CMSCR = 0x02;                             //发送SEND命令
-//     Wait();
+//     int i2c_master_port = I2CH_N;
+//     i2c_config_t conf;
+//     conf.mode = I2C_MODE_MASTER;
+//     conf.sda_io_num = I2C_EXAMPLE_MASTER_SDA_IO;
+//     conf.sda_pullup_en = 1;
+//     conf.scl_io_num = I2C_EXAMPLE_MASTER_SCL_IO;
+//     conf.scl_pullup_en = 1;
+//     conf.clk_stretch_tick = 300; // 300 ticks, Clock stretch is about 210us, you can make changes according to the actual situation.
+//     ESP_ERROR_CHECK(i2c_driver_install(i2c_master_port, conf.mode));
+//     ESP_ERROR_CHECK(i2c_param_config(i2c_master_port, &conf));
+//     return ESP_OK;
 // }
 
-// void RecvACK()
+// /**
+//  * @brief   Write serial data to reg
+//  * @param   addr slave machine address
+//  * @param   data_t data to write(uint8)
+//  * @param   len length of write data(uint8)
+//  * @return  0: success, !0: error
+//  */
+// uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len)
 // {
-//     I2CMSCR = 0x03;                             //发送读ACK命令
-//     Wait();
+//     int ret;
+//     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+//     i2c_master_start(cmd);
+//     i2c_master_write_byte(cmd, addr << 1 | 0, ACK_CHECK_EN);
+//     i2c_master_write(cmd, data_t, len, ACK_CHECK_EN);
+//     i2c_master_stop(cmd);
+//     ret = i2c_master_cmd_begin(I2CH_N, cmd, 1000 / portTICK_RATE_MS);
+//     i2c_cmd_link_delete(cmd);
+
+//     return ret;
 // }
 
-// char RecvData()
+// /**
+//  * @brief   Read serial data to reg
+//  * @param   addr slave machine address
+//  * @param   data_t data to read(uint8)
+//  * @param   len length of read data(uint8)
+//  * @return  0: success, !0: error
+//  */
+// uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len)
 // {
-//     I2CMSCR = 0x04;                             //发送RECV命令
-//     Wait();
-//     return I2CRXD;
-// }
+//     int ret;
+//     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+//     i2c_master_start(cmd);
+//     i2c_master_write_byte(cmd, addr << 1 | 0, ACK_CHECK_EN);
+//     i2c_master_stop(cmd);
+//     ret = i2c_master_cmd_begin(I2CH_N, cmd, 1000 / portTICK_RATE_MS);
+//     i2c_cmd_link_delete(cmd);
+
+//     if(ret != ESP_OK) {
+//         return ret;
+//     }
 
-// void SendACK()
-// {
-//     I2CMSST = 0x00;                             //设置ACK信号
-//     I2CMSCR = 0x05;                             //发送ACK命令
-//     Wait();
-// }
+//     cmd = i2c_cmd_link_create();
+//     i2c_master_start(cmd);
+//     i2c_master_write_byte(cmd, addr << 1 | 1, ACK_CHECK_EN);
+//     i2c_master_read(cmd, data_t, len, LAST_NACK_VAL);
+//     i2c_master_stop(cmd);
+//     ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_RATE_MS);
+//     i2c_cmd_link_delete(cmd);
 
-// void SendNAK()
-// {
-//     I2CMSST = 0x01;                             //设置NAK信号
-//     I2CMSCR = 0x05;                             //发送ACK命令
-//     Wait();
+//     return ret;
 // }
 
-// void Stop()
-// {
-//     I2CMSCR = 0x06;                             //发送STOP命令
-//     Wait();
-// }
 
-// void Delay()
-// {
-//     int i;
-
-//     for(i = 0; i < 3000; i++)
-//     {
-//         _nop_();
-//         _nop_();
-//         _nop_();
-//         _nop_();
+// void I2C_1_SCL_SET(uint8_t level){
+//     if(level == _ATY_HL_L){
+//         GPIO_SET_L(I2C_SCL_PORT, I2C_SCL_PIN);
+//     }
+//     else if(level == _ATY_HL_H){
+//         GPIO_SET_H(I2C_SCL_PORT, I2C_SCL_PIN);
 //     }
 // }
-#endif /* PLATFORM */
-
-#endif /* __I2C_HARDWARE_ATY */
+// void I2C_1_SDA_SET(uint8_t cmd, uint8_t param){
+//     if(cmd == 'I'){
+//         if(param == _ATY_IO_I){
+//             GPIO_SET_IN(I2C_SDA_PORT, I2C_SDA_PIN);
+//         }
+//         else if(param == _ATY_IO_O){
+//             GPIO_SET_OUT(I2C_SDA_PORT, I2C_SDA_PIN);
+//         }
+//     }
+//     else if(cmd == 'L'){
+//         if(param == _ATY_HL_L){
+//             GPIO_SET_L(I2C_SDA_PORT, I2C_SDA_PIN);
+//         }
+//         else if(param == _ATY_HL_H){
+//             GPIO_SET_H(I2C_SDA_PORT, I2C_SDA_PIN);
+//         }
+//     }
+// }
+// uint8_t I2C_1_SDA_GET(void){ return GPIO_GET(I2C_SDA_PORT, I2C_SDA_PIN); }
+// uint8_t I2C_1(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){ return 0; }
+
+// void I2C_Delay(uint8_t t){ while(t--); }
+
+// struct HW_I2C_ATY_Dev HW_I2C_ATY_Dev_1 = {
+//     .hardwareEnable = 1,
+//     .sclSet = I2C_1_SCL_SET,
+//     .sdaSet = I2C_1_SDA_SET,
+//     .sdaGet = I2C_1_SDA_GET,
+//     .i2cProcess = I2C_1,
+//     .delay = I2C_Delay,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+
+/* use */
+// I2C_Write(addr, data_t, len, &HW_I2C_ATY_Dev_1);
+// I2C_Read(addr, data_t, len, &HW_I2C_ATY_Dev_1);
 
-#endif /* __HW_I2C_ATY_C */
+/******************************************************************************/
 
 /******************************** End Of File *********************************/

HW_I2C_ATY.h

@@ -21,6 +21,10 @@
 * @version
 *       - 1_01_220608 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_240108 > ATY
+*           -# add multy addr and channel
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
@@ -29,39 +33,76 @@
 #define __HW_I2C_ATY_H
 
 #include "INCLUDE_ATY.h"
-#include "HW_TIMER_ATY.h"
-#include "HW_GPIO_ATY.h"
 
 /******************************* For user *************************************/
+/**
+* @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 */
+//  }
+//
+//}
+
 #define I2C_WAIT_ACK_TIME       250 // us
 #define SHORT_DELAY             1
 #define LONG_DELAY              1
+
 /******************************************************************************/
 
-#ifndef __I2C_HARDWARE_ATY
-#define I2C_SCL_SET_H           GPIO_SET_H(I2C_SCL_PORT, I2C_SCL_PIN)
-#define I2C_SCL_SET_L           GPIO_SET_L(I2C_SCL_PORT, I2C_SCL_PIN)
-#define I2C_SDA_SET_OUT         I2C_SDA_SetOut()
-#define I2C_SDA_SET_IN          I2C_SDA_SetIn()
-#define I2C_SDA_SET_H           GPIO_SET_H(I2C_SDA_PORT, I2C_SDA_PIN)
-#define I2C_SDA_SET_L           GPIO_SET_L(I2C_SDA_PORT, I2C_SDA_PIN)
-#define I2C_SDA_GET_H           GPIO_GET_H(I2C_SDA_PORT, I2C_SDA_PIN)
-#define I2C_SDA_GET_L           GPIO_GET_L(I2C_SDA_PORT, I2C_SDA_PIN)
+struct HW_I2C_ATY_Dev
+{
+    uint8_t hardwareEnable;
+
+    void (*sclSet)(uint8_t level);
+    void (*sdaSet)(uint8_t cmd, uint8_t param);
+    uint8_t(*sdaGet)();
+
+    uint8_t(*i2cProcess)(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw);
+
+    void (*delay)(uint32_t t);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    void (*LOG)();
+};
 
-void I2C_Start(void);
-void I2C_Stop(void);
-void I2C_Ack(void);
-void I2C_NoAck(void);
-uint8_t I2C_WaitAck(uint16_t maxErrTime);
-void I2C_WriteByte(uint8_t byte);
-uint8_t I2C_ReadByte(uint8_t ack);
-#endif /* __I2C_HARDWARE_ATY */
+uint8_t I2C_Start(struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_Stop(struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_Ack(struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_NoAck(struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_WaitAck(uint16_t maxErrTime, struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_WriteByte(uint8_t byte, struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_ReadByte(uint8_t ack, struct HW_I2C_ATY_Dev* dev);
 
-uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len);
-uint8_t I2C_Write_NoStop(uint8_t addr, uint8_t* data_t, uint8_t len);
-uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len);
-uint8_t I2C_WriteReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len);
-uint8_t I2C_ReadReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len);
+uint8_t I2C_Write(uint8_t addr, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_Write_NoStop(uint8_t addr, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_Read(uint8_t addr, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_WriteReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev);
+uint8_t I2C_ReadReg(uint8_t addr, uint8_t reg, uint8_t* data_t, uint8_t len, struct HW_I2C_ATY_Dev* dev);
 
 #endif /* __HW_I2C_ATY_H */
 

HW_PWM_ATY.c

@@ -32,7 +32,7 @@
 
 /******************************* For user *************************************/
 
-#if defined(__STC8G_ATY)
+#if defined (__STC8G_ATY)
 /**
  * @brief   set pulse period with specified duty with PCA
  * @param   periodS pulse period, us
@@ -285,7 +285,7 @@ void PWM_Start(uint32_t periodS, float dutyS, uint8_t channelS)
  */
 void PWM_Stop(uint8_t level, uint8_t channelS)
 {
-#ifdef PWM_T01C1
+#if defined (PWM_T01C1)
     if(channelS == PWM_T01C1){
         if(level)
             __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, __HAL_TIM_GET_AUTORELOAD(&htim1));
@@ -295,7 +295,7 @@ void PWM_Stop(uint8_t level, uint8_t channelS)
         HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
     }
 #endif
-#ifdef PWM_T02C2
+#if defined (PWM_T02C2)
     if(level)
     {
         TIM2->ARR = 0;
@@ -311,7 +311,7 @@ void PWM_Stop(uint8_t level, uint8_t channelS)
     if(channelS == PWM_T02C2)
         HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
 #endif
-#ifdef PWM_T03C2
+#if defined (PWM_T03C2)
     if(level)
     {
         TIM3->ARR = 0;

HW_PWM_ATY.h

@@ -32,7 +32,7 @@
 
 /******************************* For user *************************************/
 // #define __DEBUG_HW_PWM_ATY
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 #define PWM1_CHOSE PWM_PIN_POS_0
 #define PWM2_CHOSE PWM_PIN_POS_0
 #define PWM3_CHOSE PWM_PIN_POS_0
@@ -44,9 +44,13 @@
 #elif defined(__STM32_HAL_ATY)
 #endif /* PLATFORM */
 
+// #define PWM_T01C1 0x11
+// #define PWM_T01C2 0x12
+// #define PWM_T02C1 0x21
+
 /******************************************************************************/
 
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 #define PWM_CHANNEL_1P 0x01
 #define PWM_CHANNEL_1N 0x02
 #define PWM_CHANNEL_2P 0x04
@@ -74,7 +78,7 @@
 void PWM_Start(uint32_t periodS, float dutyS, uint8_t channelS);
 void PWM_Stop(uint8_t level, uint8_t channelS);
 void PwmFreqSet(uint32_t periodS, uint8_t channelS);
-#if defined(__STC8G_ATY)
+#if defined (__STC8G_ATY)
 void PWM_StartPulse(uint32_t periodS, uint8_t channelS);
 #endif
 

HW_RESET_ATY.c

@@ -38,7 +38,7 @@
  */
 __WEAK_ATY void SoftReset(void)
 {
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
     IAP_CONTR |= 0x60;      // @STCISP# Auto ISP Flash Download
 #elif defined(__HC32_ATY) || \
     defined(__STM32_SPL_ATY) || \

HW_SPI_ATY.c

@@ -21,6 +21,9 @@
 * @version
 *       - 1_01_221028 > ATY
 *           -# Preliminary version, first Release
+*       - 1_01_240111 > ATY
+*           -# add multy addr and channel
+*           -# add lock
 *           -Undone: in soft
 ********************************************************************************
 */
@@ -34,139 +37,218 @@
 
 /******************************************************************************/
 
-#ifndef __SPI_HARDWARE_ATY
-#else
-
-#if defined(__STC51_ATY)
-uint8_t SPI_Write(uint8_t* data_t, uint16_t len)
-{
-    uint8_t i = 0;
-    uint16_t errCount = 1000;
-    SPCTL = 0xD4;
-    for(i = 0; i < len; i++)
-    {
-        SPSTAT |= 0xC0;
-        SPDAT = *(data_t + i);
-        while(((SPSTAT & 0x80) != 0x80) && errCount)
-            errCount--;
-        if(errCount == 0)
-            return 1;
-    }
-    return 0;
-}
-
-uint8_t SPI_Read(uint8_t* data_t, uint16_t len)
-{
-    uint8_t i = 0;
-    uint16_t errCode = 1000;
-    SPCTL = 0xD4;
-    for(i = 0; i < len; i++)
-    {
-        SPSTAT |= 0xC0;
-        SPDAT = 0xFF;
-        while(((SPSTAT & 0x80) != 0x80) && errCode)
-            errCode--;
-        if(errCode == 0)
-            return 1;
-        *(data_t + i) = SPDAT;
-    }
-    return 0;
-}
-
-#elif defined(__STM32_HAL_ATY)
-#include "spi.h"
-
-uint8_t SPI_Write(uint8_t* data_t, uint16_t len)
+/**
+ * @brief
+ *
+ * @param   data_t
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t SPI_Write(uint8_t* data_t, uint16_t len, struct HW_SPI_ATY_Dev* dev)
 {
-    uint8_t i = 3;
-    while(i--)
-    {
-        if(HAL_SPI_Transmit(&SPIH_N, (uint8_t *)data_t, len, 1000) == HAL_OK)
-            return 0;
+    if(dev->hardwareEnable == 1){
+        uint8_t errCode = 0;
+        __ATY_LOCK(dev);
+        errCode = dev->spiProcess(data_t, len, _ATY_RW_W);
+        __ATY_UNLOCK(dev);
+        return errCode;
     }
-    return 1;
+    else{ __ATY_UNLOCK(dev); return 1; }
 }
 
-uint8_t SPI_Read(uint8_t* data_t, uint16_t len)
+/**
+ * @brief
+ *
+ * @param   data_t
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t SPI_Read(uint8_t* data_t, uint16_t len, struct HW_SPI_ATY_Dev* dev)
 {
-    uint8_t i = 3;
-    while(i--)
-    {
-        if(HAL_SPI_Receive(&SPIH_N, (uint8_t *)data_t, len, 1000) == HAL_OK)
-            return 0;
+    if(dev->hardwareEnable == 1){
+        uint8_t errCode = 0;
+        __ATY_LOCK(dev);
+        errCode = dev->spiProcess(data_t, len, _ATY_RW_R);
+        __ATY_UNLOCK(dev);
+        return errCode;
     }
-    return 1;
-}
-
-#elif defined(__ESP8266_RTOS_ATY)
-#include <stdio.h>
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/queue.h"
-#include "esp8266/gpio_struct.h"
-#include "esp8266/spi_struct.h"
-#include "esp_system.h"
-#include "esp_log.h"
-#include "esp_libc.h"
-#include "driver/gpio.h"
-#include "driver/spi.h"
-
-static const char *TAG = "user_spi";
-
-esp_err_t esp8266_spi_init(void)
-{
-    ESP_LOGI(TAG, "init spi");
-    spi_config_t spi_config;
-    // Load default interface parameters
-    // CS_EN:1, MISO_EN:1, MOSI_EN:1, BYTE_TX_ORDER:1, BYTE_TX_ORDER:1, BIT_RX_ORDER:0, BIT_TX_ORDER:0, CPHA:0, CPOL:0
-    spi_config.interface.val = SPI_DEFAULT_INTERFACE;
-
-    // Load default interrupt enable
-    // TRANS_DONE: true, WRITE_STATUS: false, READ_STATUS: false, WRITE_BUFFER: false, READ_BUFFER: false
-    spi_config.intr_enable.val = SPI_MASTER_DEFAULT_INTR_ENABLE;
-
-    spi_config.interface.cs_en = 0;
-    spi_config.interface.mosi_en = 1;
-    spi_config.interface.miso_en = 1;
-
-    // Set SPI to master mode
-    // ESP8266 Only support half-duplex
-    spi_config.mode = SPI_MASTER_MODE;
-    // Set the SPI clock frequency division factor
-    spi_config.clk_div = SPI_2MHz_DIV;
-    spi_config.event_cb = NULL;
-    return spi_init(HSPI_HOST, &spi_config);
+    else{ __ATY_UNLOCK(dev); return 1; }
 }
 
 /**
  * @brief
- * @note    use [ESP8266_RTOS_SDK](https://github.com/espressif/ESP8266_RTOS_SDK/)
+ *
+ * @param   data_t
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
  */
-// esp_err_t SPI_Write(uint8_t* data_t, uint16_t len)
-uint8_t SPI_Write(uint8_t* data_t, uint16_t len)
+uint8_t SPI_ReadWrite(uint8_t* data_t, uint16_t len, struct HW_SPI_ATY_Dev* dev)
 {
-    spi_trans_t trans = {0};
-    trans.mosi = data;
-    trans.bits.mosi = len * 8;
-    return spi_trans(HSPI_HOST, &trans);
-}
-
-uint8_t SPI_Read(uint8_t* data_t, uint16_t len)
-{
-    spi_trans_t trans;
-    memset(&trans, 0x0, sizeof(trans));
-    trans.bits.val = 0;
-    trans.miso = data_t;
-    trans.bits.miso = len * 8;
-    if(spi_trans(HSPI_HOST, &trans))
-        return 0;
-    return 1;
+    if(dev->hardwareEnable == 1){
+        uint8_t errCode = 0;
+        __ATY_LOCK(dev);
+        errCode = dev->spiProcess(data_t, len, _ATY_RW_RW);
+        __ATY_UNLOCK(dev);
+        return errCode;
+    }
+    else{ __ATY_UNLOCK(dev); return 1; }
 }
-#endif /* PLATFORM */
 
+#endif /* __HW_SPI_ATY_C */
 
-#endif /* __SPI_HARDWARE_ATY */
+/************************************ etc *************************************/
+/* init */
+// // STM32 HAL
+// uint8_t SPI_1(uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W)
+//         return HAL_SPI_Transmit(&hspi2, (uint8_t*)data_t, len, 1000);
+//     else if(rw == _ATY_RW_R)
+//         return HAL_SPI_Receive(&hspi2, (uint8_t*)data_t, len, 1000);
+//     else if(rw == _ATY_RW_RW)
+//         return HAL_SPI_TransmitReceive(&hspi2, (uint8_t*)data_t, (uint8_t*)data_t, len, 1000);
+//     return 0;
+// }
+
+// // 51 // todo: not tested
+// uint8_t SPI_1(uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W){
+//         uint8_t i = 0;
+//         uint16_t errCount = 1000;
+//         SPCTL = 0xD4;
+//         for(i = 0; i < len; i++)
+//         {
+//             SPSTAT |= 0xC0;
+//             SPDAT = data_t[i];
+//             while(((SPSTAT & 0x80) != 0x80) && errCount) errCount--;
+//             if(errCount == 0) return 1; else errCount = 1000;
+//         }
+//         return 0;
+//     }
+//     else if(rw == _ATY_RW_R){
+//         uint8_t i = 0;
+//         uint16_t errCode = 1000;
+//         SPCTL = 0xD4;
+//         for(i = 0; i < len; i++)
+//         {
+//             SPSTAT |= 0xC0;
+//             SPDAT = 0xFF;
+//             while(((SPSTAT & 0x80) != 0x80) && errCode) errCode--;
+//             if(errCount == 0) return 1; else errCount = 1000;
+//             data_t[i] = SPDAT;
+//         }
+//         return 0;
+//     }
+
+//     else if(rw == _ATY_RW_RW){
+//         uint8_t i = 0;
+//         uint16_t errCount = 1000;
+//         SPCTL = 0xD4;
+
+//         SPSTAT |= 0xC0;
+//         SPDAT = data_t[0];
+//         while(((SPSTAT & 0x80) != 0x80) && errCount) errCount--;
+//         if(errCount == 0) return 1; else errCount = 1000;
+
+//         SPCTL = 0xD4;
+//         for(i = 0; i < len; i++)
+//         {
+//             SPSTAT |= 0xC0;
+//             SPDAT = 0xFF;
+//             while(((SPSTAT & 0x80) != 0x80) && errCount) errCount--;
+//             if(errCount == 0) return 1; else errCount = 1000;
+//             data_t[i] = SPDAT;
+//         }
+
+//         return 0;
+//     }
+//     return 0;
+// }
+
+// // ESP8266_RTOS // todo: not tested
+// #include <stdio.h>
+// #include "freertos/FreeRTOS.h"
+// #include "freertos/task.h"
+// #include "freertos/queue.h"
+// #include "esp8266/gpio_struct.h"
+// #include "esp8266/spi_struct.h"
+// #include "esp_system.h"
+// #include "esp_log.h"
+// #include "esp_libc.h"
+// #include "driver/gpio.h"
+// #include "driver/spi.h"
+
+// static const char* TAG = "user_spi";
+
+// esp_err_t esp8266_spi_init(void)
+// {
+//     ESP_LOGI(TAG, "init spi");
+//     spi_config_t spi_config;
+//     // Load default interface parameters
+//     // CS_EN:1, MISO_EN:1, MOSI_EN:1, BYTE_TX_ORDER:1, BYTE_TX_ORDER:1, BIT_RX_ORDER:0, BIT_TX_ORDER:0, CPHA:0, CPOL:0
+//     spi_config.interface.val = SPI_DEFAULT_INTERFACE;
+
+//     // Load default interrupt enable
+//     // TRANS_DONE: true, WRITE_STATUS: false, READ_STATUS: false, WRITE_BUFFER: false, READ_BUFFER: false
+//     spi_config.intr_enable.val = SPI_MASTER_DEFAULT_INTR_ENABLE;
+
+//     spi_config.interface.cs_en = 0;
+//     spi_config.interface.mosi_en = 1;
+//     spi_config.interface.miso_en = 1;
+
+//     // Set SPI to master mode
+//     // ESP8266 Only support half-duplex
+//     spi_config.mode = SPI_MASTER_MODE;
+//     // Set the SPI clock frequency division factor
+//     spi_config.clk_div = SPI_2MHz_DIV;
+//     spi_config.event_cb = NULL;
+//     return spi_init(HSPI_HOST, &spi_config);
+// }
+
+// /**
+//  * @brief
+//  * @note    use [ESP8266_RTOS_SDK](https://github.com/espressif/ESP8266_RTOS_SDK/)
+//  */
+// // esp_err_t SPI_Write(uint8_t* data_t, uint16_t len)
+// uint8_t SPI_Write(uint8_t* data_t, uint16_t len)
+// {
+//     spi_trans_t trans = {0};
+//     trans.mosi = data;
+//     trans.bits.mosi = len * 8;
+//     return spi_trans(HSPI_HOST, &trans);
+// }
+
+// uint8_t SPI_Read(uint8_t* data_t, uint16_t len)
+// {
+//     spi_trans_t trans;
+//     memset(&trans, 0x0, sizeof(trans));
+//     trans.bits.val = 0;
+//     trans.miso = data_t;
+//     trans.bits.miso = len * 8;
+//     if(spi_trans(HSPI_HOST, &trans))
+//         return 0;
+//     return 1;
+// }
+
+
+// void SPI_Delay(uint8_t t){ }
+
+// struct HW_SPI_ATY_Dev HW_SPI_ATY_Dev_1 = {
+//     .hardwareEnable = 1,
+//     .spiProcess = SPI_1,
+//     .delay = SPI_Delay,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+
+/* use */
+// SPI_Write(data_t, len, &HW_SPI_ATY_Dev_1);
+// SPI_Read(data_t, len, &HW_SPI_ATY_Dev_1);
+// SPI_ReadWrite(data_t, len, &HW_SPI_ATY_Dev_1);
 
-#endif /* __HW_SPI_ATY_C */
+/******************************************************************************/
 
 /******************************** End Of File *********************************/

HW_SPI_ATY.h

@@ -21,6 +21,9 @@
 * @version
 *       - 1_01_221028 > ATY
 *           -# Preliminary version, first Release
+*       - 1_01_240111 > ATY
+*           -# add multy addr and channel
+*           -# add lock
 ********************************************************************************
 */
 
@@ -29,20 +32,27 @@
 #define __HW_SPI_ATY_H
 
 #include "INCLUDE_ATY.h"
-#include "HW_TIMER_ATY.h"
-#include "HW_GPIO_ATY.h"
 
 /******************************* For user *************************************/
 
 /******************************************************************************/
 
-#ifndef __SPI_HARDWARE_ATY
-// #define SPI_SCL_SET_H           GPIO_SET_H(I2C_SCL_PORT, I2C_SCL_PIN)
-#else
-#endif /* __SPI_HARDWARE_ATY */
+struct HW_SPI_ATY_Dev
+{
+    uint8_t hardwareEnable;
 
-uint8_t SPI_Write(uint8_t* data_t, uint16_t len);
-uint8_t SPI_Read(uint8_t* data_t, uint16_t len);
+    uint8_t(*spiProcess)(uint8_t* data_t, uint16_t len, uint8_t rw);
+
+    void (*delay)(uint32_t t);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    void (*LOG)();
+};
+
+uint8_t SPI_Write(uint8_t* data_t, uint16_t len, struct HW_SPI_ATY_Dev* dev);
+uint8_t SPI_Read(uint8_t* data_t, uint16_t len, struct HW_SPI_ATY_Dev* dev);
+uint8_t SPI_ReadWrite(uint8_t* data_t, uint16_t len, struct HW_SPI_ATY_Dev* dev);
 
 #endif /* __HW_SPI_ATY_H */
 

HW_TIMER_ATY.c

@@ -32,7 +32,7 @@
 
 /******************************* For user *************************************/
 
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 /**
  * @brief   1 us delay with for @ 24MHz about 1.04us
  */

HW_UART_ATY.c

@@ -33,7 +33,7 @@
 struct _uartMsgStruct uartMsgStruct_t = {0};
 
 /******************************* For user *************************************/
-#if defined(__STC51_ATY)
+#if defined (__STC51_ATY)
 
 #define BRT         (uint32_t)(65536 - (uint32_t)FOSC / BAUD_RATE / 4)
 // #define FOSC        5529600UL  // 5.5296MHz MCU frequency
@@ -297,7 +297,7 @@ void UartSendFloat(float dataFloat)
 void UartSendFloatStr(float dataFloat)
 {
 #define DECIMALS_NUM 4
-    uint8_t i = 0, j = 0;
+    uint8_t i = 0;
     uint8_t dataStr[10];    // ulongint 4294967295, 6.4f
     unsigned long int tempSaveData = 0;
 

INCLUDE_ATY.h

@@ -134,7 +134,7 @@ typedef unsigned long uint32_t;
 
 #ifndef _UINT64_T
 #define _UINT64_T
-#if defined(SDCC) || defined(__SDCC) || defined(__CX51__) || defined(__C51__)
+#if defined (SDCC) || defined(__SDCC) || defined(__CX51__) || defined(__C51__)
 typedef unsigned long int uint64_t;  // uint64_t at 64 bit platform with ulong
 #else
 typedef unsigned long long int uint64_t;
@@ -144,7 +144,7 @@ typedef unsigned long long int uint64_t;
 typedef signed char int8_t;
 typedef signed short int int16_t;
 typedef signed int int32_t;
-#if defined(SDCC) || defined(__SDCC) || defined(__CX51__) || defined(__C51__)
+#if defined (SDCC) || defined(__SDCC) || defined(__CX51__) || defined(__C51__)
 typedef signed long int int64_t;
 #else
 typedef signed long long int int64_t;
@@ -152,7 +152,7 @@ typedef signed long long int int64_t;
 #endif /* __stdint_h */
 
 /******************************* Platform *************************************/
-#if defined(__SDCC_SYNTAX_FIX)
+#if defined (__SDCC_SYNTAX_FIX)
 #include <stdbool.h>
 #include <lint.h>
 # warning unrecognized compiler
@@ -226,7 +226,7 @@ extern void _nop_(void);
 #define __CODE
 #define __NOP_ATY __nop()
 
-#if defined(__ICCARM__)
+#if defined (__ICCARM__)
 #define __WEAK_ATY __WEAK __ATTRIBUTES
 #elif defined(__CC_ARM)
 #define __WEAK_ATY __weak
@@ -250,35 +250,35 @@ extern void _nop_(void);
 
 #include "main.h"
 
-#if defined(__HC32_ATY) || \
-    defined(__STM32_SPL_ATY) || \
-    defined(__STM32_HAL_ATY) || \
-    defined(__STM32_LL_ATY)
-// shield warnings
-#pragma diag_suppress 550   // variable ""  was set but never used
-#pragma diag_suppress 177   // function ""  was declared but never referenced
-#pragma diag_suppress 186   // pointless comparison of unsigned integer with zero
-#pragma diag_suppress 1035  // single-precision operand implicitly converted to double-precision
-// #pragma diag_suppress 223
-#endif
+// #if defined (__HC32_ATY) || \
+//     defined(__STM32_SPL_ATY) || \
+//     defined(__STM32_HAL_ATY) || \
+//     defined(__STM32_LL_ATY)
+// // shield warnings
+// #pragma diag_suppress 550   // variable ""  was set but never used
+// #pragma diag_suppress 177   // function ""  was declared but never referenced
+// #pragma diag_suppress 186   // pointless comparison of unsigned integer with zero
+// #pragma diag_suppress 1035  // single-precision operand implicitly converted to double-precision
+// // #pragma diag_suppress 223
+// #endif
 
-#ifdef __STC51_ATY
-#define BIG_ENDIAN                                      // chip in big endian mode, like 51
-#endif
+// #ifdef __STC51_ATY
+// #define BIG_ENDIAN                                      // chip in big endian mode, like 51
+// #endif
 
-#if defined(__STC51_ATY)
-#define LOG_ATY(__STRING) UartSendStr(__STRING)
-#elif defined(__HC32_ATY) || \
-    defined(__STM32_SPL_ATY) || \
-    defined(__STM32_HAL_ATY) || \
-    defined(__STM32_LL_ATY)
-#include "HW_UART_ATY.h"
-#include "stdarg.h"
-#define LOG_ATY(__STRING) printf(__STRING)   // C99
-#define LOG_ATY__(__STRING, ...) printf(__STRING,##__VA_ARGS__)   // C99
-#else
-#define LOG_ATY(__STRING)
-#endif
+// #if defined (__STC51_ATY)
+// #define LOG_ATY(__STRING) UartSendStr(__STRING)
+// #elif defined(__HC32_ATY) || \
+//     defined(__STM32_SPL_ATY) || \
+//     defined(__STM32_HAL_ATY) || \
+//     defined(__STM32_LL_ATY)
+// #include "HW_UART_ATY.h"
+// #include "stdarg.h"
+// #define LOG_ATY(__STRING) printf(__STRING)   // C99
+// #define LOG_ATY__(__STRING, ...) printf(__STRING,##__VA_ARGS__)   // C99
+// #else
+// #define LOG_ATY(__STRING)
+// #endif
 
 
 
@@ -290,7 +290,7 @@ extern void _nop_(void);
 /*
 // todo, not tested and need to be adjust
 // #include <stdio.h>      // printf(only for debug)
-#if defined(__HC32_ATY) || \
+#if defined (__HC32_ATY) || \
     defined(__STM32_SPL_ATY) || \
     defined(__STM32_HAL_ATY) || \
     defined(__STM32_LL_ATY)
@@ -340,10 +340,46 @@ extern void _nop_(void);
 
 
 /******************************************************************************/
+#define _ATY_IO_O 0
+#define _ATY_IO_I 1
+#define _ATY_HL_L 0
+#define _ATY_HL_H 1
+#define _ATY_RW_W 0
+#define _ATY_RW_R 1
+#define _ATY_RW_RW 2
+
+#define _ATY_BUSY 99
+#define _ATY_LOCKED 101
+#define _ATY_UNLOCKED 102
+#if (USE_RTOS == 1U)
+#define __ATY_LOCK(__HANDLE__)
+#define __ATY_UNLOCK(__HANDLE__)
+#else
+#define __ATY_LOCK(__HANDLE__)                  \
+    do{                                         \
+        if((__HANDLE__)->lock == _ATY_LOCKED) {  \
+            return _ATY_BUSY;                    \
+        }                                       \
+        else {                                  \
+            (__HANDLE__)->lock = _ATY_LOCKED;    \
+        }                                       \
+    }while (0U)
+
+#define __ATY_UNLOCK(__HANDLE__)                \
+    do{                                         \
+        (__HANDLE__)->lock = _ATY_UNLOCKED;      \
+    }while (0U)
+#endif /* USE_RTOS */
 
+#endif /* __INCLUDE_ATY_H */
 
+/************************************ etc *************************************/
+/* init */
+
+/* use */
+
+/******************************************************************************/
 
 
-#endif /* __INCLUDE_ATY_H */
 
 /******************************** End Of File *********************************/

LED_ATY.c

@@ -21,11 +21,13 @@
 * @version
 *       - 1_01_220901 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# change struct to dev type
+*       - 1_01_240111 > ATY
+*           -# add lock
 ********************************************************************************
 */
 
-
-
 #ifndef __LED_ATY_C
 #define __LED_ATY_C
 
@@ -34,250 +36,240 @@
 /******************************* For user *************************************/
 
 /******************************************************************************/
-
-uint32_t ledBlinkStep = 0;
-uint8_t ledBlinkType = 20;
 /**
  * @brief   set sysled blink ledBlinkType
+ *
+ * @param   dev device
+ * @return  uint8_t
  * @note    put this function at timer IT callback, change
- * @note    1: light on and off cycle
- *          10: light on and off cycle long time ver
- *          2: light on blink twice
- *          20: light off blink twice
- *          3: light on blink thrice
- *          30: light off blink thrice
- *          40: breath
+ * @note    0x01: light on and off cycle
+            0x10: light on and off cycle long time ver
+            0x02: light on blink twice
+            0x20: light off blink twice
+            0x03: light on blink thrice
+            0x30: light off blink thrice
+            0x40: breath // not recommended to use
  * @note    if(ledBlinkType - 40 >= 10) at large time cycle
- *          if(ledBlinkType - 40 < 10) at small time cycle(breath type is 40-49)
+            if(ledBlinkType - 40 < 10) at small time cycle(breath type is 40-49)
  */
-void SysLedBlink(void)
+uint8_t SysLedBlink(struct LED_ATY_Dev* dev)
 {
     static uint8_t ledBlinkLastType = 0;
-    if(ledBlinkLastType != ledBlinkType)
-    {
-        ledBlinkLastType = ledBlinkType;
-        ledBlinkStep = 0;
+    __ATY_LOCK(dev);
+    if(ledBlinkLastType != dev->ledBlinkType){
+        ledBlinkLastType = dev->ledBlinkType;
+        dev->ledBlinkStep = 0;
     }
-    if(ledBlinkType == 1)
+    if(dev->ledBlinkType == 0x01)
     {
-        if(ledBlinkStep == 0)
-        {
-            ledBlinkStep = 1;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep != 0)
-        {
-            ledBlinkStep = 0;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-#ifdef __DEBUG_LED_ATY
-            // printf("\r\nSysLed Blink.");
-#endif /* __DEBUG_LED_ATY */
+        if(dev->ledBlinkStep == 0){
+            dev->ledBlinkStep = 1;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep != 0){
+            dev->ledBlinkStep = 0;
+            dev->ioSet(_ATY_HL_H);
+            if(dev->debugEnable == 1)
+                dev->LOG("\r\nSysLed Blink.");
         }
     }
-    else if(ledBlinkType == 10)
+    else if(dev->ledBlinkType == 0x10)
     {
-        ledBlinkStep++;
-        if(ledBlinkStep < 10)
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        else if(ledBlinkStep >= 10 && ledBlinkStep < 20)
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        else
-        {
-            ledBlinkStep = 0;
+        dev->ledBlinkStep++;
+        if(dev->ledBlinkStep < 10)
+            dev->ioSet(_ATY_HL_L);
+        else if(dev->ledBlinkStep >= 10 && dev->ledBlinkStep < 20)
+            dev->ioSet(_ATY_HL_H);
+        else{
+            dev->ledBlinkStep = 0;
         }
     }
     // Type 2 & 3 put at short timer is better, like 100ms
-    else if(ledBlinkType == 2)
+    else if(dev->ledBlinkType == 0x02)
     {
-        if(ledBlinkStep == 0)
-        {
-            ledBlinkStep = 1;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 1)
-        {
-            ledBlinkStep = 2;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 2)
-        {
-            ledBlinkStep = 3;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 3)
-        {
-            ledBlinkStep = 4;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if((ledBlinkStep >= 4) && (ledBlinkStep < LED_LONG_STEPS))
-        {
-            ledBlinkStep++;
-        }
-        else if(ledBlinkStep == LED_LONG_STEPS)
-        {
-            ledBlinkStep = 0;
-#ifdef __DEBUG_LED_ATY
-            // printf("\r\nSysLed Blink.");
-#endif /* __DEBUG_LED_ATY */
+        if(dev->ledBlinkStep == 0){
+            dev->ledBlinkStep = 1;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 1){
+            dev->ledBlinkStep = 2;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 2){
+            dev->ledBlinkStep = 3;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 3){
+            dev->ledBlinkStep = 4;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if((dev->ledBlinkStep >= 4) && (dev->ledBlinkStep < dev->longSteps)){
+            dev->ledBlinkStep++;
+        }
+        else if(dev->ledBlinkStep == dev->longSteps){
+            dev->ledBlinkStep = 0;
+            if(dev->debugEnable == 1)
+                dev->LOG("\r\nSysLed Blink.");
         }
     }
-    else if(ledBlinkType == 20)
+    else if(dev->ledBlinkType == 0x20)
     {
-        if(ledBlinkStep == 0)
-        {
-            ledBlinkStep = 1;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 1)
-        {
-            ledBlinkStep = 2;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 2)
-        {
-            ledBlinkStep = 3;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 3)
-        {
-            ledBlinkStep = 4;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if((ledBlinkStep >= 4) && (ledBlinkStep < LED_LONG_STEPS))
-        {
-            ledBlinkStep++;
-        }
-        else if(ledBlinkStep == LED_LONG_STEPS)
-        {
-            ledBlinkStep = 0;
-#ifdef __DEBUG_LED_ATY
-            // printf("\r\nSysLed Blink.");
-#endif /* __DEBUG_LED_ATY */
+        if(dev->ledBlinkStep == 0){
+            dev->ledBlinkStep = 1;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 1){
+            dev->ledBlinkStep = 2;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 2){
+            dev->ledBlinkStep = 3;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 3){
+            dev->ledBlinkStep = 4;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if((dev->ledBlinkStep >= 4) && (dev->ledBlinkStep < dev->longSteps)){
+            dev->ledBlinkStep++;
+        }
+        else if(dev->ledBlinkStep == dev->longSteps){
+            dev->ledBlinkStep = 0;
+            if(dev->debugEnable == 1)
+                dev->LOG("\r\nSysLed Blink.");
         }
     }
-    else if(ledBlinkType == 3)
+    else if(dev->ledBlinkType == 0x03)
     {
-        if(ledBlinkStep == 0)
-        {
-            ledBlinkStep = 1;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 1)
-        {
-            ledBlinkStep = 2;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 2)
-        {
-            ledBlinkStep = 3;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 3)
-        {
-            ledBlinkStep = 4;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 4)
-        {
-            ledBlinkStep = 5;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 5)
-        {
-            ledBlinkStep = 6;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if((ledBlinkStep >= 6) && (ledBlinkStep < LED_LONG_STEPS))
-        {
-            ledBlinkStep++;
-        }
-        else if(ledBlinkStep == LED_LONG_STEPS)
-        {
-            ledBlinkStep = 0;
-#ifdef __DEBUG_LED_ATY
-            // printf("\r\nSysLed Blink.");
-#endif /* __DEBUG_LED_ATY */
+        if(dev->ledBlinkStep == 0){
+            dev->ledBlinkStep = 1;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 1){
+            dev->ledBlinkStep = 2;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 2){
+            dev->ledBlinkStep = 3;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 3){
+            dev->ledBlinkStep = 4;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 4){
+            dev->ledBlinkStep = 5;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 5){
+            dev->ledBlinkStep = 6;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if((dev->ledBlinkStep >= 6) && (dev->ledBlinkStep < dev->longSteps)){
+            dev->ledBlinkStep++;
+        }
+        else if(dev->ledBlinkStep == dev->longSteps){
+            dev->ledBlinkStep = 0;
+            if(dev->debugEnable == 1)
+                dev->LOG("\r\nSysLed Blink.");
+
         }
     }
-    else if(ledBlinkType == 30)
+    else if(dev->ledBlinkType == 0x30)
     {
-        if(ledBlinkStep == 0)
-        {
-            ledBlinkStep = 1;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 1)
-        {
-            ledBlinkStep = 2;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 2)
-        {
-            ledBlinkStep = 3;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 3)
-        {
-            ledBlinkStep = 4;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 4)
-        {
-            ledBlinkStep = 5;
-            GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if(ledBlinkStep == 5)
-        {
-            ledBlinkStep = 6;
-            GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
-        }
-        else if((ledBlinkStep >= 6) && (ledBlinkStep < LED_LONG_STEPS))
-        {
-            ledBlinkStep++;
-        }
-        else if(ledBlinkStep == LED_LONG_STEPS)
-        {
-            ledBlinkStep = 0;
-#ifdef __DEBUG_LED_ATY
-            // printf("\r\nSysLed Blink.");
-#endif /* __DEBUG_LED_ATY */
+        if(dev->ledBlinkStep == 0){
+            dev->ledBlinkStep = 1;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 1){
+            dev->ledBlinkStep = 2;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 2){
+            dev->ledBlinkStep = 3;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 3){
+            dev->ledBlinkStep = 4;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if(dev->ledBlinkStep == 4){
+            dev->ledBlinkStep = 5;
+            dev->ioSet(_ATY_HL_H);
+        }
+        else if(dev->ledBlinkStep == 5){
+            dev->ledBlinkStep = 6;
+            dev->ioSet(_ATY_HL_L);
+        }
+        else if((dev->ledBlinkStep >= 6) && (dev->ledBlinkStep < dev->longSteps)){
+            dev->ledBlinkStep++;
+        }
+        else if(dev->ledBlinkStep == dev->longSteps){
+            dev->ledBlinkStep = 0;
+            if(dev->debugEnable == 1)
+                dev->LOG("\r\nSysLed Blink.");
         }
     }
-    else if(ledBlinkType == 40) // put at 1ms cycle, cycle more faster, led animation more breathly
+    else if(dev->ledBlinkType == 0x40) // put at 1ms cycle, cycle more faster, led animation more breathly
     {
-// ms when cycle is 1ms // 3000 at 1ms cycle, 60000 at 24MHz main while cycle
-#define FLOW_CYCLE_COUNT ((uint32_t)60000)
-// #define FLOW_CYCLE_COUNT (3000)
-
-// led brghtness split // 10 at 1ms cycle, 1000 at 24MHz main while cycle
-#define ONE_PULSE_COUNT (60)
-// #define ONE_PULSE_COUNT (10)
-
         static uint16_t cycleCount = 0;
-        if(cycleCount < ONE_PULSE_COUNT)
+        if(cycleCount < dev->onePulseCount)
             cycleCount++;
         else
             cycleCount = 0;
-        ledBlinkStep++;
+        dev->ledBlinkStep++;
         // UartSendFloatStr(cycleCount);
-        if(ledBlinkStep < FLOW_CYCLE_COUNT){
-            if(cycleCount < (ONE_PULSE_COUNT * ledBlinkStep / FLOW_CYCLE_COUNT))
-                GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
+        if(dev->ledBlinkStep < dev->flowCycleCount){
+            if(cycleCount < (dev->onePulseCount * dev->ledBlinkStep / dev->flowCycleCount))
+                dev->ioSet(_ATY_HL_H);
             else
-                GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
+                dev->ioSet(_ATY_HL_L);
         }
-        else if(ledBlinkStep >= FLOW_CYCLE_COUNT && ledBlinkStep < FLOW_CYCLE_COUNT * 2){
-            if(cycleCount < (ONE_PULSE_COUNT * (ledBlinkStep - FLOW_CYCLE_COUNT) / FLOW_CYCLE_COUNT))
-                GPIO_SET_L(SYSLED_PORT, SYSLED_PIN);
+        else if(dev->ledBlinkStep >= dev->flowCycleCount && dev->ledBlinkStep < dev->flowCycleCount * 2){
+            if(cycleCount < (dev->onePulseCount * (dev->ledBlinkStep - dev->flowCycleCount) / dev->flowCycleCount))
+                dev->ioSet(_ATY_HL_L);
             else
-                GPIO_SET_H(SYSLED_PORT, SYSLED_PIN);
+                dev->ioSet(_ATY_HL_H);
         }
-        if(ledBlinkStep >= FLOW_CYCLE_COUNT * 2)
-            ledBlinkStep = 0;
+        if(dev->ledBlinkStep >= dev->flowCycleCount * 2)
+            dev->ledBlinkStep = 0;
     }
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
-
 #endif /* __LED_ATY_C */
 
+/************************************ etc *************************************/
+/* init */
+// void SysLed_1_IO_SET_L(void){ GPIO_SET_L(SYSLED_GPIO_Port, SYSLED_Pin); }
+// void SysLed_1_IO_SET_H(void){ GPIO_SET_H(SYSLED_GPIO_Port, SYSLED_Pin); }
+// struct LED_ATY_Dev LED_ATY_t_1 = {
+//     .ledBlinkStep = 0,
+//     .ledBlinkType = 0x01,
+//     .ioSetL = SysLed_1_IO_SET_L,
+//     .ioSetH = SysLed_1_IO_SET_H,
+//     .longSteps = 20,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf};
+
+// struct LED_ATY_Dev LED_ATY_t_1 = {
+//     .ledBlinkStep = 0,
+//     .ledBlinkType = 0x40,
+//     .ioSetL = SysLed_1_IO_SET_L,
+//     .ioSetH = SysLed_1_IO_SET_H,
+//     .longSteps = 20,
+//     .flowCycleCount = 60000,
+//     .onePulseCount = 60,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf};
+
+/* use */
+// SysLedBlink(&LED_ATY_t_1); // put at 1ms cycle
+
+/******************************************************************************/
+
+
 /******************************** End Of File *********************************/

LED_ATY.h

@@ -24,24 +24,41 @@
 ********************************************************************************
 */
 
-
-
 #ifndef __LED_ATY_H
 #define __LED_ATY_H
 
 #include "INCLUDE_ATY.h"
-#include "HW_GPIO_ATY.h"
-#include "HW_UART_ATY.h"
 
 /******************************* For user *************************************/
-// #define __DEBUG_LED_ATY
-#define LED_LONG_STEPS 20
+// todo: add in struct
+// for breath
+// ms when cycle is 1ms // 3000 at 1ms cycle, 60000 at 24MHz main while cycle
+// #define FLOW_CYCLE_COUNT ((uint32_t)60000)
+// #define FLOW_CYCLE_COUNT (3000)
+// led brghtness split // 10 at 1ms cycle, 1000 at 24MHz main while cycle
+// #define ONE_PULSE_COUNT (60)
+// #define ONE_PULSE_COUNT (10)
 
 /******************************************************************************/
 
-extern uint32_t ledBlinkStep;
-extern uint8_t ledBlinkType;
-void SysLedBlink(void);
+struct LED_ATY_Dev
+{
+    uint32_t ledBlinkStep;
+    uint8_t ledBlinkType;
+
+    void (*ioSet)(uint8_t level);
+
+    uint8_t longSteps;
+
+    uint32_t flowCycleCount;    // optional
+    uint8_t onePulseCount;      // optional
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    void (*LOG)();
+};
+
+uint8_t SysLedBlink(struct LED_ATY_Dev *dev);
 
 
 #endif /* __LED_ATY_H */

MODBUS_LOW_ATY.c

@@ -35,7 +35,7 @@
 
 /******************************************************************************/
 
-#if defined(MODBUS_FLOAT_MODE)
+#if defined (MODBUS_FLOAT_MODE)
 float mbRegHoding[MODBUS_REG_HOLDING_SIZE] = {0};
 /**
  * @brief   modbus process with float
@@ -179,6 +179,7 @@ void Modbus_Process(uint8_t* buf, uint8_t len)
                 sendBuf[2 + (i * 4) + 4] = mbFloatChange_u.u8_t[0];
 #endif
                 sendBufSize += 4;
+                // sendBufSize += 4;    // aty240117
             }
             break; }
         // case MODBUS_FUNC_READ_INPUT_REGISTERS:{break; }

MODBUS_LOW_ATY.h

@@ -61,7 +61,7 @@
 #define MODBUS_FUNC_WRITE_SINGLE_HOLDING_REGISTERS 0x06
 #define MODBUS_FUNC_WRITE_MULTY_HOLDING_REGISTERS  0x10
 
-#if defined(MODBUS_FLOAT_MODE) || defined(MODBUS_FLOAT_CODE_MODE)
+#if defined (MODBUS_FLOAT_MODE) || defined(MODBUS_FLOAT_CODE_MODE)
 #ifndef MUL_FLOAT
 #define MUL_FLOAT 1000
 #endif /* MUL_FLOAT */

MODBUS_S_LOW_ATY.c

@@ -23,6 +23,9 @@
 * @version
 *       - 1_01_221029 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_240120 > ATY
+*           -# add multy addr and channel
+*           -# add lock
 ********************************************************************************
 */
 
@@ -35,31 +38,34 @@
 
 /******************************************************************************/
 
-__XDATA uint16_t mbRegHodingS[MODBUS_REG_HOLDING_SIZE] = {0};
 /**
  * @brief   modbus process
+ *
+ * @param   buf
+ * @param   len
+ * @param   dev
+ * @return  uint8_t
  * @note    only make 03/06/10 function code, others will return err 01
  */
-void Modbus_Process(uint8_t* buf, uint8_t len)
+uint8_t Modbus_Process(uint8_t* buf, uint8_t len, struct MODBUS_S_LOW_ATY_Dev* dev)
 {
     uint8_t sendBuf[(MODBUS_REG_HOLDING_SIZE * 2) + 4] = {0x00};
     uint16_t sendBufSize = 4;
+
+    __ATY_LOCK(dev);
     sendBuf[0] = buf[0];
     sendBuf[1] = buf[1];
 
-    if(buf[0] != MODBUS_ADDR){                      // check addr
+    if(buf[0] == dev->addr){                        // check addr
         if(len < 4){                                // check buf min size
             sendBuf[1] = buf[1] + 0x80;
             sendBuf[2] = 0x02;
             sendBufSize = 6;
-            break;
         }
-
         else if(CheckCrc16Modbus(buf, len)){        // check crc
             sendBuf[1] = buf[1] + 0x80;
             sendBuf[2] = 0x08;
             sendBufSize = 6;
-            break;
         }
         else{
             switch(buf[1])                          // check function code
@@ -76,17 +82,18 @@ void Modbus_Process(uint8_t* buf, uint8_t len)
                         sendBufSize = 6;
                         break;
                     }
-                    sendBuf[2] = regCount * 4;
+                    sendBuf[2] = regCount * 2;
                     sendBufSize += 1;
                     for(i = 0; i < regCount; i++){
-#ifdef BIG_ENDIAN
-                        sendBuf[2 + (i * 2) + 1] = mbRegHodingS[startAddr + i];
-                        sendBuf[2 + (i * 2) + 2] = mbRegHodingS[startAddr + i] >> 8;
-#else
-                        sendBuf[2 + (i * 2) + 1] = mbRegHodingS[startAddr + i] >> 8;
-                        sendBuf[2 + (i * 2) + 2] = mbRegHodingS[startAddr + i];
-#endif
-                        sendBufSize += 4;
+                        if(dev->bigEndian){
+                            sendBuf[2 + (i * 2) + 1] = dev->mbRegs[startAddr + i];
+                            sendBuf[2 + (i * 2) + 2] = dev->mbRegs[startAddr + i] >> 8;
+                        }
+                        else{
+                            sendBuf[2 + (i * 2) + 1] = dev->mbRegs[startAddr + i] >> 8;
+                            sendBuf[2 + (i * 2) + 2] = dev->mbRegs[startAddr + i];
+                        }
+                        sendBufSize += 2;
                     }
                     break;
                 }
@@ -101,21 +108,23 @@ void Modbus_Process(uint8_t* buf, uint8_t len)
                         sendBufSize = 6;
                         break;
                     }
-#ifdef BIG_ENDIAN
-                    mbRegHodingS[startAddr] = buf[4] + buf[5] << 8;
-#else
-                    mbRegHodingS[startAddr] = buf[4] << 8 + buf[5];
-#endif
+                    if(dev->bigEndian){
+                        dev->mbRegs[startAddr] = buf[4] + buf[5] << 8;
+                    }
+                    else{
+                        dev->mbRegs[startAddr] = buf[4] << 8 + buf[5];
+                    }
                     sendBuf[2] = startAddr >> 8;
                     sendBuf[3] = startAddr;
-#ifdef BIG_ENDIAN
-                    sendBuf[4] = mbRegHodingS[startAddr];
-                    sendBuf[5] = mbRegHodingS[startAddr] >> 8;
-#else
-                    sendBuf[4] = mbRegHodingS[startAddr] >> 8;
-                    sendBuf[5] = mbRegHodingS[startAddr];
-#endif
-                    sendBufSize += 6;
+                    if(dev->bigEndian){
+                        sendBuf[4] = dev->mbRegs[startAddr];
+                        sendBuf[5] = dev->mbRegs[startAddr] >> 8;
+                    }
+                    else{
+                        sendBuf[4] = dev->mbRegs[startAddr] >> 8;
+                        sendBuf[5] = dev->mbRegs[startAddr];
+                    }
+                    sendBufSize += 4;
                     break;
                 }
                 case MODBUS_FUNC_WRITE_MULTY_HOLDING_REGISTERS:{
@@ -130,11 +139,12 @@ void Modbus_Process(uint8_t* buf, uint8_t len)
                     }
                     for(i = 0; i < regCount; i++)
                     {
-#ifdef BIG_ENDIAN
-                        mbRegHodingS[startAddr + i] = buf[6 + (i * 4) + 1] + buf[6 + (i * 4) + 2] << 8;
-#else
-                        mbRegHodingS[startAddr + i] = buf[6 + (i * 4) + 1] << 8 + buf[6 + (i * 4) + 2];
-#endif
+                        if(dev->bigEndian){
+                            dev->mbRegs[startAddr + i] = (buf[6 + (i * 2) + 1]) + (buf[6 + (i * 2) + 2] << 8);
+                        }
+                        else{
+                            dev->mbRegs[startAddr + i] = (buf[6 + (i * 2) + 1] << 8) + (buf[6 + (i * 2) + 2]);
+                        }
                     }
 
                     sendBuf[2] = startAddr >> 8;
@@ -152,8 +162,10 @@ void Modbus_Process(uint8_t* buf, uint8_t len)
         }
         sendBuf[sendBufSize - 2] = GenCrc16ModbusHL(sendBuf, sendBufSize - 2, 1);
         sendBuf[sendBufSize - 1] = GenCrc16ModbusHL(sendBuf, sendBufSize - 2, 0);
-        UartSendBytes(sendBuf, sendBufSize);
+        dev->uartSendBytes(sendBuf, sendBufSize);
     }
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 #endif /* __MODBUS_S_LOW_ATY_C */

MODBUS_S_LOW_ATY.h

@@ -29,23 +29,33 @@
 
 #include "INCLUDE_ATY.h"
 #include "ALGO_CRC_ATY.h"
-#include "HW_UART_ATY.h"
 
 /******************************* For user *************************************/
-// #define MODBUS_FLOAT_MODE
-#define MODBUS_FLOAT_CODE_MODE
-
+// set --model-large at 51
 #ifndef MODBUS_REG_HOLDING_SIZE
-#define MODBUS_REG_HOLDING_SIZE                    100   // set --model-large at 51
+#define MODBUS_REG_HOLDING_SIZE                    100
 #endif
+
 #ifndef MODBUS_ADDR
 #define MODBUS_ADDR                                0x01
 #endif
-// #ifdef __STC51_ATY                                      // move to INCLUDE.h
-// #define BIG_ENDIAN                                      // chip in big endian mode
-// #endif
+
 /******************************************************************************/
 
+struct MODBUS_S_LOW_ATY_Dev
+{
+    uint8_t addr;
+    uint8_t size;   // todo: not used
+    uint16_t mbRegs[MODBUS_REG_HOLDING_SIZE];
+
+    uint8_t bigEndian;      // 1 for big endian(51 core)
+    uint8_t(*uartSendBytes)();
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    int (*LOG)();
+};
+
 #define MODBUS_FUNC_READ_COILS                     0x01
 #define MODBUS_FUNC_READ_DISCRETE_INPUTS           0x02
 #define MODBUS_FUNC_READ_HOLDING_REGISTERS         0x03
@@ -54,12 +64,9 @@
 #define MODBUS_FUNC_WRITE_SINGLE_HOLDING_REGISTERS 0x06
 #define MODBUS_FUNC_WRITE_MULTY_HOLDING_REGISTERS  0x10
 
-extern __XDATA float mbRegHodingS[MODBUS_REG_HOLDING_SIZE];
-#else
-extern uint16_t mbRegHodingS[MODBUS_REG_HOLDING_SIZE];
-#endif /* MODBUS_FLOAT_MODE */
+union mbFloatChange{ float f_t; uint8_t u8_t[4]; };
 
-void Modbus_Process(uint8_t* buf, uint8_t len);
+uint8_t Modbus_Process(uint8_t* buf, uint8_t len, struct MODBUS_S_LOW_ATY_Dev* dev);
 
 #endif /* __MODBUS_S_LOW_ATY_H */
 

MOTOR_DC_ATY.c

@@ -21,6 +21,9 @@
 * @version
 *       - 1_01_230426 > ATY
 *           -# Preliminary version, first Release
+*       - 1_01_240112 > ATY
+*           -# add multy addr and channel
+*           -# add lock
 ********************************************************************************
 */
 
@@ -33,120 +36,190 @@
 
 /******************************************************************************/
 
-
-uint8_t motorEn = 0;
-uint8_t motorDir = MOTOR_DIR_OUT;
-uint32_t motorSoftSpeed = 0;
-uint32_t motorSpeed = 0;
-uint32_t motorSoftTime = 0;
-uint32_t motorTime = 0;
-
-uint32_t motorSpeedCounter = 0;
-uint32_t motorStopCounter = 0;
-
-uint8_t motorSetState = 0;          // 0: stop, 1: start hold, 2: start soft, 3: run speed, 4: change dir, 5: stop state, soft set 0 after use, 10: scram motor
-
-
 /**
  * @brief   start motor with direction set
+ *
  * @param   dir direction to move
  * @param   speed direction to move
+ * @param   dev
+ * @return  uint8_t
  */
-void MotorStart(uint8_t dir, uint32_t speed)
+uint8_t MOTOR_DC_Start(uint8_t dir, uint32_t speed, struct MOTOR_DC_ATY_Dev* dev)
 {
-    // MOTOR_EN_SET_ENABLE;
-    if(dir == MOTOR_DIR_IN)
-        MOTOR_IN;
-    else if(dir == MOTOR_DIR_OUT)
-        MOTOR_OUT;
-    __UNUSED(speed);
-    // PwmFreqSet(speed, Motor_Channel);
-#ifdef __DEBUG_MOTOR_DC_ATY
-    printf("\r\nMotor Start: %d - %d", dir, speed);
-#endif /* __DEBUG_MOTOR_DC_ATY */
+    __ATY_LOCK(dev);
+    dev->motorEn = 1;
+    dev->motorDir = dir;
+    if(dir){
+        dev->signalSet('A', 0);
+        dev->signalSet('B', speed);
+    }
+    else{
+        dev->signalSet('A', speed);
+        dev->signalSet('B', 0);
+    }
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
 /**
- * @brief   start motor with only speed
- * @param   speed direction to move
+ * @brief   stop motor
+ *
+ * @param   dev
+ * @return  uint8_t
  */
-void MotorStartSpeed(uint32_t speed)
+uint8_t MOTOR_DC_Stop(struct MOTOR_DC_ATY_Dev* dev)
 {
-    __UNUSED(speed);
-    // MOTOR_EN_SET_ENABLE;
-    // PwmFreqSet(speed, Motor_Channel);
-#ifdef __DEBUG_MOTOR_DC_ATY
-    printf("\r\nMotor Start: %d", speed);
-#endif /* __DEBUG_MOTOR_DC_ATY */
+    if(dev->motorEn == 0)
+        return 1;
+    __ATY_LOCK(dev);
+    dev->motorEn = 0;
+    dev->signalSet('A', 0);
+    dev->signalSet('B', 0);
+    dev->motorSpeedCounter = 0;
+    // MOTOR_DC_PARAM_SET(0, 0, 0, 0, 0, 0, dev);
+    __ATY_UNLOCK(dev);
+    return 0;
 }
 
+
 /**
- * @brief   stop motor
+ * @brief   deal step motor state
+ *
+ * @param   dev
+ * @note    put at 1ms cycle;
+ *          set motorSetState = 4 to change motor dir with speed no changed
+ *          set motorSetState = 3 to start motor directly, motorSoftSteps need to be 0
+ *          set motorSetState = 2 to strat motor with soft, motorDir/0/motorSpeed/motorSoftSteps/motorSteps need to be set
+ *          set motorSetState = 0 to stop motor flow
+ *          set motorSetState = 10 to scram motor
+ *          when motorSetState = 5 means last cycle finished, set others to start a new cycle
+ *          when motorSetState = 1 means motor running and state not changing
  */
-void MotorStop(void)
+void MOTOR_DC_StateMachine_PWM(struct MOTOR_DC_ATY_Dev* dev)
 {
-    // MOTOR_PARAM_SET(MOTOR_DIR_OUT, 0, 0, 0, 0, motorSetState);
-    if(motorEn != 0){
-        // PWM_Stop(0, Motor_Channel);
-        // MOTOR_EN_SET_DISABLE;
-        MOTOR_STOP;
-        motorSpeedCounter = 0;
-        motorStopCounter = 0;
-#ifdef __DEBUG_MOTOR_DC_ATY
-        printf("\r\nMotor Stop");
-#endif /* __DEBUG_MOTOR_DC_ATY */
-    }
-    MOTOR_STANDBY;
+    if(dev->motorSetState == MOTOR_DC_SET_REVERSE){
+        dev->motorStepCounter = 0;
+        dev->motorSetState = MOTOR_DC_SET_START_SOFT;
+        dev->motorDir = !dev->motorDir;
+    }
+    else if(dev->motorSetState == MOTOR_DC_SET_START_DIRECTLY){
+        dev->motorStepCounter = dev->motorSoftSteps;
+        MOTOR_DC_Start(dev->motorDir, dev->motorSpeed, dev);
+        dev->motorSetState = MOTOR_DC_SET_RUNNING;
+    }
+    else if(dev->motorSetState == MOTOR_DC_SET_START_SOFT){
+        dev->motorStepCounter = 0;
+        MOTOR_DC_Start(dev->motorDir, 0, dev);
+        dev->motorSetState = MOTOR_DC_SET_RUNNING;
+    }
+    else if(dev->motorSetState == MOTOR_DC_SET_RUNNING){
+        // if(dev->motorStepCounter < dev->motorSoftSteps){
+        //     if(dev->lineProType == 'T'){
+        //         dev->speedIncreaseStep = ((float)(0 - dev->motorSpeed) / (float)dev->motorSoftSteps);  // at 1ms cycle
+        //         MOTOR_DC_Start(dev->motorDir,
+        //             dev->motorSpeed < (0 - (dev->speedIncreaseStep * dev->motorStepCounter)) ?
+        //             (0 - (dev->speedIncreaseStep * dev->motorStepCounter)) : dev->motorSpeed, dev);
+        //     }
+        //     else if(dev->lineProType == 'S'){
+        //         // S line: y = ax^3 + cx, a in 0-1, c >= 0, lower c cause lower increase at start or end, c for users
+        //         float S_param_A = (((float)(0 - dev->motorSpeed) / 2)
+        //             - (dev->lineProParam * (float)((float)dev->motorSoftSteps / 2) * (float)((float)dev->motorSoftSteps / 2) / 2))
+        //             / ((float)((float)dev->motorSoftSteps / 2) * (float)((float)dev->motorSoftSteps / 2)
+        //                 * (float)((float)dev->motorSoftSteps / 2) * (float)((float)dev->motorSoftSteps / 2)) * 4;
+        //         // mbG[27] = S_param_A * 10000000;
+        //         if(dev->motorStepCounter < (dev->motorSoftSteps / 2))
+        //             dev->speedIncreaseStep =
+        //             ((float)(S_param_A * dev->motorStepCounter * dev->motorStepCounter * dev->motorStepCounter * dev->motorStepCounter) / 4)
+        //             + ((float)(dev->lineProParam * dev->motorStepCounter * dev->motorStepCounter) / 2);
+        //         // (S_param_A * dev->motorStepCounter * dev->motorStepCounter * dev->motorStepCounter)
+        //         // + (lineProParam * dev->motorStepCounter);
+        //         else
+        //             dev->speedIncreaseStep =
+        //             (float)((float)(0 - dev->motorSpeed) / 2)
+        //             + ((float)(S_param_A * dev->motorSoftSteps * dev->motorSoftSteps * dev->motorSoftSteps * dev->motorSoftSteps) / 64)
+        //             + ((float)(dev->lineProParam * dev->motorSoftSteps * dev->motorSoftSteps) / 8)
+        //             - ((float)(S_param_A * (dev->motorSoftSteps - dev->motorStepCounter) * (dev->motorSoftSteps - dev->motorStepCounter)
+        //                 * (dev->motorSoftSteps - dev->motorStepCounter) * (dev->motorSoftSteps - dev->motorStepCounter)) / 4)
+        //             - ((float)(dev->lineProParam * (dev->motorSoftSteps - dev->motorStepCounter) * (dev->motorSoftSteps - dev->motorStepCounter)) / 2);
+        //             // 0
+        //             // - (S_param_A * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps)
+        //             //     * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps)
+        //             //     * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps))
+        //             // - (dev->lineProParam * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps));
+        //         MOTOR_DC_Start(dev->motorDir,
+        //             dev->motorSpeed < (0 - dev->speedIncreaseStep) ?
+        //             (0 - dev->speedIncreaseStep) : dev->motorSpeed, dev);
+        //     }
+        //     else if(dev->lineProType == '2'){}
+        // }
+
+        if(dev->motorStepCounter == dev->motorSoftSteps)
+            dev->motorSetState = MOTOR_DC_SET_START_DIRECTLY;
+        else if(dev->motorStepCounter >= (dev->motorSoftSteps + dev->motorSteps))
+            dev->motorSetState = MOTOR_DC_SET_FINISHED;
+    }
+    else if(dev->motorSetState == MOTOR_DC_SET_SCRAM){
+        MOTOR_DC_Stop(dev);
+        dev->motorSetState = MOTOR_DC_SET_STOP;
+    }
+    else{ MOTOR_DC_Stop(dev); }    // 5 0
+
+    if(dev->motorEn == 0){
+        dev->motorStepCounter = 0;
+    }
+    else{
+        dev->motorStepCounter++;
+    }
 }
 
+
 /**
  * @brief   deal step motor state
+ *
+ * @param   dev
  * @note    put at 1ms cycle;
  *          set motorSetState = 4 to change motor dir with speed no change
- *          set motorSetState = 3 to start motor directly, motorSoftTime need to be 0
- *          set motorSetState = 2 to strat motor with soft, motorDir/motorSoftSpeed/motorSpeed/motorSoftTime/motorTime need to be set
+ *          set motorSetState = 3 to start motor directly, motorSoftSteps need to be 0
+ *          set motorSetState = 2 to strat motor with soft, motorDir/0/motorSpeed/motorSoftSteps/motorTime need to be set
  *          set motorSetState = 0 to stop motor
  *          set motorSetState = 10 to scram motor
  *          when motorSetState = 5 means last cycle finished, set others to start a new cycle
  *          when motorSetState = 1 means motor running and state not changing
  */
-void MotorStateMachine_DC(void)
+void MOTOR_DC_StateMachine(struct MOTOR_DC_ATY_Dev* dev)
 {
-    if(motorSetState == 4){
-        motorSpeedCounter = 0;
-        motorStopCounter = 0;
-        motorSetState = 1;
-        motorDir = !motorDir;
-    }
-    else if(motorSetState == 3){
-        motorSpeedCounter = motorSoftTime;
-        motorSetState = 1;
-        MotorStart(motorDir, motorSpeed);
-    }
-    else if(motorSetState == 2){
-        motorSpeedCounter = 0;
-        motorSetState = 1;
-        MotorStart(motorDir, motorSoftSpeed);
-    }
-    else if(motorSetState == 1){
-        if(motorSpeedCounter == motorSoftTime)
-            motorSetState = 3;
-        else if(motorSpeedCounter == (motorSoftTime + motorTime))
-            motorSetState = 5;
-    }
-    else if(motorSetState == 10){
-        motorSetState = 0;
-        MotorStop();
-    }
-    else{ MotorStop(); }    // 5 0
-
-    if(motorEn == 0){
-        motorSpeedCounter = 0;
-        motorStopCounter++;
+    if(dev->motorSetState == 4){
+        dev->motorSpeedCounter = 0;
+        dev->motorSetState = 1;
+        dev->motorDir = !dev->motorDir;
+    }
+    else if(dev->motorSetState == 3){
+        dev->motorSpeedCounter = dev->motorSoftSteps;
+        dev->motorSetState = 1;
+        MOTOR_DC_Start(dev->motorDir, dev->motorSpeed, dev);
+    }
+    else if(dev->motorSetState == 2){
+        dev->motorSpeedCounter = 0;
+        dev->motorSetState = 1;
+        MOTOR_DC_Start(dev->motorDir, 0, dev);
+    }
+    else if(dev->motorSetState == 1){
+        if(dev->motorSpeedCounter == dev->motorSoftSteps)
+            dev->motorSetState = 3;
+        else if(dev->motorSpeedCounter == (dev->motorSoftSteps + dev->motorSteps))
+            dev->motorSetState = 5;
+    }
+    else if(dev->motorSetState == 10){
+        dev->motorSetState = 0;
+        MOTOR_DC_Stop(dev);
+    }
+    else{ MOTOR_DC_Stop(dev); }    // 5 0
+
+    if(dev->motorEn == 0){
+        dev->motorSpeedCounter = 0;
     }
     else{
-        motorSpeedCounter++;
-        motorStopCounter = 0;
+        dev->motorSpeedCounter++;
     }
 }
 

MOTOR_DC_ATY.h

@@ -21,6 +21,9 @@
 * @version
 *       - 1_01_230426 > ATY
 *           -# Preliminary version, first Release
+*       - 1_01_240112 > ATY
+*           -# add multy addr and channel
+*           -# add lock
 ********************************************************************************
 */
 
@@ -28,76 +31,77 @@
 #define __MOTOR_DC_ATY_H
 
 #include "INCLUDE_ATY.h"
-#include "HW_GPIO_ATY.h"
-#include "HW_PWM_ATY.h"
-
 
 /******************************* For user *************************************/
-// #define __DEBUG_MOTOR_DC_ATY
-// #define Motor_Channel 2
 
 /******************************************************************************/
 
-extern uint8_t motorEn;
-extern uint8_t motorDir;
-extern uint32_t motorSoftSpeed;
-extern uint32_t motorSpeed;
-extern uint32_t motorSoftTime;
-extern uint32_t motorTime;
-
-extern uint32_t motorSpeedCounter;
-extern uint32_t motorStopCounter;       // for stall detection or driver error(TMC2209)
-
-extern uint8_t motorSetState;           // 0: stop, 1: start hold, 2: start soft, 3: run speed, 4: change dir, 5: stop state, soft set 0 after use
-
-
-#define MOTOR_STANDBY \
-    do{GPIO_SET_L(MOTOR_A_PORT, MOTOR_A_PIN); GPIO_SET_L(MOTOR_B_PORT, MOTOR_B_PIN); motorEn = 0;}while(0)
-#define MOTOR_STOP \
-    do{GPIO_SET_H(MOTOR_A_PORT, MOTOR_A_PIN); GPIO_SET_H(MOTOR_B_PORT, MOTOR_B_PIN); motorEn = 0;}while(0)
-#define MOTOR_IN \
-    do{GPIO_SET_L(MOTOR_A_PORT, MOTOR_A_PIN); GPIO_SET_H(MOTOR_B_PORT, MOTOR_B_PIN); motorEn = 1;}while(0)
-#define MOTOR_OUT \
-    do{GPIO_SET_H(MOTOR_A_PORT, MOTOR_A_PIN); GPIO_SET_L(MOTOR_B_PORT, MOTOR_B_PIN); motorEn = 1;}while(0)
-
-/*
-#define MOTOR_EN_SET_ENABLE \
-    do{GPIO_SET_L(MOTOR_EN_PORT, MOTOR_EN_PIN); motorEn = 1;}while(0)
-#define MOTOR_EN_SET_DISABLE \
-    do{GPIO_SET_H(MOTOR_EN_PORT, MOTOR_EN_PIN); motorEn = 0;}while(0)
-*/
+struct MOTOR_DC_ATY_Dev
+{
+    uint8_t id;
 
-#define MOTOR_DIR_OUT       2
-#define MOTOR_DIR_IN        1
-/*
-#define MOTOR_DIR_SET_IN \
-    do{GPIO_SET_H(MOTOR_DIR_PORT, MOTOR_DIR_PIN); motorDir = MOTOR_DIR_IN;}while(0)
-#define MOTOR_DIR_SET_OUT \
-    do{GPIO_SET_L(MOTOR_DIR_PORT, MOTOR_DIR_PIN); motorDir = MOTOR_DIR_OUT;}while(0)
-
-#define MOTOR_STEP_SET_H \
-    (GPIO_SET_H(MOTOR_STEP_PORT, MOTOR_STEP_PIN))
-#define MOTOR_STEP_SET_L \
-    (GPIO_SET_L(MOTOR_STEP_PORT, MOTOR_STEP_PIN))
-*/
+    uint8_t motorEn;
+    uint8_t motorDir;
+
+    uint32_t motorSpeed;
+    uint32_t motorSpeedCounter;
+
+    uint32_t motorSoftSteps;
+    uint32_t motorSteps;
+    uint32_t motorStepCounter;
+
+    uint8_t motorSetState;          // 0: stop, 1: start hold, 2: start soft, 3: run speed, 4: change dir, 5: stop state, soft set 0 after use, 10: scram motor
+
+    float speedIncreaseStep;
+    uint8_t lineProType;
+    float lineProParam;
+
+    void (*signalSet)(uint8_t pin, uint8_t level);
 
-#define MOTOR_PARAM_SET(dir, softSpeed, speed, softTime, time, setState) \
+    uint8_t lock;
+    uint8_t debugEnable;
+    void (*LOG)();
+};
+
+
+#define MOTOR_DC_PARAM_SET(en, dir, speed, softSteps, steps, setState, dev) \
     do \
     { \
-        motorDir = dir; \
-        motorSoftSpeed = softSpeed; \
-        motorSpeed = speed; \
-        motorSoftTime = softTime; \
-        motorTime = time; \
-        motorSetState = setState; \
+        dev->motorEn = (uint8_t)en; \
+        dev->motorDir = (uint8_t)dir; \
+        dev->motorSpeed = (uint32_t)speed; \
+        dev->motorSoftSteps = (uint32_t)softSteps; \
+        dev->motorSteps = (uint32_t)steps; \
+        dev->motorSetState = (uint8_t)setState; \
     } while(0)
 
+#define MOTOR_DC_PARAM_GET(en, dir, speed, softSteps, steps, setState, dev) \
+    do \
+    { \
+        en = dev.motorEn; \
+        dir = dev.motorDir; \
+        speed = dev.motorSpeed; \
+        softSteps = dev.motorSoftSteps; \
+        steps = dev.motorSteps; \
+        setState = dev.motorSetState; \
+    } while(0)
+
+
+uint8_t MOTOR_DC_Start(uint8_t dir, uint32_t speed, struct MOTOR_DC_ATY_Dev* dev);
+uint8_t MOTOR_DC_Stop(struct MOTOR_DC_ATY_Dev* dev);
+void MOTOR_DC_StateMachine_PWM(struct MOTOR_DC_ATY_Dev* dev);
+void MOTOR_DC_StateMachine(struct MOTOR_DC_ATY_Dev* dev);
 
-void MotorStart(uint8_t dir, uint32_t speed);
-void MotorStartSpeed(uint32_t speed);
-void MotorStop(void);
-void MotorStateMachine_DC(void);
+#define MOTOR_DC_SET_REVERSE           4
+#define MOTOR_DC_SET_START_DIRECTLY    3
+#define MOTOR_DC_SET_START_SOFT        2
+#define MOTOR_DC_SET_STOP              0
+#define MOTOR_DC_SET_SCRAM             10
+#define MOTOR_DC_SET_FINISHED          5
+#define MOTOR_DC_SET_RUNNING           1
 
+/* for motor soft start  */
+#define MOTOR_DC_S_PARAM_C                   0.5f      // 0-1
 
 #endif /* __MOTOR_DC_ATY_H */
 

MOTOR_STEP_ATY.c

@@ -140,19 +140,13 @@ void MotorSetStepLevel(uint8_t level, uint8_t channel)
 uint8_t MotorGetDiagLevel(uint8_t channel)
 {
 #if (MOTOR_COUNT >= 1)
-#if defined (MOTOR_DIAG_PORT_0) && defined (MOTOR_DIAG_PIN_0)
     if(channel == 0){ motorStep_t_Group[channel].motorDiag = GPIO_GET(MOTOR_DIAG_PORT_0, MOTOR_DIAG_PIN_0); }
 #endif
-#endif
 #if (MOTOR_COUNT >= 2)
-#if defined (MOTOR_DIAG_PORT_1) && defined (MOTOR_DIAG_PIN_0)
     if(channel == 1){ motorStep_t_Group[channel].motorDiag = GPIO_GET(MOTOR_DIAG_PORT_1, MOTOR_DIAG_PIN_1); }
 #endif
-#endif
 #if (MOTOR_COUNT >= 3)
-#if defined (MOTOR_DIAG_PORT_2) && defined (MOTOR_DIAG_PIN_2)
     if(channel == 2){ motorStep_t_Group[channel].motorDiag = GPIO_GET(MOTOR_DIAG_PORT_2, MOTOR_DIAG_PIN_2); }
-#endif
 #endif
     return motorStep_t_Group[channel].motorDiag;
 }
@@ -242,10 +236,10 @@ void MotorSelfCycle(uint8_t channel)
 /**
  * @brief   deal step motor state
  * @note    put at 1ms cycle;
- *          set motorSetState = 4 to change motor dir with speed no changed
+ *          set motorSetState = 4 to change motor dir with speed no change
  *          set motorSetState = 3 to start motor directly, motorSoftSteps need to be 0
  *          set motorSetState = 2 to strat motor with soft, motorDir/motorSoftSpeed/motorSpeed/motorSoftSteps/motorSteps need to be set
- *          set motorSetState = 0 to stop motor flow
+ *          set motorSetState = 0 to stop motor
  *          set motorSetState = 10 to scram motor
  *          when motorSetState = 5 means last cycle finished, set others to start a new cycle
  *          when motorSetState = 1 means motor running and state not changing
@@ -336,7 +330,7 @@ void MotorStateMachine_Step_PWM(void)
 }
 
 
-uint8_t motorLastState[MOTOR_COUNT] = {0};
+uint8_t motorLastState[2] = {0};
 /**
  * @brief   deal step motor state
  * @note    put at 1us cycle;
@@ -387,46 +381,6 @@ void MotorStateMachine_Step(void)
         }
 
 
-        if(motorStep_t_Group[i].motorEn){
-            motorStep_t_Group[i].motorStopCounter = 0;
-            MotorSetDirection(motorStep_t_Group[i].motorDir, i);
-            MotorSetAble(motorStep_t_Group[i].motorEn, i);
-            motorStep_t_Group[i].motorSpeedCounter++;
-
-            if((motorLastState[i] == 3 && motorStep_t_Group[i].motorSpeedCounter >= motorStep_t_Group[i].motorSpeed)
-                || (motorLastState[i] == 2 && motorStep_t_Group[i].motorSpeedCounter >= motorStep_t_Group[i].motorSoftSpeed)){
-                motorStep_t_Group[i].motorSpeedCounter = 0;
-                motorStep_t_Group[i].motorStepLevel = !motorStep_t_Group[i].motorStepLevel;
-                MotorSetStepLevel(motorStep_t_Group[i].motorStepLevel, i);
-
-                if(motorStep_t_Group[i].motorStepLevel == STATIC_STEP_LEVEL){
-                    motorStep_t_Group[i].motorStepCounter++;
-
-                    if((motorLastState[i] == 3 && motorStep_t_Group[i].motorStepCounter >= motorStep_t_Group[i].motorSteps)
-                        || (motorLastState[i] == 2 && motorStep_t_Group[i].motorStepCounter >= motorStep_t_Group[i].motorSoftSteps)){
-                        motorStep_t_Group[i].motorSpeedCounter = 0;
-                        motorStep_t_Group[i].motorStepCounter = 0;
-                        motorStep_t_Group[i].motorStepLevel = STATIC_STEP_LEVEL;
-                        MotorSetStepLevel(motorStep_t_Group[i].motorStepLevel, i);
-                        // motorStep_t_Group[i].motorSpeedCounter = 0;
-                        if(motorLastState[i] == 3)
-                            motorStep_t_Group[i].motorSetState = 5;
-                        else if(motorLastState[i] == 2)
-                            motorStep_t_Group[i].motorSetState = 3;
-                    }
-                }
-            }
-        }
-        else{
-            motorStep_t_Group[i].motorSpeedCounter = 0;
-            motorStep_t_Group[i].motorStepCounter = 0;
-            motorStep_t_Group[i].motorStopCounter++;
-            motorStep_t_Group[i].motorStepLevel = STATIC_STEP_LEVEL;
-            MotorSetStepLevel(motorStep_t_Group[i].motorStepLevel, i);
-            MotorSetAble(motorStep_t_Group[i].motorEn, i);
-        }
-
-
 //         if(motorStep_t_Group[i].motorSetState == 4){
 //             motorStep_t_Group[i].motorSpeedCounter = 0;
 //             motorStep_t_Group[i].motorStopCounter = 0;
@@ -507,6 +461,47 @@ void MotorStateMachine_Step(void)
 //             motorStep_t_Group[i].motorStopCounter = 0;
 //         }
 
+        if(motorStep_t_Group[i].motorEn){
+            motorStep_t_Group[i].motorStopCounter = 0;
+            MotorSetDirection(motorStep_t_Group[i].motorDir, i);
+            MotorSetAble(motorStep_t_Group[i].motorEn, i);
+            motorStep_t_Group[i].motorSpeedCounter++;
+            mbP_HSTV = motorStep_t_Group[i].motorSpeedCounter;
+
+            if((motorLastState[i] == 3 && motorStep_t_Group[i].motorSpeedCounter >= motorStep_t_Group[i].motorSpeed)
+                || (motorLastState[i] == 2 && motorStep_t_Group[i].motorSpeedCounter >= motorStep_t_Group[i].motorSoftSpeed)){
+                motorStep_t_Group[i].motorSpeedCounter = 0;
+                motorStep_t_Group[i].motorStepLevel = !motorStep_t_Group[i].motorStepLevel;
+                MotorSetStepLevel(motorStep_t_Group[i].motorStepLevel, i);
+                mbP_HSHS = motorStep_t_Group[i].motorStepLevel;
+                mbP_HSTW = motorStep_t_Group[i].motorStepCounter;
+
+                if(motorStep_t_Group[i].motorStepLevel == STATIC_STEP_LEVEL){
+                    motorStep_t_Group[i].motorStepCounter++;
+
+                    if((motorLastState[i] == 3 && motorStep_t_Group[i].motorStepCounter >= motorStep_t_Group[i].motorSteps)
+                        || (motorLastState[i] == 2 && motorStep_t_Group[i].motorStepCounter >= motorStep_t_Group[i].motorSoftSteps)){
+                        motorStep_t_Group[i].motorSpeedCounter = 0;
+                        motorStep_t_Group[i].motorStepCounter = 0;
+                        motorStep_t_Group[i].motorStepLevel = STATIC_STEP_LEVEL;
+                        MotorSetStepLevel(motorStep_t_Group[i].motorStepLevel, i);
+                        // motorStep_t_Group[i].motorSpeedCounter = 0;
+                        if(motorLastState[i] == 3)
+                            motorStep_t_Group[i].motorSetState = 5;
+                        else if(motorLastState[i] == 2)
+                            motorStep_t_Group[i].motorSetState = 3;
+                    }
+                }
+            }
+        }
+        else{
+            motorStep_t_Group[i].motorSpeedCounter = 0;
+            motorStep_t_Group[i].motorStepCounter = 0;
+            motorStep_t_Group[i].motorStopCounter++;
+            motorStep_t_Group[i].motorStepLevel = STATIC_STEP_LEVEL;
+            MotorSetStepLevel(motorStep_t_Group[i].motorStepLevel, i);
+            MotorSetAble(motorStep_t_Group[i].motorEn, i);
+        }
     }
 }
 

MOTOR_STEP_ATY.h

@@ -37,45 +37,41 @@
 
 
 /******************************* For user *************************************/
-#include "main.h"
 // #define __DEBUG_MOTOR_STEP_ATY
-
-/* set program for motor soft start  */
 // #define S_PARAM_C 0.5f      // 0-1
 // #define Motor_StartLine_2
-// #define Motor_StartLine_T
+#define Motor_StartLine_T
 // #define Motor_StartLine_S
-
-/* 3 max, if need more, add codes at every function */
-// #define MOTOR_COUNT 2
-
-/* pin defination must include all motors,
-    diag pin is selectable, do not define if not use */
-// #define MOTOR_EN_PORT_0                 TMC1_EN_GPIO_Port
-// #define MOTOR_EN_PIN_0                  TMC1_EN_Pin
-// #define MOTOR_DIR_PORT_0                TMC1_DIR_GPIO_Port
-// #define MOTOR_DIR_PIN_0                 TMC1_DIR_Pin
-// #define MOTOR_STEP_PORT_0               TMC1_STEP_GPIO_Port
-// #define MOTOR_STEP_PIN_0                TMC1_STEP_Pin
-// // #define MOTOR_DIAG_PORT_0               0
-// // #define MOTOR_DIAG_PIN_0                0
-// #define MOTOR_PWM_Channel_0            PWM_T3C2
-
-// #define MOTOR_EN_PORT_1                 TMC1_EN_GPIO_Port
-// #define MOTOR_EN_PIN_1                  TMC1_EN_Pin
-// #define MOTOR_DIR_PORT_1                TMC1_DIR_GPIO_Port
-// #define MOTOR_DIR_PIN_1                 TMC1_DIR_Pin
-// #define MOTOR_STEP_PORT_1               TMC1_STEP_GPIO_Port
-// #define MOTOR_STEP_PIN_1                TMC1_STEP_Pin
-// // #define MOTOR_DIAG_PORT_1               0
-// // #define MOTOR_DIAG_PIN_1                0
-// #define MOTOR_PWM_Channel_1            PWM_T1C1
-
-/* set step pin vol level when motor is not enable  */
-// #define STATIC_STEP_LEVEL 0
+// #define Motor_Channel PWM_T2C2
+
+// 3 max, if need more, add codes at every function
+#define MOTOR_COUNT 2
+
+// pin defination must include all motors
+// diag pin is selectable
+#define MOTOR_EN_PORT_0               0
+#define MOTOR_EN_PIN_0                P37
+#define MOTOR_DIR_PORT_0              0
+#define MOTOR_DIR_PIN_0               P21
+#define MOTOR_STEP_PORT_0             0
+#define MOTOR_STEP_PIN_0              P23
+#define MOTOR_DIAG_PORT_0             0
+#define MOTOR_DIAG_PIN_0              0
+#define MOTOR_PWM_Channel_0           PWM_CHANNEL_8P
+
+#define MOTOR_EN_PORT_1               0
+#define MOTOR_EN_PIN_1                P36
+#define MOTOR_DIR_PORT_1              0
+#define MOTOR_DIR_PIN_1               P20
+#define MOTOR_STEP_PORT_1             0
+#define MOTOR_STEP_PIN_1              P22
+#define MOTOR_DIAG_PORT_1             0
+#define MOTOR_DIAG_PIN_1              0
+#define MOTOR_PWM_Channel_1           PWM_CHANNEL_7P
+
+#define STATIC_STEP_LEVEL 0
 /******************************************************************************/
 
-
 typedef struct{
     uint8_t motorEn;
     uint8_t motorDir;
@@ -128,6 +124,8 @@ extern motorStep_t motorStep_t_Group[MOTOR_COUNT];
         setState = motorStep_t_Group[(uint8_t)channel].motorSetState; \
     } while(0)
 
+#define MOTOR_DIR_IN 1
+#define MOTOR_DIR_OUT 0
 
 void MotorSetAble(uint8_t enable, uint8_t channel);
 void MotorSetDirection(uint8_t dir, uint8_t channel);
@@ -141,78 +139,6 @@ void MotorStop(uint8_t channel);
 void MotorStateMachine_Step(void);
 void MotorStateMachine_Step_PWM(void);
 
-#define MOTOR_DIR_IN 1
-#define MOTOR_DIR_OUT 0
-
-#define MOTOR_SET_REVERSE 4
-#define MOTOR_SET_START_DIRECTLY 3
-#define MOTOR_SET_START_SOFT 2
-#define MOTOR_SET_STOP 0
-#define MOTOR_SET_SCRAM 10
-#define MOTOR_SET_FINISHED 5
-#define MOTOR_SET_RUNNING 1
-
-#define PWM_T01C1 0x11
-#define PWM_T01C2 0x12
-#define PWM_T01C3 0x13
-#define PWM_T01C4 0x14
-#define PWM_T02C1 0x21
-#define PWM_T02C2 0x22
-#define PWM_T02C3 0x23
-#define PWM_T02C4 0x24
-#define PWM_T03C1 0x31
-#define PWM_T03C2 0x32
-#define PWM_T03C3 0x33
-#define PWM_T03C4 0x34
-#define PWM_T04C1 0x41
-#define PWM_T04C2 0x42
-#define PWM_T04C3 0x43
-#define PWM_T04C4 0x44
-#define PWM_T05C1 0x51
-#define PWM_T05C2 0x52
-#define PWM_T05C3 0x53
-#define PWM_T05C4 0x54
-#define PWM_T06C1 0x61
-#define PWM_T06C2 0x62
-#define PWM_T06C3 0x63
-#define PWM_T06C4 0x64
-#define PWM_T07C1 0x71
-#define PWM_T07C2 0x72
-#define PWM_T07C3 0x73
-#define PWM_T07C4 0x74
-#define PWM_T08C1 0x81
-#define PWM_T08C2 0x82
-#define PWM_T08C3 0x83
-#define PWM_T08C4 0x84
-#define PWM_T09C1 0x91
-#define PWM_T09C2 0x92
-#define PWM_T09C3 0x93
-#define PWM_T09C4 0x94
-#define PWM_T10C1 0xA1
-#define PWM_T10C2 0xA2
-#define PWM_T10C3 0xA3
-#define PWM_T10C4 0xA4
-#define PWM_T11C1 0xB1
-#define PWM_T11C2 0xB2
-#define PWM_T11C3 0xB3
-#define PWM_T11C4 0xB4
-#define PWM_T12C1 0xC1
-#define PWM_T12C2 0xC2
-#define PWM_T12C3 0xC3
-#define PWM_T12C4 0xC4
-#define PWM_T13C1 0xD1
-#define PWM_T13C2 0xD2
-#define PWM_T13C3 0xD3
-#define PWM_T13C4 0xD4
-#define PWM_T14C1 0xE1
-#define PWM_T14C2 0xE2
-#define PWM_T14C3 0xE3
-#define PWM_T14C4 0xE4
-#define PWM_T15C1 0xF1
-#define PWM_T15C2 0xF2
-#define PWM_T15C3 0xF3
-#define PWM_T15C4 0xF4
-
 
 #endif /* __MOTOR_STEP_ATY_H */
 

NoPublic/STM32_HAL_PRINTF_ATY.c

@@ -31,7 +31,7 @@
 #include "usart.h"
 
 /******************************* For user *************************************/
-#if defined(__STM32_HAL_ATY) && defined(DEBUG_PRINTF_RECEIVE)
+#if defined (__STM32_HAL_ATY) && defined(DEBUG_PRINTF_RECEIVE)
 void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size)
 {
     HAL_UART_DMAStop(&PRINTF_UART);

OLED_SSD1306_ATY.c

@@ -247,6 +247,7 @@ void OLED_Dis_Welcom(void)
     OLED_DrawString8x16(0, 0, "I. Astrol", FontSongTi8x16);
     // OLED_DrawString8x16(0, 16, "HT", 2, FontSongTi8x16);
 }
+// todo: not tested
 
 
 #endif /* __OLED_SSD1306_ATY_C */

SHT3X_ATY.c

@@ -22,6 +22,8 @@
 * @version
 *       - 1_01_200318 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -91,23 +93,27 @@ uint8_t SHT3X_CheckCrc(uint8_t* sht3xData, uint8_t nbrOfBytes, uint8_t checksum)
 /**
  * @brief   write command to SHT3X
  * @param   cmd command to send
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void SHT3X_WriteCommand(sht3xCommands cmd)
+void SHT3X_WriteCommand(sht3xCommands cmd, uint8_t addr, uint8_t channel)
 {
     uint8_t cmd_t[2];
     cmd_t[0] = cmd >> 8;
     cmd_t[1] = cmd & 0xFF;
-    I2C_Write(SHT3X_ADDR, cmd_t, 2);
+    I2C_Write(addr, cmd_t, 2, channel);
 }
 
 /**
  * @brief   start periodic measurment
  * @param   repeatability repeatability
  * @param   frequency frequency
+ * @param   addr chip address
+ * @param   channel chip channel
  * @note    use depending on the required repeatability and frequency,
  *          the corresponding command
  */
-void SHT3X_StartPeriodicMeasurment(sht3xRepeatability repeatability, sht3xFrequency frequency)
+void SHT3X_StartPeriodicMeasurment(sht3xRepeatability repeatability, sht3xFrequency frequency, uint8_t addr, uint8_t channel)
 {
     switch(repeatability)
     {
@@ -115,19 +121,19 @@ void SHT3X_StartPeriodicMeasurment(sht3xRepeatability repeatability, sht3xFreque
             switch(frequency)
             {
                 case FREQUENCY_HZ5:  // low repeatability,  0.5 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_05_L);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_05_L, addr, channel);
                     break;
                 case FREQUENCY_1HZ:  // low repeatability,  1.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_1_L);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_1_L, addr, channel);
                     break;
                 case FREQUENCY_2HZ:  // low repeatability,  2.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_2_L);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_2_L, addr, channel);
                     break;
                 case FREQUENCY_4HZ:  // low repeatability,  4.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_4_L);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_4_L, addr, channel);
                     break;
                 case FREQUENCY_10HZ: // low repeatability, 10.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_10_L);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_10_L, addr, channel);
                     break;
                 default:
                     break;
@@ -138,19 +144,19 @@ void SHT3X_StartPeriodicMeasurment(sht3xRepeatability repeatability, sht3xFreque
             switch(frequency)
             {
                 case FREQUENCY_HZ5:  // medium repeatability,  0.5 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_05_M);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_05_M, addr, channel);
                     break;
                 case FREQUENCY_1HZ:  // medium repeatability,  1.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_1_M);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_1_M, addr, channel);
                     break;
                 case FREQUENCY_2HZ:  // medium repeatability,  2.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_2_M);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_2_M, addr, channel);
                     break;
                 case FREQUENCY_4HZ:  // medium repeatability,  4.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_4_M);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_4_M, addr, channel);
                     break;
                 case FREQUENCY_10HZ: // medium repeatability, 10.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_10_M);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_10_M, addr, channel);
                     break;
                 default:
                     break;
@@ -161,16 +167,16 @@ void SHT3X_StartPeriodicMeasurment(sht3xRepeatability repeatability, sht3xFreque
             switch(frequency)
             {
                 case FREQUENCY_HZ5:  // high repeatability,  0.5 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_05_H);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_05_H, addr, channel);
                     break;
                 case FREQUENCY_1HZ:  // high repeatability,  1.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_1_H);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_1_H, addr, channel);
                     break;
                 case FREQUENCY_2HZ:  // high repeatability,  2.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_2_H);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_2_H, addr, channel);
                     break;
                 case FREQUENCY_4HZ:  // high repeatability,  4.0 Hz
-                    SHT3X_WriteCommand(CMD_MEAS_PERI_4_H);
+                    SHT3X_WriteCommand(CMD_MEAS_PERI_4_H, addr, channel);
                     break;
                 case FREQUENCY_10HZ: // high repeatability, 10.0 Hz
                     SHT3X_WriteCommand(CMD_MEAS_PERI_10_H);
@@ -224,13 +230,15 @@ void SHT3X_ValuePorcess(uint16_t* temperature, uint16_t* humidity)
  * @brief   read all data from SHT3X
  * @param   temperature temperature 16 bit origin value
  * @param   humidity humidity 16 bit origin value
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void SHT3X_ReadDataAndCrc(uint16_t* temperature, uint16_t* humidity)
+void SHT3X_ReadDataAndCrc(uint16_t* temperature, uint16_t* humidity, uint8_t addr, uint8_t channel)
 {
     uint8_t bytes[6]; // read 2 data array and 1 checksum byte
 
     // read two data bytes and one checksum byte
-    I2C_Read(SHT3X_ADDR, bytes, 6);
+    I2C_Read(addr, bytes, 6, channel);
 
     // verify checksum then combine the two bytes to a 16-bit value
     if(!SHT3X_CheckCrc(bytes, 2, bytes[2]))
@@ -247,22 +255,26 @@ void SHT3X_ReadDataAndCrc(uint16_t* temperature, uint16_t* humidity)
 
 /**
  * @brief   read data and calc real value
+ * @param   addr chip address
+ * @param   channel chip channel
  */
-void SHT3X_ReadMeasurementBuffer(void)
+void SHT3X_ReadMeasurementBuffer(uint8_t addr, uint8_t channel)
 {
     uint16_t hexValueTemp = 0;
     uint16_t hexValueHumi = 0;
 
-    SHT3X_WriteCommand(CMD_FETCH_DATA);
-    SHT3X_ReadDataAndCrc(&hexValueTemp, &hexValueHumi);
+    SHT3X_WriteCommand(CMD_FETCH_DATA, addr, channel);
+    SHT3X_ReadDataAndCrc(&hexValueTemp, &hexValueHumi, addr, channel);
 }
 
 /**
  * @brief   start measurement in clock stretching mode
  * @param   repeatability repeatability
+ * @param   addr chip address
+ * @param   channel chip channel
  * @note    use depending on the required repeatability, the corresponding command
  */
-void SHT3X_GetTempAndHumiClkStretch(sht3xRepeatability repeatability)
+void SHT3X_GetTempAndHumiClkStretch(sht3xRepeatability repeatability, uint8_t addr, uint8_t channel)
 {
     uint16_t hexTempValue = 0;
     uint16_t hexHumiValue = 0;
@@ -270,47 +282,50 @@ void SHT3X_GetTempAndHumiClkStretch(sht3xRepeatability repeatability)
     switch(repeatability)
     {
         case REPEATAB_LOW:
-            SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_L);
+            SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_L, addr, channel);
             break;
         case REPEATAB_MEDIUM:
-            SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_M);
+            SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_M, addr, channel);
             break;
         case REPEATAB_HIGH:
-            SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_H);
+            SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_H, addr, channel);
             break;
         default:
             break;
     }
-    SHT3X_ReadDataAndCrc(&hexTempValue, &hexHumiValue);
+    SHT3X_ReadDataAndCrc(&hexTempValue, &hexHumiValue, addr, channel);
 }
 
 /**
  * @brief   init SHT3X, check device
+ * @param   addr chip address
+ * @param   channel chip channel
  * @note    put at main init
  */
-void SHT3X_InitBegin(void)
+void SHT3X_InitBegin(uint8_t addr, uint8_t channel)
 {
     uint8_t i = 0;
 
-    SHT3X_StartPeriodicMeasurment(REPEATAB_HIGH, FREQUENCY_10HZ);
+    SHT3X_StartPeriodicMeasurment(REPEATAB_HIGH, FREQUENCY_10HZ, addr, channel);
     for(i = 0; i < 9; i++)
     {
         DelayMs(110);
-        SHT3X_ReadMeasurementBuffer();
-        // SHT3X_GetTempAndHumiClkStretch(REPEATAB_LOW);
+        SHT3X_ReadMeasurementBuffer(addr, channel);
+        // SHT3X_GetTempAndHumiClkStretch(REPEATAB_LOW, addr, channel);
 
     }
-    // SHT3X_StartPeriodicMeasurment(REPEATAB_LOW, FREQUENCY_HZ1);
-    SHT3X_StartPeriodicMeasurment(REPEATAB_HIGH, FREQUENCY_10HZ);
+    // SHT3X_StartPeriodicMeasurment(REPEATAB_LOW, FREQUENCY_HZ1, addr, channel);
+    SHT3X_StartPeriodicMeasurment(REPEATAB_HIGH, FREQUENCY_10HZ, addr, channel);
 }
 
+// todo: not tested
 
 // void main()
 // {
-//     SHT3X_InitBegin();
+//     SHT3X_InitBegin(addr, channel);
 //     while(1)
 //     {
-//         SHT3X_ReadMeasurementBuffer();
+//         SHT3X_ReadMeasurementBuffer(addr, channel);
 //         UartSendStr("\r\nHT: ");
 //         UartSendStr(TemperatureStr);
 //         UartSendStr(" - ");
@@ -319,38 +334,38 @@ void SHT3X_InitBegin(void)
 //     }
 // }
 
-    // // declare 5byte group, last with '\0' for show
-    // uint8_t Temperature[5] = {0, 0, '.', 0};
-    // uint8_t Humidity[5] = {0, 0, '.', 0};
-    // uint8_t TemperatureStr[5] = {0, 0, '.', 0};
-    // uint8_t HumidityStr[5] = {0, 0, '.', 0};
-    // uint8_t temperatureHexI = 0;    // integer
-    // uint8_t temperatureHexD = 0;    // decimal
-    // uint8_t humidityHexI = 0;
-    // uint8_t humidityHexD = 0;
-    // temperature = ((uint8_t)decTempValue << 8) + ((uint16_t)(decTempValue * 100) % 100);
-    // humidity = ((uint8_t)decHumiValue << 8) + ((uint16_t)(decHumiValue * 100) % 100);
-
-    // temperatureHexI = temperature >> 8;
-    // temperatureHexD = temperature;
-    // humidityHexI = humidity >> 8;
-    // humidityHexD = humidity;
-    // // todo higher than 100 or below 0
-    // // todo only get origin data, do not change type here
-    // // todo AHT20 deal the same, and change I2C function to standard
-    // // if()
-    // Temperature[0] = temperatureHexI / 10;
-    // Temperature[1] = temperatureHexI % 10;
-    // Temperature[3] = temperatureHexD / 10;
-    // Humidity[0] = humidityHexI / 10;
-    // Humidity[1] = humidityHexI % 10;
-    // Humidity[3] = humidityHexD / 10;
-    // TemperatureStr[0] = Temperature[0] + '0';
-    // TemperatureStr[1] = Temperature[1] + '0';
-    // TemperatureStr[3] = Temperature[3] + '0';
-    // HumidityStr[0] = Humidity[0] + '0';
-    // HumidityStr[1] = Humidity[1] + '0';
-    // HumidityStr[3] = Humidity[3] + '0';
+// // declare 5byte group, last with '\0' for show
+// uint8_t Temperature[5] = {0, 0, '.', 0};
+// uint8_t Humidity[5] = {0, 0, '.', 0};
+// uint8_t TemperatureStr[5] = {0, 0, '.', 0};
+// uint8_t HumidityStr[5] = {0, 0, '.', 0};
+// uint8_t temperatureHexI = 0;    // integer
+// uint8_t temperatureHexD = 0;    // decimal
+// uint8_t humidityHexI = 0;
+// uint8_t humidityHexD = 0;
+// temperature = ((uint8_t)decTempValue << 8) + ((uint16_t)(decTempValue * 100) % 100);
+// humidity = ((uint8_t)decHumiValue << 8) + ((uint16_t)(decHumiValue * 100) % 100);
+
+// temperatureHexI = temperature >> 8;
+// temperatureHexD = temperature;
+// humidityHexI = humidity >> 8;
+// humidityHexD = humidity;
+// // todo higher than 100 or below 0
+// // todo only get origin data, do not change type here
+// // todo AHT20 deal the same, and change I2C function to standard
+// // if()
+// Temperature[0] = temperatureHexI / 10;
+// Temperature[1] = temperatureHexI % 10;
+// Temperature[3] = temperatureHexD / 10;
+// Humidity[0] = humidityHexI / 10;
+// Humidity[1] = humidityHexI % 10;
+// Humidity[3] = humidityHexD / 10;
+// TemperatureStr[0] = Temperature[0] + '0';
+// TemperatureStr[1] = Temperature[1] + '0';
+// TemperatureStr[3] = Temperature[3] + '0';
+// HumidityStr[0] = Humidity[0] + '0';
+// HumidityStr[1] = Humidity[1] + '0';
+// HumidityStr[3] = Humidity[3] + '0';
 
 
 

SHT3X_ATY.h

@@ -22,6 +22,8 @@
 * @version
 *       - 1_01_200318 > ATY
 *           -# Preliminary version, first Release
+*       - 1_02_231229 > ATY
+*           -# add multy addr and channel
 ********************************************************************************
 */
 
@@ -33,7 +35,11 @@
 #include "HW_I2C_ATY.h"
 
 /******************************* For user *************************************/
-#define SHT3X_ADDR 0x44
+#define SHT3X_P_ADDR 0
+#define SHT3X_ADDR (0x44 | SHT3X_P_ADDR)
+// #define __DEBUG_SHT3X_ATY
+// #define SHT3X_I2C I2C_C1
+
 extern uint8_t Temperature[5];
 extern uint8_t Humidity[5];
 extern uint8_t TemperatureStr[5];
@@ -110,8 +116,8 @@ typedef enum{
 }sht3xFrequency;
 
 
-void SHT3X_InitBegin(void);
-void SHT3X_ReadMeasurementBuffer(void);
+void SHT3X_InitBegin(uint8_t addr, uint8_t channel);
+void SHT3X_ReadMeasurementBuffer(uint8_t addr, uint8_t channel);
 
 
 #endif /* __SHT3X_ATY_H */

TM7707_ATY.c

@@ -301,6 +301,7 @@ void TM7707_Test(void)
         TM7707_VoltageCalc(1.2093, tm7707Data24Temp));
     printf("\r\n");
 }
+// todo: not tested
 
 
 #endif /* __TM7707_ATY_C */

TMC2209_ATY.c

@@ -0,0 +1,355 @@
+/**
+* @file TMC2209_ATY.c
+*
+* @param Project DEVICE_GENERAL_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of SteppingMotor control
+*
+* @version
+*       - 1_01_221231 > ATY
+*           -# Preliminary version, first Release
+*       - 1_02_230408 > ATY
+*           -# Add State Machine and so
+*       - 1_03_230426 > ATY
+*           -# Change name "SteppingMotor_ATY" to "TMC2209_ATY"
+*       - 1_01_240111 > ATY
+*           -# add multy addr and channel
+*           -# add lock
+*       - 1_01_240112 > ATY
+*           -# change name from MOTOR_STEP to TMC2209
+********************************************************************************
+*/
+
+#ifndef __TMC2209_ATY_C
+#define __TMC2209_ATY_C
+
+#include "TMC2209_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+/**
+ * @brief   set motor enable or disbale
+ *
+ * @param   enable 0 for disable, 1 for enable
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t TMC2209_SetAble(uint8_t en, struct TMC2209_ATY_Dev* dev)
+{
+    __ATY_LOCK(dev);
+    dev->motorEn = en;
+    if(en){ dev->enSet(_ATY_HL_L); }
+    else{ dev->enSet(_ATY_HL_H); }
+    __ATY_UNLOCK(dev);
+    return 0;
+}
+
+/**
+ * @brief   set motor direction
+ *
+ * @param   dir 0 for forward, 1 for reversal
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t TMC2209_SetDirection(uint8_t dir, struct TMC2209_ATY_Dev* dev)
+{
+    __ATY_LOCK(dev);
+    dev->motorDir = dir;
+    if(dir){ dev->dirSet(_ATY_HL_H); }
+    else{ dev->dirSet(_ATY_HL_L); }
+    __ATY_UNLOCK(dev);
+    return 0;
+}
+
+/**
+ * @brief   get TMC2209 diag pin voltage level
+ *
+ * @param   dev
+ * @return  uint8_t 0 for low, 1 fo high
+ * @return  uint8_t
+ */
+uint8_t TMC2209_GetDiagLevel(struct TMC2209_ATY_Dev* dev)
+{
+    __ATY_LOCK(dev);
+    dev->motorDiag = dev->diagGet();
+    __ATY_UNLOCK(dev);
+    return dev->motorDiag;
+}
+
+
+/**
+ * @brief   start motor with direction set
+ *
+ * @param   dir direction to move
+ * @param   speed direction to move
+ * @param   dev
+ */
+void TMC2209_Start(uint8_t dir, uint32_t speed, struct TMC2209_ATY_Dev* dev)
+{
+    TMC2209_SetDirection(dir, dev);
+    TMC2209_SetAble(1, dev);
+    dev->freqSet(speed);
+}
+
+/**
+ * @brief   stop motor
+ *
+ * @param   dev
+ */
+void TMC2209_Stop(struct TMC2209_ATY_Dev* dev)
+{
+    // TMC2209_PARAM_SET(0, 0, 0, 0, 0, 0, dev);
+    if(dev->motorEn == 0)
+        return;
+    else{
+        dev->freqSet(0);
+        TMC2209_SetAble(0, dev);
+        dev->motorSpeedCounter = 0;
+        dev->motorStopCounter = 0;
+    }
+}
+
+/**
+ * @brief   process motor error
+ *
+ * @param   dev
+ * @note    put at 1ms cycle
+ */
+void MotorSelfCycle(struct TMC2209_ATY_Dev* dev)
+{
+    if(TMC2209_GetDiagLevel(dev)){
+        if(dev->motorEn == 1)
+            TMC2209_SetAble(0, dev);
+        if(dev->motorStopCounter >= 10000)
+            TMC2209_SetAble(1, dev);
+    }
+}
+
+
+/**
+ * @brief   deal step motor state
+ *
+ * @param   dev
+ * @note    put at 1ms cycle;
+ *          set motorSetState = 4 to change motor dir with speed no changed
+ *          set motorSetState = 3 to start motor directly, motorSoftSteps need to be 0
+ *          set motorSetState = 2 to strat motor with soft, motorDir/motorSoftSpeed/motorSpeed/motorSoftSteps/motorSteps need to be set
+ *          set motorSetState = 0 to stop motor flow
+ *          set motorSetState = 10 to scram motor
+ *          when motorSetState = 5 means last cycle finished, set others to start a new cycle
+ *          when motorSetState = 1 means motor running and state not changing
+ */
+void TMC2209_StateMachine_PWM(struct TMC2209_ATY_Dev* dev)
+{
+    if(dev->motorSoftSpeed < dev->motorSpeed)
+        dev->motorSoftSpeed = dev->motorSpeed;
+
+    if(dev->motorSetState == TMC2209_SET_REVERSE){
+        dev->motorStopCounter = 0;
+        dev->motorStepCounter = 0;
+        dev->motorSetState = TMC2209_SET_START_SOFT;
+        dev->motorDir = !dev->motorDir;
+    }
+    else if(dev->motorSetState == TMC2209_SET_START_DIRECTLY){
+        dev->motorStepCounter = dev->motorSoftSteps;
+        TMC2209_Start(dev->motorDir, dev->motorSpeed, dev);
+        dev->motorSetState = TMC2209_SET_RUNNING;
+    }
+    else if(dev->motorSetState == TMC2209_SET_START_SOFT){
+        dev->motorStepCounter = 0;
+        TMC2209_Start(dev->motorDir, dev->motorSoftSpeed, dev);
+        dev->motorSetState = TMC2209_SET_RUNNING;
+    }
+    else if(dev->motorSetState == TMC2209_SET_RUNNING){
+        if(dev->motorStepCounter < dev->motorSoftSteps){
+            if(dev->lineProType == 'T'){
+                dev->speedIncreaseStep = ((float)(dev->motorSoftSpeed - dev->motorSpeed) / (float)dev->motorSoftSteps);  // at 1ms cycle
+                TMC2209_Start(dev->motorDir,
+                    dev->motorSpeed < (dev->motorSoftSpeed - (dev->speedIncreaseStep * dev->motorStepCounter)) ?
+                    (dev->motorSoftSpeed - (dev->speedIncreaseStep * dev->motorStepCounter)) : dev->motorSpeed, dev);
+            }
+            else if(dev->lineProType == 'S'){
+                // S line: y = ax^3 + cx, a in 0-1, c >= 0, lower c cause lower increase at start or end, c for users
+                float S_param_A = (((float)(dev->motorSoftSpeed - dev->motorSpeed) / 2)
+                    - (dev->lineProParam * (float)((float)dev->motorSoftSteps / 2) * (float)((float)dev->motorSoftSteps / 2) / 2))
+                    / ((float)((float)dev->motorSoftSteps / 2) * (float)((float)dev->motorSoftSteps / 2)
+                        * (float)((float)dev->motorSoftSteps / 2) * (float)((float)dev->motorSoftSteps / 2)) * 4;
+                // mbG[27] = S_param_A * 10000000;
+                if(dev->motorStepCounter < (dev->motorSoftSteps / 2))
+                    dev->speedIncreaseStep =
+                    ((float)(S_param_A * dev->motorStepCounter * dev->motorStepCounter * dev->motorStepCounter * dev->motorStepCounter) / 4)
+                    + ((float)(dev->lineProParam * dev->motorStepCounter * dev->motorStepCounter) / 2);
+                // (S_param_A * dev->motorStepCounter * dev->motorStepCounter * dev->motorStepCounter)
+                // + (lineProParam * dev->motorStepCounter);
+                else
+                    dev->speedIncreaseStep =
+                    (float)((float)(dev->motorSoftSpeed - dev->motorSpeed) / 2)
+                    + ((float)(S_param_A * dev->motorSoftSteps * dev->motorSoftSteps * dev->motorSoftSteps * dev->motorSoftSteps) / 64)
+                    + ((float)(dev->lineProParam * dev->motorSoftSteps * dev->motorSoftSteps) / 8)
+                    - ((float)(S_param_A * (dev->motorSoftSteps - dev->motorStepCounter) * (dev->motorSoftSteps - dev->motorStepCounter)
+                        * (dev->motorSoftSteps - dev->motorStepCounter) * (dev->motorSoftSteps - dev->motorStepCounter)) / 4)
+                    - ((float)(dev->lineProParam * (dev->motorSoftSteps - dev->motorStepCounter) * (dev->motorSoftSteps - dev->motorStepCounter)) / 2);
+                    // 0
+                    // - (S_param_A * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps)
+                    //     * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps)
+                    //     * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps))
+                    // - (dev->lineProParam * (float)((float)dev->motorStepCounter - (float)dev->motorSoftSteps));
+                TMC2209_Start(dev->motorDir,
+                    dev->motorSpeed < (dev->motorSoftSpeed - dev->speedIncreaseStep) ?
+                    (dev->motorSoftSpeed - dev->speedIncreaseStep) : dev->motorSpeed, dev);
+            }
+            else if(dev->lineProType == '2'){}
+        }
+
+        if(dev->motorStepCounter == dev->motorSoftSteps)
+            dev->motorSetState = TMC2209_SET_START_DIRECTLY;
+        else if(dev->motorStepCounter >= (dev->motorSoftSteps + dev->motorSteps))
+            dev->motorSetState = TMC2209_SET_FINISHED;
+    }
+    else if(dev->motorSetState == TMC2209_SET_SCRAM){
+        TMC2209_Stop(dev);
+        dev->motorSetState = TMC2209_SET_STOP;
+    }
+    else{ TMC2209_Stop(dev); }    // 5 0
+
+    if(dev->motorEn == 0){
+        dev->motorStepCounter = 0;
+        dev->motorStopCounter++;
+    }
+    else{
+        dev->motorStepCounter++;
+        dev->motorStopCounter = 0;
+    }
+}
+
+#endif /* __TMC2209_ATY_C */
+
+/************************************ etc *************************************/
+/* init */
+// void MOTOR_1_EN_SET(uint8_t level) {
+//     if(level == _ATY_HL_L)
+//         GPIO_SET_L(STEP_MOTOR_EN_GPIO_Port, STEP_MOTOR_EN_Pin);
+//     else if(level == _ATY_HL_H)
+//         GPIO_SET_H(STEP_MOTOR_EN_GPIO_Port, STEP_MOTOR_EN_Pin);
+// }
+// void MOTOR_1_DIR_SET(uint8_t level) {
+//     if(level == _ATY_HL_L)
+//         GPIO_SET_L(STEP_MOTOR_DIR_GPIO_Port, STEP_MOTOR_DIR_Pin);
+//     else if(level == _ATY_HL_H)
+//         GPIO_SET_H(STEP_MOTOR_DIR_GPIO_Port, STEP_MOTOR_DIR_Pin);
+// }
+// void MOTOR_1_DIAG_GET(void) { }
+// void MOTOR_1_FREQ_SET(uint16_t freq) {
+//     HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_3);
+//     __HAL_TIM_SET_AUTORELOAD(&htim3, freq);
+//     __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_3, (uint16_t)(freq * 0.5f));
+//     HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);
+// }
+// struct TMC2209_ATY_Dev TMC2209_ATY_Dev_1 = {
+//     .id = 'M',
+
+//     .motorEn = 0,
+//     .motorDir = 0,
+//     .motorStepLevel = 0,
+//     .motorDiag = 0,
+
+//     .motorSoftSpeed = 0,
+//     .motorSpeed = 0,
+//     .motorSpeedCounter = 0,
+
+//     .motorSoftSteps = 0,
+//     .motorSteps = 0,
+//     .motorStepCounter = 0,
+
+//     .motorStopCounter = 0,
+
+//     .motorSetState = 0,
+
+//     .speedIncreaseStep = 0,
+//     .lineProType = 'T',
+//     .lineProParam = TMC2209_S_PARAM_C,
+
+//     .enSet = MOTOR_1_EN_SET,
+//     .dirSet = MOTOR_1_DIR_SET,
+//     .diagGet = MOTOR_1_DIAG_GET,
+
+//     .freqSet = MOTOR_1_FREQ_SET,
+
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+
+
+
+// SetMotorDefault(&TMC2209_ATY_Dev_1){
+//     TMC2209_PARAM_SET(
+//         (uint8_t)mbP_TMC2209_DIR,
+//         (uint32_t)mbP_TMC2209_SOFT_SPEED,
+//         (uint32_t)mbP_TMC2209_RUN_SPEED,
+//         (uint32_t)mbP_TMC2209_SOFT_TIME,
+//         (uint32_t)mbP_TMC2209_RUN_TIME,
+//         (uint8_t)mbP_TMC2209_SET_STATE,
+//         dev);
+//     HAL_GPIO_WritePin(STEP_MOTOR_DIR_GPIO_Port, STEP_MOTOR_DIR_Pin, GPIO_PIN_RESET);
+//     HAL_GPIO_WritePin(STEP_MOTOR_EN_GPIO_Port, STEP_MOTOR_EN_Pin, GPIO_PIN_SET);
+// }
+// HAL_TIM_Base_Start(&htim3);
+// __HAL_TIM_SET_AUTORELOAD(&htim3, STEP_MOTOR_PARAM_RUN_SPEED);
+// __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_3, 0);
+// HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);
+
+/* use */
+// // in 1ms loop
+// StepMotorProcess();
+// TMC2209_StateMachine_PWM(&TMC2209_ATY_Dev_1);
+// TMC2209_PARAM_GET(
+//     mbP_TMC2209_DIR,
+//     mbP_TMC2209_SOFT_SPEED,
+//     mbP_TMC2209_RUN_SPEED,
+//     mbP_TMC2209_SOFT_TIME,
+//     mbP_TMC2209_RUN_TIME,
+//     mbP_TMC2209_SET_STATE,
+//     TMC2209_ATY_Dev_1);
+
+// // uart change(in uart process)
+// TMC2209_PARAM_SET(
+//     (uint8_t)mbP_TMC2209_DIR,
+//     (uint32_t)mbP_TMC2209_SOFT_SPEED,
+//     (uint32_t)mbP_TMC2209_RUN_SPEED,
+//     (uint32_t)mbP_TMC2209_SOFT_TIME,
+//     (uint32_t)mbP_TMC2209_RUN_TIME,
+//     (uint8_t)mbP_TMC2209_SET_STATE,
+//     (&TMC2209_ATY_Dev_1));
+
+// // set state or others to use
+// if((uint8_t)mbP_TMC2209_FAST_CMD == STEP_MOTOR_CMD_SCRAM){
+//     mbP_TMC2209_SET_STATE = TMC2209_SET_SCRAM;
+// }
+// else if((uint8_t)mbP_TMC2209_FAST_CMD == STEP_MOTOR_CMD_UP){
+//     mbP_TMC2209_DIR = STEP_MOTOR_PARAM_DIR_UP;
+//     mbP_TMC2209_SET_STATE = TMC2209_SET_START_SOFT;
+// }
+// else if((uint8_t)mbP_TMC2209_FAST_CMD == STEP_MOTOR_CMD_DOWN){
+//     mbP_TMC2209_DIR = STEP_MOTOR_PARAM_DIR_DOWN;
+//     mbP_TMC2209_SET_STATE = TMC2209_SET_START_SOFT;
+// }
+
+/******************************************************************************/
+
+/******************************** End Of File *********************************/

TMC2209_ATY.h

@@ -0,0 +1,124 @@
+/**
+* @file TMC2209_ATY.h
+*
+* @param Project DEVICE_GENERAL_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of SteppingMotor control
+*
+* @version
+*       - 1_01_221231 > ATY
+*           -# Preliminary version, first Release
+*       - 1_02_230408 > ATY
+*           -# Add State Machine and so
+*       - 1_03_230426 > ATY
+*           -# Change name "SteppingMotor_ATY" to "TMC2209_ATY"
+*       - 1_01_240111 > ATY
+*           -# add multy addr and channel
+*           -# add lock
+********************************************************************************
+*/
+
+#ifndef __TMC2209_ATY_H
+#define __TMC2209_ATY_H
+
+#include "INCLUDE_ATY.h"
+
+/******************************* For user *************************************/
+/* set step pin vol level when motor is not enable  */
+// #define STATIC_STEP_LEVEL 0
+/******************************************************************************/
+
+struct TMC2209_ATY_Dev
+{
+    uint8_t id;
+
+    uint8_t motorEn;
+    uint8_t motorDir;
+    uint8_t motorDiag;
+
+    uint32_t motorSoftSpeed;
+    uint32_t motorSpeed;
+    uint32_t motorSpeedCounter;
+
+    uint32_t motorSoftSteps;
+    uint32_t motorSteps;
+    uint32_t motorStepCounter;
+
+    uint32_t motorStopCounter;      // delay for stall detection or driver error(TMC2209)
+
+    uint8_t motorSetState;          // 0: stop, 1: start hold, 2: start soft, 3: run speed, 4: change dir, 5: stop state, soft set 0 after use, 10: scram motor
+
+    float speedIncreaseStep;
+    float lineProParam;
+    uint8_t lineProType;
+
+    void (*enSet)(uint8_t level);
+    void (*dirSet)(uint8_t level);
+    uint8_t (*diagGet)();
+
+    void (*freqSet)(uint16_t freq);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    void (*LOG)();
+};
+
+
+#define TMC2209_PARAM_SET(dir, softSpeed, speed, softSteps, steps, setState, dev) \
+    do \
+    { \
+        dev->motorDir = (uint8_t)dir; \
+        dev->motorSoftSpeed = (uint32_t)softSpeed; \
+        dev->motorSpeed = (uint32_t)speed; \
+        dev->motorSoftSteps = (uint32_t)softSteps; \
+        dev->motorSteps = (uint32_t)steps; \
+        dev->motorSetState = (uint8_t)setState; \
+    } while(0)
+
+#define TMC2209_PARAM_GET(dir, softSpeed, speed, softSteps, steps, setState, dev) \
+    do \
+    { \
+        dir = dev.motorDir; \
+        softSpeed = dev.motorSoftSpeed; \
+        speed = dev.motorSpeed; \
+        softSteps = dev.motorSoftSteps; \
+        steps = dev.motorSteps; \
+        setState = dev.motorSetState; \
+    } while(0)
+
+
+uint8_t TMC2209_SetAble(uint8_t enable, struct TMC2209_ATY_Dev *dev);
+uint8_t TMC2209_SetDirection(uint8_t dir, struct TMC2209_ATY_Dev *dev);
+uint8_t TMC2209_GetDiagLevel(struct TMC2209_ATY_Dev *dev);
+
+void TMC2209_Start(uint8_t dir, uint32_t speed, struct TMC2209_ATY_Dev *dev);
+void TMC2209_Stop(struct TMC2209_ATY_Dev *dev);
+void TMC2209_StateMachine_PWM(struct TMC2209_ATY_Dev *dev);
+
+#define TMC2209_SET_REVERSE             4
+#define TMC2209_SET_START_DIRECTLY      3
+#define TMC2209_SET_START_SOFT          2
+#define TMC2209_SET_STOP                0
+#define TMC2209_SET_SCRAM               10
+#define TMC2209_SET_FINISHED            5
+#define TMC2209_SET_RUNNING             1
+
+/* for motor soft start  */
+#define TMC2209_S_PARAM_C               0.5f      // 0-1
+
+#endif /* __TMC2209_ATY_H */
+
+/******************************** End Of File *********************************/

VL6180X_ATY.c

@@ -0,0 +1,599 @@
+/**
+* @file VL6180X_ATY.c
+*
+* @param Project DEVICE_GENERAL_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of VL6180 for all embedded device
+*
+* @version
+*       - 1_01_231228 > ATY
+*           -# Preliminary version, first Release
+*       - 1_01_240104 > ATY
+*           -# base tested VL6180
+*       - 1_01_240111 > ATY
+*           -# add lock
+********************************************************************************
+*/
+
+#ifndef __VL6180X_ATY_C
+#define __VL6180X_ATY_C
+
+#include "VL6180X_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+/**
+ * @brief
+ *
+ * @param   reg
+ * @param   data
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_WriteByte(uint16_t reg, uint8_t data, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t groupRegData[3], errCode = 0;
+    __ATY_LOCK(dev);
+    groupRegData[0] = (reg >> 8) & 0xFF;    // MSB of register address
+    groupRegData[1] = reg & 0xFF;           // LSB of register address
+    groupRegData[2] = data & 0xFF;
+    errCode = dev->i2cProcess(dev->addr, groupRegData, 3, _ATY_RW_W);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   reg
+ * @param   data
+ * @param   bytes num to write
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_WriteBytes(uint16_t reg, uint8_t* data, uint8_t bytes, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t groupRegData[3], i = 0, errCode = 0;
+    __ATY_LOCK(dev);
+    groupRegData[0] = (reg >> 8) & 0xFF;    // MSB of register address
+    groupRegData[1] = reg & 0xFF;           // LSB of register address
+    for(i = 0; i < bytes; i++)
+        groupRegData[2 + i] = data[i] & 0xFF;
+    errCode = dev->i2cProcess(dev->addr, groupRegData, 2 + bytes, _ATY_RW_W);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   reg
+ * @param   data
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_ReadByte(uint16_t reg, uint8_t* data, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t groupReg[2], errCode = 0;
+    __ATY_LOCK(dev);
+    groupReg[0] = (reg >> 8) & 0xFF;            // MSB of register address
+    groupReg[1] = reg & 0xFF;                   // LSB of register address
+    errCode = dev->i2cProcess(dev->addr, groupReg, 2, _ATY_RW_W);
+    if(errCode){ __ATY_UNLOCK(dev); return errCode; }
+    errCode = dev->i2cProcess(dev->addr, data, 1, _ATY_RW_R);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   reg
+ * @param   data
+ * @param   bytes num to read
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_ReadBytes(uint16_t reg, uint8_t* data, uint8_t bytes, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t groupReg[2], errCode = 0;
+    __ATY_LOCK(dev);
+    groupReg[0] = (reg >> 8) & 0xFF;        // MSB of register address
+    groupReg[1] = reg & 0xFF;               // LSB of register address
+    errCode = dev->i2cProcess(dev->addr, groupReg, 2, _ATY_RW_W);
+    if(errCode){ __ATY_UNLOCK(dev); return errCode; }
+    errCode = dev->i2cProcess(dev->addr, data, bytes, _ATY_RW_R);
+    __ATY_UNLOCK(dev);
+    return errCode;
+}
+
+/**
+ * @brief   get ids
+ *
+ * @param   id need 9 size array
+ * @param   dev device
+ * @return  uint8_t
+ */
+uint8_t VL6180X_GetId(uint8_t* id, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    errCode = 0x00 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_MODEL_ID, &id[0], dev);
+    errCode = 0x10 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_MODEL_REV_MAJOR, &id[1], dev);
+    errCode = 0x20 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_MODEL_REV_MINOR, &id[2], dev);
+    errCode = 0x30 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_MODULE_REV_MAJOR, &id[3], dev);
+    errCode = 0x40 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_MODULE_REV_MINOR, &id[4], dev);
+    errCode = 0x50 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_DATE_HI, &id[5], dev);
+    errCode = 0x60 & VL6180X_ReadByte(VL6180X_REG_IDENTIFICATION_DATE_LO, &id[6], dev);
+    errCode = 0x70 & VL6180X_ReadBytes(VL6180X_REG_IDENTIFICATION_TIME, &id[7], 2, dev);
+
+    if(dev->debugEnable == 1){
+        uint8_t i = 0;
+        for(i = 0; i < 9; i++)
+            dev->LOG("%02X ", id[i]);
+        dev->LOG("\r\n");
+    }
+    if(id[0] != 0x84){ return 0x81; }
+    return errCode;
+}
+
+/**
+ * @brief   set offset
+ *
+ * @param   offset
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_SetOffset(uint8_t offset, struct VL6180X_ATY_Dev* dev)
+{
+    return VL6180X_WriteByte(VL6180X_REG_SYSRANGE_PART_TO_PART_RANGE_OFFSET, offset, dev);
+}
+
+/**
+ * @brief   write new addr
+ *
+ * @param   newAddr
+ * @param   dev
+ * @note    not real tested
+ * @return  uint8_t
+ */
+uint8_t VL6180X_SetAddress(uint8_t newAddr, struct VL6180X_ATY_Dev* dev)
+{
+    if(VL6180X_WriteByte(VL6180X_REG_SLAVE_DEVICE_ADDRESS, newAddr & 0x7F, dev) == 1)
+        return 1;
+    dev->addr = newAddr;
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_ClearInterrupts(struct VL6180X_ATY_Dev* dev)
+{
+    if(VL6180X_WriteByte(VL6180X_REG_SYSTEM_INTERRUPT_CLEAR, 0x07, dev) == 1)
+        return 1;
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @return  uint8_t 1 for ready
+ */
+uint8_t VL6180X_IsDeviceReady(struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t byte = 0;
+    if(VL6180X_ReadByte(VL6180X_REG_RESULT_INTERRUPT_STATUS_GPIO, &byte, dev) == 1)
+        return 2;
+    if((byte & 0x01))
+        return 1;
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @return  uint8_t 1 for ready
+ */
+uint8_t VL6180X_WaitDeviceReady(struct VL6180X_ATY_Dev* dev)
+{
+    uint16_t errCount = 0;
+    while(VL6180X_IsDeviceReady(dev) != 1){
+        errCount++;
+        if(errCount > 100) return 2;
+    }
+    return 1;
+}
+
+/**
+ * @brief
+ *
+ * @return  uint8_t 1 for complete
+ */
+uint8_t VL6180X_IsRangeComplete(struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t status = 0;
+    if(VL6180X_ReadByte(VL6180X_REG_RESULT_INTERRUPT_STATUS_GPIO, &status, dev) == 1)
+        return 2;
+    status &= 0x07;
+    if((status & 0x04))
+        return 1;
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @return  uint8_t 1 for complete
+ */
+uint8_t VL6180X_WaitRangeComplete(struct VL6180X_ATY_Dev* dev)
+{
+    uint16_t errCount = 0;
+    while(VL6180X_IsRangeComplete(dev) != 1){
+        errCount++;
+        if(errCount > 100) return 2;
+    }
+    return 1;
+}
+
+/**
+ * @brief   request ranging success/error message (retreive after ranging)
+ *
+ * @param   value
+ * @param   dev
+ * @return  uint8_t one of possible VL6180X_ERROR_* values
+ */
+uint8_t VL6180X_ReadRangeStatus(uint8_t* status, struct VL6180X_ATY_Dev* dev)
+{
+    if(VL6180X_ReadByte(VL6180X_REG_RESULT_RANGE_STATUS, status, dev) == 1)
+        return 1;
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   dev
+ * @return  uint8_t
+ * @note    Return results of read reqyest also clears out the interrupt
+            Be sure to check the return of {@link readRangeStatus} to before using
+            the return value!
+ */
+uint8_t VL6180X_ReadRangeResult(uint8_t* range, struct VL6180X_ATY_Dev* dev)
+{
+    if(VL6180X_ReadByte(VL6180X_REG_RESULT_RANGE_VAL, range, dev) == 1)
+        return 1;
+    if(dev->debugEnable == 1)
+        dev->LOG("%d\r\n", *range);
+    return 0;
+}
+
+/**
+ * @brief
+ *
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_StartRange(struct VL6180X_ATY_Dev* dev)
+{
+    if(VL6180X_WriteByte(VL6180X_REG_SYSRANGE_START, 0x01, dev) == 1)
+        return 1;
+    return 0;
+}
+
+/**
+ * @brief   start continuous ranging
+ *
+ * @param   period_msOptional Period between ranges in ms.
+            Values will be rounded down to 10ms units with minimum of 10ms.
+            Default is 50
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_StartRangeContinuous(uint16_t period_ms, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t period_reg = 0;
+    if(period_ms > 10) {
+        if(period_ms < 2550)
+            period_reg = (period_ms / 10) - 1;
+        else
+            period_reg = 254;
+    }
+    // Set ranging inter-measurement
+    if(VL6180X_WriteByte(SYSRANGE__INTERMEASUREMENT_PERIOD, period_reg, dev) == 1)
+        return 1;
+    // Start a continuous range measurement
+    if(VL6180X_WriteByte(VL6180X_REG_SYSRANGE_START, 0x03, dev) == 1)
+        return 1;
+    return 0;
+}
+
+/**
+ * @brief   stop continuous range operation
+ *
+ * @param   dev
+ * @return  uint8_t
+ * @note    stop the continuous range operation, by setting the range register
+            back to 1, Page 7 of appication notes
+ */
+uint8_t VL6180X_StopRangeContinuous(struct VL6180X_ATY_Dev* dev)
+{
+    if(VL6180X_WriteByte(VL6180X_REG_SYSRANGE_START, 0x01, dev) == 1)
+        return 1;
+    return 0;
+}
+
+
+/**
+ * @brief   initializes I2C interface, checks that VL6180X is found and resets chip
+ *
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_Init(struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t reset;
+    if(VL6180X_ReadByte(VL6180X_REG_SYSTEM_FRESH_OUT_OF_RESET, &reset, dev) == 1)
+        return 1;
+    // check to see has it be Initialised already
+    if(reset == 1){
+        if(VL6180X_Config(dev))
+            return 3;
+        //change fresh out of set status to 0
+        if(VL6180X_WriteByte(VL6180X_REG_SYSTEM_FRESH_OUT_OF_RESET, 0x00, dev) == 1)
+            return 2;
+    }
+    return 0;
+}
+
+
+/**
+ * @brief
+ *
+ * @param   range
+ * @param   dev
+ * @return  uint8_t distance in millimeters if valid
+ */
+uint8_t VL6180X_MeasureRangeOnce(uint8_t* range, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    errCode = 0x00 & VL6180X_WaitDeviceReady(dev);  // slower
+    errCode = 0x10 & VL6180X_StartRange(dev);
+    errCode = 0x20 & VL6180X_WaitRangeComplete(dev);
+    errCode = 0x30 & VL6180X_ReadRangeResult(range, dev);
+    errCode = 0x40 & VL6180X_ClearInterrupts(dev);
+    return errCode;
+}
+
+/**
+ * @brief
+ *
+ * @param   range
+ * @param   dev
+ * @return  uint8_t distance in millimeters if valid(100ms cycle tested)
+ */
+uint8_t VL6180X_MeasureRangeOnceFast(uint8_t* range, struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    // errCode = 0x00 & VL6180X_WaitDeviceReady(dev);
+    errCode = 0x10 & VL6180X_StartRange(dev);
+    // errCode = 0x10 & VL6180X_StartRangeContinuous(10, dev);
+    errCode = 0x20 & VL6180X_WaitRangeComplete(dev);
+    errCode = 0x30 & VL6180X_ReadRangeResult(range, dev);
+    errCode = 0x40 & VL6180X_ClearInterrupts(dev);
+    return errCode;
+}
+
+
+/**
+ * @brief   single shot lux measurement
+ *
+ * @param   gain gain setting, one of VL6180X_ALS_GAIN_*
+ * @param   lux
+ * @param   dev
+ * @return  uint8_t
+ * @note    only for VL6180X
+ */
+uint8_t VL6180X_ReadLux(uint8_t gain, float* lux, struct VL6180X_ATY_Dev* dev)
+{
+    uint16_t errCount = 0;
+    uint8_t byte = 0;
+
+    if(VL6180X_ReadByte(VL6180X_REG_SYSTEM_INTERRUPT_CONFIG, &byte, dev) == 1)
+        return 1;
+    byte &= ~0x38;
+    byte |= (0x4 << 3); // IRQ on ALS ready
+    if(VL6180X_WriteByte(VL6180X_REG_SYSTEM_INTERRUPT_CONFIG, byte, dev) == 1)
+        return 2;
+
+    // 100 ms integration period
+    if(VL6180X_WriteByte(VL6180X_REG_SYSALS_INTEGRATION_PERIOD_HI, 0, dev) == 1)
+        return 3;
+    if(VL6180X_WriteByte(VL6180X_REG_SYSALS_INTEGRATION_PERIOD_LO, 100, dev) == 1)
+        return 4;
+
+    // analog gain
+    if(gain > VL6180X_ALS_GAIN_40) {
+        gain = VL6180X_ALS_GAIN_40;
+    }
+    if(VL6180X_WriteByte(VL6180X_REG_SYSALS_ANALOGUE_GAIN, 0x40 | gain, dev) == 1)
+        return 5;
+
+    // start ALS
+    if(VL6180X_WriteByte(VL6180X_REG_SYSALS_START, 0x01, dev) == 1)
+        return 6;
+    if(VL6180X_ReadByte(VL6180X_REG_RESULT_INTERRUPT_STATUS_GPIO, &byte, dev) == 1)
+        return 7;
+    // Poll until "New Sample Ready threshold event" is set
+    while(4 != ((byte >> 3) & 0x7)){
+        if(VL6180X_ReadByte(VL6180X_REG_RESULT_INTERRUPT_STATUS_GPIO, &byte, dev) == 1)
+            return 8;
+        errCount++;
+        if(errCount > 1000) return 9;
+    }
+
+    // read lux!
+    uint8_t luxBytes[2] = {0};
+    if(VL6180X_ReadBytes(VL6180X_REG_RESULT_ALS_VAL, luxBytes, 2, dev) == 1)
+        return 10;
+    *lux = ((luxBytes[0] << 8) | luxBytes[1]);
+
+    // clear interrupt
+    if(VL6180X_WriteByte(VL6180X_REG_SYSTEM_INTERRUPT_CLEAR, 0x07, dev) == 1)
+        return 11;
+
+    *lux *= 0.32; // calibrated count/lux
+    switch(gain) {
+        case VL6180X_ALS_GAIN_1:
+            break;
+        case VL6180X_ALS_GAIN_1_25:
+            *lux /= 1.25;
+            break;
+        case VL6180X_ALS_GAIN_1_67:
+            *lux /= 1.67;
+            break;
+        case VL6180X_ALS_GAIN_2_5:
+            *lux /= 2.5;
+            break;
+        case VL6180X_ALS_GAIN_5:
+            *lux /= 5;
+            break;
+        case VL6180X_ALS_GAIN_10:
+            *lux /= 10;
+            break;
+        case VL6180X_ALS_GAIN_20:
+            *lux /= 20;
+            break;
+        case VL6180X_ALS_GAIN_40:
+            *lux /= 40;
+            break;
+    }
+    *lux *= 100;
+    *lux /= 100; // integration time in ms
+
+    return 0;
+}
+
+
+/**
+ * @brief
+ *
+ * @param   dev
+ * @return  uint8_t
+ */
+uint8_t VL6180X_Config(struct VL6180X_ATY_Dev* dev)
+{
+    uint8_t errCode = 0;
+    // Mandatory : private registers
+    errCode = 0x10 & VL6180X_WriteByte(0x0207, 0x01, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0208, 0x01, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0096, 0x00, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0097, 0xfd, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00e3, 0x01, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00e4, 0x03, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00e5, 0x02, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00e6, 0x01, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00e7, 0x03, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00f5, 0x02, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00d9, 0x05, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00db, 0xce, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00dc, 0x03, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00dd, 0xf8, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x009f, 0x00, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00a3, 0x3c, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00b7, 0x00, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00bb, 0x3c, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00b2, 0x09, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00ca, 0x09, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0198, 0x01, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x01b0, 0x17, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x01ad, 0x00, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x00ff, 0x05, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0100, 0x05, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0199, 0x05, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x01a6, 0x1b, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x01ac, 0x3e, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x01a7, 0x1f, dev);
+    errCode = 0x10 & VL6180X_WriteByte(0x0030, 0x00, dev);
+
+    // Recommended : Public registers - See data sheet for more detail
+    errCode = 0x20 & VL6180X_WriteByte(0x0011, 0x10, dev); // Enables polling for "New Sample ready" when measurement completes
+    errCode = 0x20 & VL6180X_WriteByte(0x010a, 0x30, dev); // Set the averaging sample period (compromise between lower noise and increased execution time)
+    errCode = 0x20 & VL6180X_WriteByte(0x003f, 0x46, dev); // Sets the light and dark gain (upper nibble). Dark gain should not be changed.
+    errCode = 0x20 & VL6180X_WriteByte(0x0031, 0xFF, dev); // sets the # of range measurements after which auto calibration of system is performed
+    errCode = 0x20 & VL6180X_WriteByte(0x0041, 0x63, dev); // Set ALS integration time to 100ms
+    errCode = 0x20 & VL6180X_WriteByte(0x002e, 0x01, dev); // perform a single temperature calibration of the ranging sensor
+
+    // Optional: Public registers - See data sheet for more detail
+    errCode = 0x30 & VL6180X_WriteByte(0x001b, 0x09, dev); // Set default ranging inter-measurement period to 100ms
+    errCode = 0x30 & VL6180X_WriteByte(0x003e, 0x31, dev); // Set default ALS inter-measurement period to 500ms
+    errCode = 0x30 & VL6180X_WriteByte(0x0014, 0x24, dev); // Configures interrupt on "New Sample Ready threshold event"
+    return errCode;
+}
+
+#endif /* __VL6180X_ATY_C */
+
+/************************************ etc *************************************/
+/* init */
+// uint8_t VL6180X_1_I2C(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W)
+//         return I2C_Write(addr, data_t, len, &HW_I2C_ATY_Dev_1);
+//     else if(rw == _ATY_RW_R)
+//         return I2C_Read(addr, data_t, len, &HW_I2C_ATY_Dev_1);
+// }
+
+// uint8_t VL6180X_1_I2C(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw){
+//     if(rw == _ATY_RW_W)
+//         return (uint8_t)HAL_I2C_Master_Transmit(&hi2c1, (addr << 1 | 0), data_t, len, 1000);
+//     else if(rw == _ATY_RW_R)
+//         return (uint8_t)HAL_I2C_Master_Receive(&hi2c1, (addr << 1 | 1), data_t, len, 1000);
+// }
+
+// struct VL6180X_ATY_Dev VL6180X_ATY_t_1 = {
+//     .addr = VL6180X_ADDRESS,
+//     .i2cProcess = VL6180X_1_I2C,
+//     .lock = _ATY_UNLOCKED,
+//     .debugEnable = 0,
+//     .LOG = printf
+// };
+
+// VL6180X_Init(&VL6180X_ATY_t_1);
+
+/* use */
+// VL6180X_ATY_t_1.debugEnable = 1;
+
+// uint8_t idGroup[9] = {0};
+// VL6180X_GetId(idGroup, &VL6180X_ATY_t_1);
+
+// VL6180X_SetOffset(10, &VL6180X_ATY_t_1);
+
+// VL6180X_SetAddress(0x10, &VL6180X_ATY_t_1);
+
+// VL6180X_MeasureRangeOnce(&range, &VL6180X_ATY_t_1);
+// VL6180X_MeasureRangeOnceFast(&range, &VL6180X_ATY_t_1);
+// only for VL6180X
+// VL6180X_ReadLux(VL6180X_ALS_GAIN_40, &lux, &VL6180X_ATY_t_1);
+
+// rcPara_t rcParam_VL6180 = {0.028, 0};
+// rcLpFiter(&rcParam_VL6180, value);
+
+/******************************************************************************/
+
+/******************************** End Of File *********************************/

VL6180X_ATY.h

@@ -0,0 +1,170 @@
+/**
+* @file VL6180X_ATY.h
+*
+* @param Project DEVICE_GENERAL_ATY_LIB
+*
+* @author ATY
+*
+* @copyright
+*       - Copyright 2017 - 2023 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.
+*
+* @brief Familiar functions of VL6180 for all embedded device
+*
+* @version
+*       - 1_01_230828 > ATY
+*           -# Preliminary version, first Release
+*       - 1_01_240104 > ATY
+*           -# base tested VL6180
+*       - 1_01_240111 > ATY
+*           -# add lock
+********************************************************************************
+*/
+
+#ifndef __VL6180X_ATY_H
+#define __VL6180X_ATY_H
+
+#include "INCLUDE_ATY.h"
+
+/******************************* For user *************************************/
+// 0 1 0 1 0 0 1 R/W    // can edit by program
+#define VL6180X_ADDRESS (0x29)
+
+/******************************************************************************/
+
+struct VL6180X_ATY_Dev
+{
+    uint8_t addr;
+
+    uint8_t(*i2cProcess)(uint8_t addr, uint8_t* data_t, uint8_t len, uint8_t rw);
+
+    uint8_t lock;
+    uint8_t debugEnable;
+    int (*LOG)();
+};
+
+
+uint8_t VL6180X_WriteByte(uint16_t reg, uint8_t data, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_WriteBytes(uint16_t reg, uint8_t* data, uint8_t bytes, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_ReadByte(uint16_t reg, uint8_t* data, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_ReadBytes(uint16_t reg, uint8_t* data, uint8_t bytes, struct VL6180X_ATY_Dev* dev);
+
+uint8_t VL6180X_GetId(uint8_t* id, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_SetOffset(uint8_t offset, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_SetAddress(uint8_t newAddr, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_Clear_Interrupts(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_IsDeviceReady(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_WaitDeviceReady(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_IsRangeComplete(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_WaitRangeComplete(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_ReadRangeStatus(uint8_t* status, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_ReadRangeResult(uint8_t* range, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_StartRange(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_StartRangeContinuous(uint16_t period_ms, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_StopRangeContinuous(struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_Init(struct VL6180X_ATY_Dev* dev);
+
+uint8_t VL6180X_MeasureRangeOnce(uint8_t* range, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_MeasureRangeOnceFast(uint8_t* range, struct VL6180X_ATY_Dev* dev);
+uint8_t VL6180X_ReadLux(uint8_t gain, float* lux, struct VL6180X_ATY_Dev* dev);
+
+uint8_t VL6180X_Config(struct VL6180X_ATY_Dev* dev);
+
+// device model identification number
+#define VL6180X_REG_IDENTIFICATION_MODEL_ID                 0x000
+#define VL6180X_REG_IDENTIFICATION_MODEL_REV_MAJOR          0x001
+#define VL6180X_REG_IDENTIFICATION_MODEL_REV_MINOR          0x002
+#define VL6180X_REG_IDENTIFICATION_MODULE_REV_MAJOR         0x003
+#define VL6180X_REG_IDENTIFICATION_MODULE_REV_MINOR         0x004
+#define VL6180X_REG_IDENTIFICATION_DATE_HI                  0x006
+#define VL6180X_REG_IDENTIFICATION_DATE_LO                  0x007
+#define VL6180X_REG_IDENTIFICATION_TIME                     0x008 // 8~9
+#define VL6180X_REG_SYSTEM_MODE_GPIO0                       0x010
+#define VL6180X_REG_SYSTEM_MODE_GPIO1                       0x011
+#define VL6180X_REG_SYSTEM_HISTORY_CTRL                     0x012
+#define VL6180X_REG_SYSTEM_INTERRUPT_CONFIG                 0x014
+#define VL6180X_REG_SYSTEM_INTERRUPT_CLEAR                  0x015
+#define VL6180X_REG_SYSTEM_FRESH_OUT_OF_RESET               0x016
+#define VL6180X_REG_SYSTEM_GROUPED_PARAMETER_HOLD           0x017
+#define VL6180X_REG_SYSRANGE_START                          0x018
+#define VL6180X_REG_SYSRANGE_THRESH_HIGH                    0x019
+#define VL6180X_REG_SYSRANGE_THRESH_LOW                     0x01A
+#define VL6180X_REG_SYSRANGE_INTERMEASUREMENT_PERIOD        0x01B
+#define VL6180X_REG_SYSRANGE_MAX_CONVERGENCE_TIME           0x01C
+#define VL6180X_REG_SYSRANGE_CROSSTALK_COMPENSATION_RATE    0x01E
+#define VL6180X_REG_SYSRANGE_CROSSTALK_VALID_HEIGHT         0x021
+#define VL6180X_REG_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE     0x022
+#define VL6180X_REG_SYSRANGE_PART_TO_PART_RANGE_OFFSET      0x024
+#define VL6180X_REG_SYSRANGE_RANGE_IGNORE_VALID_HEIGHT      0x025
+#define VL6180X_REG_SYSRANGE_RANGE_IGNORE_THRESHOLD         0x026
+#define VL6180X_REG_SYSRANGE_MAX_AMBIENT_LEVEL_MULT         0x02C
+#define VL6180X_REG_SYSRANGE_RANGE_CHECK_ENABLES            0x02D
+#define VL6180X_REG_SYSRANGE_VHV_RECALIBRATE                0x02E
+#define VL6180X_REG_SYSRANGE_VHV_REPEAT_RATE                0x031
+#define VL6180X_REG_RESULT_RANGE_STATUS                     0x04D
+#define VL6180X_REG_RESULT_ALS_STATUS                       0x04E
+#define VL6180X_REG_RESULT_INTERRUPT_STATUS_GPIO            0x04F
+#define VL6180X_REG_RESULT_HISTORY_BUFFER_x                 0x052 // 52~60
+#define VL6180X_REG_RESULT_RANGE_VAL                        0x062
+#define VL6180X_REG_RESULT_RANGE_RAW                        0x064
+#define VL6180X_REG_RESULT_RANGE_RETURN_RATE                0x066
+#define VL6180X_REG_RESULT_RANGE_REFERENCE_RATE             0x068
+#define VL6180X_REG_RESULT_RANGE_RETURN_SIGNAL_COUNT        0x06C
+#define VL6180X_REG_RESULT_RANGE_REFERENCE_SIGNAL_COUNT     0x070
+#define VL6180X_REG_RESULT_RANGE_RETURN_AMB_COUNT           0x074
+#define VL6180X_REG_RESULT_RANGE_REFERENCE_AMB_COUNT        0x078
+#define VL6180X_REG_RESULT_RANGE_RETURN_CONV_TIME           0x07C
+#define VL6180X_REG_RESULT_RANGE_REFERENCE_CONV_TIME        0x080
+#define VL6180X_REG_READOUT_AVERAGING_SAMPLE_PERIOD         0x10A
+#define VL6180X_REG_FIRMWARE_BOOTUP                         0x119
+#define VL6180X_REG_SLAVE_DEVICE_ADDRESS                    0x212
+
+// only for VL6180X below reg
+#define VL6180X_REG_SYSALS_START                            0x038
+#define VL6180X_REG_SYSALS_THRESH_HIGH                      0x03A
+#define VL6180X_REG_SYSALS_THRESH_LOW                       0x03C
+#define VL6180X_REG_SYSALS_INTERMEASUREMENT_PERIOD          0x03E
+#define VL6180X_REG_SYSALS_ANALOGUE_GAIN                    0x03F
+#define VL6180X_REG_SYSALS_INTEGRATION_PERIOD_HI            0x040
+#define VL6180X_REG_SYSALS_INTEGRATION_PERIOD_LO            0x041
+#define VL6180X_REG_RESULT_ALS_VAL                          0x050
+#define VL6180X_REG_FIRMWARE_RESULT_SCALER                  0x120
+#define VL6180X_REG_INTERLEAVED_MODE_ENABLE                 0x2A3
+
+
+
+#define VL6180X_ALS_GAIN_1          0x06
+#define VL6180X_ALS_GAIN_1_25       0x05
+#define VL6180X_ALS_GAIN_1_67       0x04
+#define VL6180X_ALS_GAIN_2_5        0x03
+#define VL6180X_ALS_GAIN_5          0x02
+#define VL6180X_ALS_GAIN_10         0x01
+#define VL6180X_ALS_GAIN_20         0x00
+#define VL6180X_ALS_GAIN_40         0x07
+
+#define VL6180X_ERROR_NONE          0   // Success!
+#define VL6180X_ERROR_SYSERR_1      1   // System error
+#define VL6180X_ERROR_SYSERR_5      5   // Sysem error
+#define VL6180X_ERROR_ECEFAIL       6   // Early convergence estimate fail
+#define VL6180X_ERROR_NOCONVERGE    7   // No target detected
+#define VL6180X_ERROR_RANGEIGNORE   8   // Ignore threshold check failed
+#define VL6180X_ERROR_SNR           11  // Ambient conditions too high
+#define VL6180X_ERROR_RAWUFLOW      12  // Raw range algo underflow
+#define VL6180X_ERROR_RAWOFLOW      13  // Raw range algo overflow
+#define VL6180X_ERROR_RANGEUFLOW    14  // Raw range algo underflow
+#define VL6180X_ERROR_RANGEOFLOW    15  // Raw range algo overflow
+
+// Define some additional registers mentioned in application notes and we use
+// period between each measurement when in continuous mode
+#define SYSRANGE__INTERMEASUREMENT_PERIOD 0x001b // P19 application notes
+
+#endif /* __VL6180X_ATY_H */
+
+/******************************** End Of File *********************************/

WS2812_ATY.c

@@ -33,7 +33,7 @@
 
 /******************************************************************************/
 
-#ifdef __STC51_ATY
+#if defined (__STC51_ATY)
 /**
  * @brief   Set IO level for WS2812 bus
  * @param   data_bit Generate buf
@@ -78,8 +78,9 @@ void WS2812_SetBit(uint8_t dataBit)
     }
 }
 #endif /* __STC51_ATY */
+#elif defined (__STM32_HAL_ATY)
 
-#ifdef __ESP8266_ATY
+#elif defined (__ESP8266_ATY)
 #include "HW_SPI_ATY.h"
 /**
  * @brief   Set IO level for WS2812 bus
@@ -95,7 +96,7 @@ void WS2812_SetBit(uint8_t dataBit)
     else
         SPI_Write(0x3F, 1);
 }
-#endif /* __ESP8266_ATY */
+#endif /* PLATFORM */
 
 
 /**
@@ -206,6 +207,7 @@ void WS2812_StyleA(void)
     }
 }
 
+// todo: not tested
 
 //void main()
 //{