from UMA and DIPM

AD7124_ATY.c

@@ -0,0 +1,40 @@
+/**
+* @file AD7124_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 AD7124 for all embedded device
+*
+* @version
+*       - 1_01_230828 > ATY
+*           -# Preliminary version, first Release
+*       - Undone
+********************************************************************************
+*/
+
+#ifndef __AD7124_ATY_C
+#define __AD7124_ATY_C
+
+#include "AD7124_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+
+#endif /* __AD7124_ATY_C */
+
+/******************************** End Of File *********************************/

AD7124_ATY.h

@@ -0,0 +1,323 @@
+/**
+* @file AD7124_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 AD7124 for all embedded device
+*
+* @version
+*       - 1_01_230828 > ATY
+*           -# Preliminary version, first Release
+*       - Undone
+********************************************************************************
+*/
+
+#ifndef __AD7124_ATY_H
+#define __AD7124_ATY_H
+
+#include "INCLUDE_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+/******************* 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
+
+/* 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)
+
+/* 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)
+
+/* 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)
+
+/* 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)
+
+/* 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)
+
+/* 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)
+
+/* 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)
+
+/* ID Register bits */
+#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)
+
+/* Error_En Register bits */
+#define AD7124_ERREN_REG_MCLK_CNT_EN           (1 << 22)
+#define AD7124_ERREN_REG_LDO_CAP_CHK_TEST_EN   (1 << 21)
+#define AD7124_ERREN_REG_LDO_CAP_CHK(x)        (((x) & 0x3) << 19)
+#define AD7124_ERREN_REG_ADC_CAL_ERR_EN        (1 << 18)
+#define AD7124_ERREN_REG_ADC_CONV_ERR_EN       (1 << 17)
+#define AD7124_ERREN_REG_ADC_SAT_ERR_EN        (1 << 16)
+#define AD7124_ERREN_REG_AINP_OV_ERR_EN        (1 << 15)
+#define AD7124_ERREN_REG_AINP_UV_ERR_EN        (1 << 14)
+#define AD7124_ERREN_REG_AINM_OV_ERR_EN        (1 << 13)
+#define AD7124_ERREN_REG_AINM_UV_ERR_EN        (1 << 12)
+#define AD7124_ERREN_REG_REF_DET_ERR_EN        (1 << 11)
+#define AD7124_ERREN_REG_DLDO_PSM_TRIP_TEST_EN (1 << 10)
+#define AD7124_ERREN_REG_DLDO_PSM_ERR_ERR      (1 << 9)
+#define AD7124_ERREN_REG_ALDO_PSM_TRIP_TEST_EN (1 << 8)
+#define AD7124_ERREN_REG_ALDO_PSM_ERR_EN       (1 << 7)
+#define AD7124_ERREN_REG_SPI_IGNORE_ERR_EN     (1 << 6)
+#define AD7124_ERREN_REG_SPI_SCLK_CNT_ERR_EN   (1 << 5)
+#define AD7124_ERREN_REG_SPI_READ_ERR_EN       (1 << 4)
+#define AD7124_ERREN_REG_SPI_WRITE_ERR_EN      (1 << 3)
+#define AD7124_ERREN_REG_SPI_CRC_ERR_EN        (1 << 2)
+#define AD7124_ERREN_REG_MM_CRC_ERR_EN         (1 << 1)
+#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)
+
+/* 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)
+
+/* 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
+};
+
+/******************* AD7124 Constants *****************************************/
+#define AD7124_CRC8_POLYNOMIAL_REPRESENTATION 0x07 /* x8 + x2 + x + 1 */
+#define AD7124_DISABLE_CRC 0
+#define AD7124_USE_CRC 1
+
+#endif /* __AD7124_ATY_H */
+
+/******************************** End Of File *********************************/

ALGO_Kalman_ATY.h

@@ -51,7 +51,7 @@ typedef struct _ALGO_Kalman_S
 #else
 typedef struct _ALGO_Kalman1D_S
 {
-    float X;        // state
+    float X;        // state / origin value
     float G;        // kalman gain
     float A;        // x(n)=A*x(n-1)+u(n),u(n)~N(0,q)
     float H;        // z(n)=H*x(n)+w(n),w(n)~N(0,r)

ALGO_Temperature_ATY.c

@@ -61,6 +61,32 @@ float ALGO_ResToKelvinTemp(float Rntc, float R25, float B)
     return Cn;
 }
 
+/**
+ * @brief   Calculate temperature from ntc resistance
+ * @param   vADC ADC voltage in mV
+ * @param   vRef NTC ref voltage in mV
+ * @param   rRefK ref resistance in kOhm
+ * @param   R25 NTC standard resistance value at 25C
+ * @param   B B value of NTC
+ * @param   rRefPos ref res psition, 1 for pull up, 0 for pull down(for ntc)
+ * @return  Current temperature in Celsius
+ * @note    T25: Kelvin temperature at 25C = 298.15 = ALGO_TEMP_CtoT(25)
+ *          R25: NTC standard resistance value at 25C like 10K,5K,100K...
+ *          B: B value of NTC like 3435,3950...
+ *          Rntc: Current NTC resistance value
+ *          Tn: Actual Kelvin temperature(Cn = Tn-273.15)
+ *          B = (lnR25 - lnRntc)/(1/T25 - 1/Tn)
+ */
+float ALGO_VolToKelvinTemp(float vADC, float vRef, float rRefK, float R25, float B, uint8_t rRefPos)
+{
+    if(rRefPos == 1){
+        return ALGO_ResToKelvinTemp(ALGO_VoltageToResDown(vADC, vRef, rRefK), R25, B);
+    }
+    else{
+        return ALGO_ResToKelvinTemp(ALGO_VoltageToResUp(vADC, vRef, rRefK), R25, B);
+    }
+}
+
 
 // resultTemp = ALGO_ResToKelvinTemp(ALGO_VoltageToResDown(resultTemp, vref_t, 10), 1, 3200);
 

ALGO_Temperature_ATY.h

@@ -47,23 +47,24 @@
 
 /**
  * @brief   Calculate resistance from ADC voltage, NTC down(pull up)
- * @param   vADC ADC voltage
- * @param   vRef NTC ref voltage
- * @param   rRefK ref resistance
+ * @param   vADC ADC voltage in mV
+ * @param   vRef NTC ref voltage in mV
+ * @param   rRefK ref resistance in kOhm
  */
-#define ALGO_VoltageToResDown( vADC,  vRef,  rRefK) \
-    ((rRefK* vADC) / (vRef - vADC))
+#define ALGO_VoltageToResDown(vADC,  vRef,  rRefK) \
+    (((float)rRefK * (float)vADC) / ((float)vRef - (float)vADC))
 
 /**
  * @brief   Calculate resistance from ADC voltage, NTC up(pull down)
- * @param   vADC ADC voltage
- * @param   vRef NTC ref voltage
- * @param   rRefK ref resistance
+ * @param   vADC ADC voltage in mV
+ * @param   vRef NTC ref voltage in mV
+ * @param   rRefK ref resistance in kOhm
  */
 #define ALGO_VoltageToResUp(vADC, vRef, rRefK) \
-    ((rRefK* (vRef - vADC)) / vADC)
+    (((float)rRefK * ((float)vRef - (float)vADC)) / (float)vADC)
 
 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);
 
 
 #endif /* __ALGO_Temperature_ATY_H */

DIPM_N1.html

@@ -0,0 +1,583 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <title>Document</title>
+
+
+    <style>
+        html,
+        body {
+            width: 100%;
+            height: 100%;
+            margin: 0;
+            padding: 0;
+            overflow: hidden;
+            display: inline-flex;
+            text-align: center;
+            font-family: Consolas, Monaco, monospace;
+        }
+
+        .tableStyle {
+            border-collapse: collapse;
+            width: 96%;
+            margin: 0 2%;
+            text-align: center;
+            table-layout: fixed;
+        }
+
+        .tableStyle td,
+        .tableStyle tr,
+        .tableStyle th {
+            border: 1px solid #cad9ea;
+            color: #666;
+            height: 30px;
+        }
+
+        .tableStyle th {
+            background-color: #CCE8EB;
+        }
+
+        .tableStyle tr:nth-child(odd) {
+            background: #fff;
+        }
+
+        .tableStyle tr:nth-child(even) {
+            background: #F5FAFA;
+        }
+
+        input,
+        select {
+            /* border: none; */
+            width: 100%;
+            height: 6%;
+            background-color: white;
+            outline: none;
+            border-width: 2px;
+            border-color: black;
+            border-style: solid;
+            border-right-style: none;
+            border-top-style: none;
+            border-bottom-style: none;
+            border-left-style: none;
+            padding: 0;
+            text-align: center;
+        }
+
+        input:hover {
+            text-shadow: 0 0 1px black, 0 0 0px black, 0 0 0px black, 0 0 0px black;
+        }
+
+    </style>
+</head>
+
+<body>
+    <dialog id="powerDialog"
+        style="width: 100%; height: 100%; overflow: hidden; background: rgba(255, 255, 255, 0.7);">
+        <input type="button" id="powerOnBtn" onclick="PowerOn()" value="电源：关闭&#10;&#10;点击开机"
+            style="width: 100%; height: 100%; font-size: x-large; font-weight: bold; background: rgba(255, 255, 255, 0);">
+    </dialog>
+
+    <div style="width: 49%; float: left;">
+        <h2>原始数据</h2>
+        <table id="dataTable" class="tableStyle">
+            <tr>
+                <td>探头阻值</td>
+                <td id="probeRes">0</td>
+            </tr>
+            <tr>
+                <td>粗算温度</td>
+                <td id="fastTemp">0</td>
+            </tr>
+            <tr>
+                <td>零上温度</td>
+                <td id="aboveTemp">0</td>
+            </tr>
+            <tr>
+                <td>零下温度</td>
+                <td id="belowTemp">0</td>
+            </tr>
+            <tr>
+                <td>低通滤波一</td>
+                <td id="rcBelowTemp1">0</td>
+            </tr>
+            <tr>
+                <td>低通滤波二</td>
+                <td id="rcBelowTemp2">0</td>
+            </tr>
+            <tr>
+                <td>卡尔曼滤波一</td>
+                <td id="kalmanBelowTemp1">0</td>
+            </tr>
+            <tr>
+                <td>卡尔曼滤波二</td>
+                <td id="kalmanBelowTemp2">0</td>
+            </tr>
+            <tr>
+                <td>芯片温度</td>
+                <td id="McuTemp">0</td>
+            </tr>
+            <tr>
+                <td>NTC1</td>
+                <td id="NtcTemp1">0</td>
+            </tr>
+            <tr>
+                <td>NTC2</td>
+                <td id="NtcTemp2">0</td>
+            </tr>
+            <tr>
+                <td>NTC3</td>
+                <td id="NtcTemp3">0</td>
+            </tr>
+            <tr>
+                <td>NTC4</td>
+                <td id="NtcTemp4">0</td>
+            </tr>
+        </table>
+
+        <br>
+        <hr align=center width=96% color=#987cb9 SIZE=1>
+
+        <div style="display: inline-flex; width: 96%; align-items: center;">
+            <input type="button" value="关机" id="btnPowerOff" onclick="PowerSet(id)"></input>
+            <div style="border: 1px solid black; width: 0px; height: 20px;"></div>
+            <select name="" id="refreshSelect" onchange="AutoRefresh()" style="width: 60%;>
+                <option value=" 100">100ms</option>
+                <option value="200">200ms</option>
+                <option value="500">500ms</option>
+                <option value="1000" selected>1s</option>
+                <option value="2000">2s</option>
+                <option value="10000">10s</option>
+            </select>
+            <div style="border: 1px solid black; width: 0px; height: 20px;"></div>
+            <div style="width: 80%;">图表容积
+                <input type="number" value="9999" id="dataCount"
+                    onchange="DataCountChange(value)"></input>
+            </div>
+            <div style="border: 1px solid black; width: 0px; height: 20px;"></div>
+            <input type="button" value="引晶" id="btnFreeze" onclick="BtnFreeze()"></input>
+            <div style="border: 1px solid black; width: 0px; height: 20px;"></div>
+            <input type="button" value="记录" id="btnSave" onclick="DetectDataSave()"></input>
+        </div>
+
+        <hr align=center width=96% color=#987cb9 SIZE=1>
+
+        <h2>历史记录</h2>
+        <div style="display: inline-flex; width: 96%;">
+            <input type="button" id="startTableRefresh" value="刷新" onclick="TableProcess(id)">
+            <div style="border: 1px solid black; width: 0px;"></div>
+            <input type="button" id="startTableImport" value="导入" onclick="TableProcess(id)">
+            <div style="border: 1px solid black; width: 0px;"></div>
+            <input type="button" id="startTableExport" value="导出" onclick="TableProcess(id)">
+            <div style="border: 1px solid black; width: 0px;"></div>
+            <input type="button" id="startTableClear" value="清空" onclick="TableProcess(id)">
+        </div>
+        <table id="historyTable" class="tableStyle">
+            <tr>
+                <th>编号</th>
+                <th>时间</th>
+                <th>物质</th>
+                <th>冰点</th>
+            </tr>
+        </table>
+    </div>
+
+
+    <div style="width: 49%; height: 100%; float: right;">
+        <h2>温度曲线</h2>
+        <div id="temperatureLine" style="height: 90%;"></div>
+    </div>
+
+    <script src="./ATY_LIB/Web/PROG_Base.js"></script>
+    <script src="./ATY_LIB/Web/HW_WebSerial.js"></script>
+    <script src="./ATY_LIB/Web/dexie.js"></script>
+    <script src="https://code.hcharts.cn/highcharts/highcharts.js"></script>
+    <script src="https://code.hcharts.cn/10.3.2/modules/exporting.js"></script>
+    <script src="https://code.hcharts.cn/10.3.2/modules/export-data.js"></script>
+    <script src="https://code.hcharts.cn/plugins/zh_cn.js"></script>
+    <script>
+        /* Serial Process *****************************************************/
+        var powerOnFlag = 0;
+        document.getElementById("powerDialog").showModal();
+
+        function PowerOnDetectTimer() {
+            if (powerOnFlag == 0) {
+                setTimeout(() => {
+                    SerialSendWithCrc(new Uint8Array([0x01, 0x03, 0x00, 0x00, 0x00, 0x32, 0xC4, 0x1F]));
+                    PowerOnDetectTimer();
+                }, 500);
+            }
+            else {
+                document.getElementById("powerDialog").close();
+            }
+        }
+
+        var debugPowerOnCount = 0;
+        async function PowerOn() {
+            debugPowerOnCount++;
+            if (debugPowerOnCount > 6) {
+                debugPowerOnCount = 0;
+                document.getElementById("powerDialog").close();
+                powerOnFlag = 1;
+            }
+            if (serialPort == null)
+                await SerialConnect();
+            PowerOnDetectTimer();
+            // powerOnFlag = 1;
+        }
+
+        var WaitSerialConnect = setInterval(() => {
+            if (serialPort != null) {
+                clearInterval(WaitSerialConnect);
+                return;
+            }
+            // console.log(serialPort);
+            HintWindow("Serial Not Connected", 1000);
+        }, 1000);
+
+        function PowerSet(id) {
+            if (id == "btnPowerOff") {
+                location.reload(true);
+
+                document.getElementById("powerDialog").showModal();
+                SerialSendClear();
+                powerOnFlag = 0;
+            }
+        }
+
+
+
+        var mbStartAddr = 0;
+        var mbRegCount = 0;
+        var startSaveFlag = 0;
+        var dataSaveGroup = new Uint16Array(259 + 5);
+        var paramSave = new Float32Array(60);
+
+        function DataCountChange(value) {
+            maxDataCount = Number(value);
+            console.log(maxDataCount);
+        }
+
+        function SerialSendClear() {
+            mbStartAddr = 0;
+            mbRegCount = 0;
+            startSaveFlag = 0;
+            dataSaveGroup = new Uint16Array(259 + 5);
+            // paramSave = new Float32Array(60);
+        }
+        function SerialSendWithCrc(e) {
+            // console.log("e", e);
+            mbStartAddr = e[3];
+
+            SerialSendClear();
+            e[e.length - 1] = GenCrc16ModbusHL(e, e.length - 2, 0);
+            e[e.length - 2] = GenCrc16ModbusHL(e, e.length - 2, 1);
+            SerialSend(e);
+        }
+
+        function UserDataProcess(uint8Byte) {
+            if (startSaveFlag >= 259 + 5 - 1)
+                startSaveFlag = 0;
+            dataSaveGroup[startSaveFlag++] = uint8Byte;
+            // console.log("Receive:", startSaveFlag - 1, dataSaveGroup[startSaveFlag - 1]);
+
+            if (dataSaveGroup[0] == 0x01) {
+                if (dataSaveGroup[1] == 0x03) {
+                    if (dataSaveGroup[2] != 0) {
+                        if (CheckCrc16Modbus(dataSaveGroup, dataSaveGroup[2] + 5) == 0) {
+                            HintWindow("Success 3!", 2000);
+                            // console.log("Success 3!");
+                            // console.log("#GetData G", dataSaveGroup.toString());
+
+                            powerOnFlag = 1;
+
+                            try {
+                                for (let i in paramSave) {
+                                    paramSave[Number(i) + mbStartAddr] = hex2float(
+                                        (dataSaveGroup[2 + (Number(i) * 4) + 1] << 24)
+                                        + (dataSaveGroup[2 + (Number(i) * 4) + 2] << 16)
+                                        + (dataSaveGroup[2 + (Number(i) * 4) + 3] << 8)
+                                        + (dataSaveGroup[2 + (Number(i) * 4) + 4] << 0));
+                                    // console.log(paramSave[i]);
+                                }
+                            } catch (error) { }
+
+                            SerialSendClear();
+                        }
+                    }
+                }
+                else if (dataSaveGroup[1] == 0x06) {
+                    if (CheckCrc16Modbus(dataSaveGroup, 10) == 0) {
+                        let dtS = new Date;
+                        HintWindow("Success 6! " + dataSaveGroup[3] + "-" + dtS.getSeconds(), 2000);
+                        // console.log("Success 6! " + dataSaveGroup[3] + "-" + dtS.getSeconds());
+                        // console.log("#GetData S", dataSaveGroup.toString());
+                        SerialSendClear();
+                    }
+                }
+                else if (dataSaveGroup[1] == 0x10) {
+                    if (CheckCrc16Modbus(dataSaveGroup, 8) == 0) {
+                        HintWindow("Success 16!", 2000);
+                        // console.log("Success 16!");
+                        // console.log("#GetData SM", dataSaveGroup.toString());
+                        SerialSendClear();
+                    }
+                }
+            }
+        }
+
+        var saveTempValue = [[(new Date()).getTime(), 0]];
+        var maxDataCount = 9999;
+
+        var freshTimer = null;
+        var btnFreezeFlag = 0;
+        async function AutoRefresh(id) {
+            if (freshTimer)
+                clearInterval(freshTimer);
+            freshTimer = setInterval(function () {
+                SerialSendWithCrc(new Uint8Array([0x01, 0x03, 0x00, 0, 0x00, 50, 0, 0]));
+
+                // update data
+                document.getElementById("probeRes").innerHTML = roundFun(paramSave[20], 8);
+                document.getElementById("fastTemp").innerHTML = roundFun(paramSave[21], 8);
+                document.getElementById("aboveTemp").innerHTML = roundFun(paramSave[22], 8);
+                document.getElementById("belowTemp").innerHTML = roundFun(paramSave[23], 8);
+                document.getElementById("rcBelowTemp1").innerHTML = roundFun(paramSave[24], 8);
+                document.getElementById("rcBelowTemp2").innerHTML = roundFun(paramSave[25], 8);
+                document.getElementById("kalmanBelowTemp1").innerHTML = roundFun(paramSave[26], 8);
+                document.getElementById("kalmanBelowTemp2").innerHTML = roundFun(paramSave[27], 8);
+                document.getElementById("McuTemp").innerHTML = roundFun(paramSave[31], 8);
+                document.getElementById("NtcTemp1").innerHTML = roundFun(paramSave[36], 8);
+                document.getElementById("NtcTemp2").innerHTML = roundFun(paramSave[37], 8);
+                document.getElementById("NtcTemp3").innerHTML = roundFun(paramSave[38], 8);
+                document.getElementById("NtcTemp4").innerHTML = roundFun(paramSave[39], 8);
+                console.log(Number(roundFun(paramSave[12], 0)));
+                if (Number(roundFun(paramSave[12], 0)) == 1) {
+                    btnFreezeFlag = 0;
+                    document.getElementById("btnFreeze").style.backgroundColor = "#caffca";
+                }
+                else {
+                    btnFreezeFlag++;
+                }
+                if (btnFreezeFlag > 1) {
+                    btnFreezeFlag = 0;
+                    document.getElementById("btnFreeze").style.backgroundColor = "white";
+                }
+
+                if (powerOnFlag == 1) {
+                    var x = (new Date()).getTime();
+                    var y = paramSave[25];
+                    // var y = paramSave[27];
+                    // console.log(x, y);
+
+                    if (saveTempValue.length > 1) {
+                        // if (Math.abs(y - saveTempValue[saveTempValue.length - 1][1]) < 0.1)
+                        {
+                            chart.series[0].addPoint([x, y]);
+                            activeLastPointToolip(chart);
+                        }
+                        if (saveTempValue[0][1] == 0)
+                            chart.series[0].removePoint(0);
+                    }
+                    else {
+                        chart.series[0].addPoint([x, y]);
+                        activeLastPointToolip(chart);
+                    }
+                    if (saveTempValue.length > maxDataCount) {
+                        chart.series[0].removePoint(0);
+                    }
+                    console.log(saveTempValue.length);
+                }
+
+                // console.log(paramSave[30]);
+                // console.log(paramSave[31]);
+                // console.log(paramSave[32]);
+                // console.log(paramSave[33]);
+                // console.log(paramSave[34]);
+
+
+            }, document.getElementById("refreshSelect").value);
+        }
+        AutoRefresh("");
+
+
+        /* DataDB Process *****************************************************/
+        var detectTableGroup = new Array(4);
+        detectTableGroup[0] = 0;
+
+        async function DetectDataSave() {
+            if (Number(detectTableGroup[0]) == 0)
+                detectTableGroup[0] = 1;
+            else
+                detectTableGroup[0]++;
+            detectTableGroup[1] = new Date().toLocaleString();
+            detectTableGroup[2] = "MILK";
+            detectTableGroup[3] = roundFun(paramSave[25], 8);
+
+            var db = new Dexie("DIPM_Data");
+            db.version(1).stores({
+                DIPM_DetectData: "&d_order,\
+                                    d_time,\
+                                    d_content,\
+                                    d_icePoint"
+            });
+            db.DIPM_DetectData.add({
+                d_order: detectTableGroup[0],
+                d_time: detectTableGroup[1],
+                d_content: detectTableGroup[2],
+                d_icePoint: detectTableGroup[3],
+            });
+            document.getElementById("historyTable").insertRow(1);
+            for (let j = 0; j < document.getElementById("historyTable").rows[0].cells.length; j++)
+                document.getElementById("historyTable").rows[1].insertCell(j);
+            document.getElementById("historyTable").rows[1].cells[0].innerHTML = detectTableGroup[0];
+            document.getElementById("historyTable").rows[1].cells[1].innerHTML = detectTableGroup[1];
+            document.getElementById("historyTable").rows[1].cells[2].innerHTML = detectTableGroup[2];
+            document.getElementById("historyTable").rows[1].cells[3].innerHTML = detectTableGroup[3];
+        }
+        async function DetectDataRead() {
+            var db = new Dexie("DIPM_Data");
+            db.version(1).stores({
+                DIPM_DetectData: "&d_order,\
+                                    d_time,\
+                                    d_content,\
+                                    d_icePoint"
+            });
+
+            const getAll = await db.DIPM_DetectData.where("d_order").above(-1);
+            getAll.toArray().then(r => {
+                console.log(r);
+                detectTableGroup[0] = Number(r.length);
+                for (i = document.getElementById("historyTable").rows.length - 1;
+                    i < detectTableGroup[0]; i++) {
+                    if (i >= Number(r.length))
+                        break;
+                    document.getElementById("historyTable").insertRow(1);
+                    for (let j = 0; j < document.getElementById("historyTable").rows[0].cells.length; j++)
+                        document.getElementById("historyTable").rows[1].insertCell(j);
+                    document.getElementById("historyTable").rows[1].cells[0].innerHTML = r[i].d_order;
+                    document.getElementById("historyTable").rows[1].cells[1].innerHTML = r[i].d_time;
+                    document.getElementById("historyTable").rows[1].cells[2].innerHTML = r[i].d_content;
+                    document.getElementById("historyTable").rows[1].cells[3].innerHTML = r[i].d_icePoint;
+                }
+                for (let i = 1; i < document.getElementById("historyTable").rows.length; i++) {
+                    for (let j = 0; j < document.getElementById("historyTable").rows[0].cells.length; j++)
+                        if (document.getElementById("historyTable").rows[i].cells[j].innerHTML == "NaN") {
+                            document.getElementById("historyTable").rows[i].style.backgroundColor = "#fff3f3";
+                        }
+                }
+            });
+        }
+        DetectDataRead();
+
+        /* Table Process ******************************************************/
+        function TableProcess(id) {
+            if (id == "startTableClear") {
+
+            }
+            else if (id == "startTableExport") {
+                let str = "";
+                for (let i = 0; i < document.getElementById("historyTable").rows.length; i++) {
+                    for (let j = 0; j < document.getElementById("historyTable").rows[i].cells.length; j++) {
+                        str += document.getElementById("historyTable").rows[i].cells[j].innerHTML + ",";
+                    }
+                    str += "\r\n";
+                }
+                console.log(str);
+                let csv = "data:text/csv;charset=utf-8,\ufeff" + str;
+                let link = document.createElement("a");
+                link.setAttribute("href", csv);
+                link.setAttribute("download", "DIPM_N1_" + new Date().toLocaleString() + ".csv");
+                link.click();
+            }
+        }
+
+
+
+
+
+        /* Draw Process *******************************************************/
+        Highcharts.setOptions({
+            global: {
+                useUTC: false
+            }
+        });
+        function activeLastPointToolip(chart) {
+            var points = chart.series[0].points;
+            chart.tooltip.refresh(points[points.length - 1]);
+        }
+        var chart = Highcharts.chart('temperatureLine', {
+            plotOptions: {
+                series: {
+                    point: {
+                        events: {
+                            'click': function () {
+                                if (this.series.data.length > 1) {
+                                    this.remove();
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            accessibility: {
+                enabled: false
+            },
+            chart: {
+                type: 'spline',
+                marginRight: 10,
+                events: {
+                    load: function () {
+                        var chart = this;
+                        activeLastPointToolip(chart);
+                    }
+                }
+            },
+            title: {
+                text: ''
+            },
+            xAxis: {
+                type: 'datetime',
+                tickPixelInterval: 150,
+                title: {
+                    text: 'Time'
+                }
+            },
+            yAxis: {
+                title: {
+                    text: 'Temp'
+                }
+            },
+            tooltip: {
+                formatter: function () {
+                    return '<b>' + this.series.name + '</b><br/>' +
+                        Highcharts.dateFormat('%H:%M:%S', this.x) + '<br/>' +
+                        Highcharts.numberFormat(this.y, 8);
+                }
+            },
+            legend: {
+                enabled: false
+            },
+            series: [{
+                name: 'Temp',
+                data: saveTempValue
+            }]
+        });
+
+
+        function BtnFreeze() {
+            btnFreezeFlag = 0;
+            document.getElementById("btnFreeze").style.backgroundColor = "#caffca";
+            SerialSendWithCrc(new Uint8Array([0x01, 0x06, 0x00, 0x0C, 0x3F, 0x80, 0x00, 0x00, 0xFA, 0x3A]));
+        }
+
+
+    </script>
+
+
+
+
+</body>
+
+</html>

HW_ADC_ATY.c

@@ -91,10 +91,32 @@ uint16_t ADC_Get(uint8_t channel)
 }
 #elif defined(__STM32_HAL_ATY)
 #include "adc.h"
-uint16_t ADC_Get(ADC_HandleTypeDef* channel)
+// set channel to 0 for scnad mode
+uint16_t ADC_Get(ADC_HandleTypeDef* adc, uint32_t channel)
 {
-    return HAL_ADC_GetValue(channel);
+#if defined (__STM32F4xx_ADC_H)
+#define SAMPETIME ADC_SAMPLETIME_480CYCLES
+#elif defined (__STM32F1xx_HAL_ADC_H)
+#define SAMPETIME ADC_SAMPLETIME_239CYCLES_5
+#endif
+
+    if(channel != 0){
+        ADC_ChannelConfTypeDef sConfig = {0};
+        sConfig.Channel = channel;
+        sConfig.Rank = 1U;
+        sConfig.SamplingTime = SAMPETIME;   // do not set faster than 28 at f103
+        if(HAL_ADC_ConfigChannel(adc, &sConfig) != HAL_OK)
+        {
+            Error_Handler();
+        }
+    }
+    HAL_ADC_Start(adc);
+    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;
 }
+
 #endif /* PLATFORM */
 
 

HW_ADC_ATY.h

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

HW_PWM_ATY.c

@@ -150,6 +150,8 @@ void PCA_Isr() interrupt 7
  */
 void PWM_Start(uint32_t periodS, float dutyS, uint8_t channelS)
 {
+    if(dutyS < 0)
+        dutyS = 0;
     P_SW2 |= 0x80;
     if(channelS == PWM_CHANNEL_1P || channelS == PWM_CHANNEL_1N){
         PWMA_PS = (PWMA_PS & 0xFC) | (PWM_PIN_POS_1 << 0);      //
@@ -245,20 +247,34 @@ void PWM_Stop(uint8_t level, uint8_t channelS)
  */
 void PWM_Start(uint32_t periodS, float dutyS, uint8_t channelS)
 {
-    if(channelS == PWM_T2C2)
+#if defined (PWM_T01C1)
+    if(channelS == PWM_T01C1){
+        HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
+        // TIM1->CNT = 0;
+        // TIM1->ARR = periodS;
+        // TIM1->CCR2 = (uint32_t)(periodS * dutyS);
+        // TIM1->EGR = TIM_EGR_UG;
+        HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
+        __HAL_TIM_SET_AUTORELOAD(&htim1, periodS);
+        __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, (uint32_t)(periodS / 100 * dutyS));
+    }
+#endif
+#if defined (PWM_T02C2)
+    if(channelS == PWM_T02C2){
         HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
-    else if(channelS == PWM_T3C3)
-        HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_3);
-    // TIM2->CNT = 0;
-    // TIM2->ARR = periodS;
-    // TIM2->CCR2 = (uint32_t)(periodS * dutyS);
-    // TIM2->EGR = TIM_EGR_UG;
-    if(channelS == PWM_T2C2)
         HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
-    else if(channelS == PWM_T3C3)
-        HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);
-    __HAL_TIM_SET_AUTORELOAD(&htim2, periodS);
-    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, (uint32_t)(periodS / 100 * dutyS));
+        __HAL_TIM_SET_AUTORELOAD(&htim2, periodS);
+        __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, (uint32_t)(periodS / 100 * dutyS));
+    }
+#endif
+#if defined (PWM_T03C2)
+    if(channelS == PWM_T03C2){
+        HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_2);
+        HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);
+        __HAL_TIM_SET_AUTORELOAD(&htim3, periodS);
+        __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_2, (uint32_t)(periodS / 100 * dutyS));
+    }
+#endif
 }
 
 /**
@@ -269,6 +285,17 @@ void PWM_Start(uint32_t periodS, float dutyS, uint8_t channelS)
  */
 void PWM_Stop(uint8_t level, uint8_t channelS)
 {
+#ifdef PWM_T01C1
+    if(channelS == PWM_T01C1){
+        if(level)
+            __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, __HAL_TIM_GET_AUTORELOAD(&htim1));
+        else
+            __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 0);
+        HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
+        HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
+    }
+#endif
+#ifdef PWM_T02C2
     if(level)
     {
         TIM2->ARR = 0;
@@ -281,10 +308,31 @@ void PWM_Stop(uint8_t level, uint8_t channelS)
         TIM2->CCR4 = 1;
         TIM2->EGR = TIM_EGR_UG;
     }
-    if(channelS == PWM_T2C2)
+    if(channelS == PWM_T02C2)
         HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
-    else if(channelS == PWM_T3C3)
-        HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);
+#endif
+#ifdef PWM_T03C2
+    if(level)
+    {
+        TIM3->ARR = 0;
+        TIM3->CCR4 = 0;
+        TIM3->EGR = TIM_EGR_UG;
+    }
+    else
+    {
+        TIM3->ARR = 0;
+        TIM3->CCR4 = 1;
+        TIM3->EGR = TIM_EGR_UG;
+    }
+    if(channelS == PWM_T03C2)
+        HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);
+#endif
+}
+
+// for generate spefied pulse
+void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
+{
+
 }
 
 #elif defined(__ESP8266_RTOS_ATY)

HW_PWM_ATY.h

@@ -66,10 +66,6 @@
 #define PWM_PIN_POS_3 0x03      // PWMN_4
 
 #elif defined(__STM32_HAL_ATY)
-#define PWM_T2C2 0x22
-#define PWM_T3C3 0x33
-// #define PWM_T
-// #define PWM_C
 #elif defined(__ESP8266_RTOS_ATY)
 #endif /* PLATFORM */
 

HW_SPI_ATY.c

@@ -81,7 +81,7 @@ uint8_t SPI_Write(uint8_t* data_t, uint16_t len)
     uint8_t i = 3;
     while(i--)
     {
-        if(HAL_SPI_Transmit(&SPIH_N, data_t, len, 1000) == HAL_OK)
+        if(HAL_SPI_Transmit(&SPIH_N, (uint8_t *)data_t, len, 1000) == HAL_OK)
             return 0;
     }
     return 1;
@@ -92,7 +92,7 @@ uint8_t SPI_Read(uint8_t* data_t, uint16_t len)
     uint8_t i = 3;
     while(i--)
     {
-        if(HAL_SPI_Receive(&SPIH_N, data_t, len, 1000) == HAL_OK)
+        if(HAL_SPI_Receive(&SPIH_N, (uint8_t *)data_t, len, 1000) == HAL_OK)
             return 0;
     }
     return 1;

HW_TIMER_ATY.c

@@ -260,7 +260,7 @@ __WEAK_ATY void TimerLoopProcess_User(void)
     if(timeCounterUnit_ATY.ms100_f == 1)
     {
         timeCounterUnit_ATY.ms100_f = 0;
-        ledBlinkType = (2);
+        // ledBlinkType = (2);
         // HAL_IWDG_Refresh(&hiwdg);
     }
     // if(timeCounterUnit_ATY.s2_f == 1)

HW_UART_ATY.c

@@ -118,40 +118,6 @@ void UartSendByte(uint8_t byte)
 #endif
 }
 
-/**
- * @brief   uart hardware init
- * @note    put at main init
- *          use DMA IDEL type, open uart IT and add rx dma, mode in Normal(not Circular!), data with byte
- */
-void UartInit(void)
-{
-    // __HAL_UART_ENABLE_IT(&PRINTF_UART, UART_IT_IDLE);
-    HAL_UARTEx_ReceiveToIdle_DMA(&PRINTF_UART, uartMsgStruct_t.rx, UART_RX_MAX_LEN);
-    __HAL_DMA_DISABLE_IT(&PRINTF_DMA, DMA_IT_HT);
-
-    uartMsgStruct_t.rxCount = 0x00;
-    uartMsgStruct_t.txCount = 0x00;
-    uartMsgStruct_t.busyFlag = 0;
-}
-
-
-void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size)
-{
-    if(huart->Instance == USART1){
-        HAL_UART_DMAStop(&PRINTF_UART);
-        uartMsgStruct_t.overCount = 0;
-        uartMsgStruct_t.rxCount = UART_RX_MAX_LEN - __HAL_DMA_GET_COUNTER(&PRINTF_DMA);
-
-        HAL_UARTEx_ReceiveToIdle_DMA(&PRINTF_UART, uartMsgStruct_t.rx, UART_RX_MAX_LEN);
-        __HAL_DMA_DISABLE_IT(&PRINTF_DMA, DMA_IT_HT);
-    }
-
-    /* if process is not too long, process function can be used at this call back;
-        otherwise put process at other cycle like while or timer cycle */
-    // PrintfReceiveProcess();
-}
-
-
 
 
 
@@ -207,14 +173,49 @@ GETCHAR_PROTOTYPE \
 
 #ifdef DEBUG_PRINTF_RECEIVE
 uint8_t uartPrintfRxBuf[PRINTF_RX_MAX_LEN];
-struct _uartMsgStruct uartPrintfMsgStruct = {*uartPrintfRxBuf, 0};
+
+
+/**
+ * @brief   uart hardware init
+ * @note    put at main init
+ *          use DMA IDEL type, open uart IT and add rx dma, mode in Normal(not Circular!), data with byte
+ */
+void UartInit(void)
+{
+    // __HAL_UART_ENABLE_IT(&PRINTF_UART, UART_IT_IDLE);
+    HAL_UARTEx_ReceiveToIdle_DMA(&PRINTF_UART, uartMsgStruct_t.rx, UART_RX_MAX_LEN);
+    __HAL_DMA_DISABLE_IT(&PRINTF_DMA, DMA_IT_HT);
+
+    *(uartMsgStruct_t.rx) = *uartPrintfRxBuf;
+    uartMsgStruct_t.rxCount = 0x00;
+    uartMsgStruct_t.txCount = 0x00;
+    uartMsgStruct_t.busyFlag = 0;
+}
+
+
+void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size)
+{
+    if(huart == &PRINTF_UART){
+        HAL_UART_DMAStop(&PRINTF_UART);
+        uartMsgStruct_t.overCount = 0;
+        uartMsgStruct_t.rxCount = UART_RX_MAX_LEN - __HAL_DMA_GET_COUNTER(&PRINTF_DMA);
+        uartMsgStruct_t.rcvOverFlag = 1;
+
+        // HAL_UARTEx_ReceiveToIdle_DMA(&PRINTF_UART, uartMsgStruct_t.rx, UART_RX_MAX_LEN);
+        // __HAL_DMA_DISABLE_IT(&PRINTF_DMA, DMA_IT_HT);
+    }
+
+    /* if process is not too long, process function can be used at this call back;
+        otherwise put process at other cycle like while or timer cycle */
+    // PrintfReceiveProcess();
+}
 
 /**
  * @brief   init uart IT and DMA etc.
  */
 void PrintfReceiveInit(void)
 {
-    HAL_UARTEx_ReceiveToIdle_DMA(&PRINTF_UART, uartPrintfMsgStruct.rx, PRINTF_RX_MAX_LEN);
+    HAL_UARTEx_ReceiveToIdle_DMA(&PRINTF_UART, uartMsgStruct_t.rx, PRINTF_RX_MAX_LEN);
     __HAL_DMA_DISABLE_IT(&PRINTF_DMA, DMA_IT_HT);
 }
 
@@ -224,50 +225,25 @@ void PrintfReceiveInit(void)
  */
 __WEAK_ATY void PrintfReceiveProcess(void)
 {
-    struct _uartMsgStruct* ptr = &uartPrintfMsgStruct;
+    struct _uartMsgStruct* ptr = &uartMsgStruct_t;
 
     if(ptr->rcvOverFlag)
     {
         ptr->rcvOverFlag = 0;
+        // ptr->rxCount = 0;
 
-        PrintfReceiveProcess_User(ptr);
+        UartReceiveProcess_User(ptr);
 
         PrintfReceiveInit();
     }
 }
-
-
-__WEAK_ATY void PrintfReceiveProcess_User(struct _uartMsgStruct* ptr)
-{
-    // if(memcmp("DSTART", (char*)ptr->rx, strlen("DSTART")) == 0)
-    // {
-    //     printf("\r\nDebug START!");
-    // }
-    // else if(memcmp("temp", (char*)ptr->rx, strlen("temp")) == 0)
-    // {
-    //     printf("\r\ntemp %c%c%c",
-    //         ptr->rx[strlen("temp_")],
-    //         ptr->rx[strlen("temp_") + 1],
-    //         ptr->rx[strlen("temp_") + 2]);
-    // }
-}
-
-void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size)
-{
-    HAL_UART_DMAStop(&PRINTF_UART);
-    uartPrintfMsgStruct.rxCount = PRINTF_RX_MAX_LEN - __HAL_DMA_GET_COUNTER(&PRINTF_DMA);
-    uartPrintfMsgStruct.rcvOverFlag = 1;
-
-    /* if process is not too long, process function can be used at this call back;
-        otherwise put process at other cycle like while or timer cycle */
-    // PrintfReceiveProcess();
-}
 #endif /* DEBUG_PRINTF_RECEIVE */
 
-
 #endif /* PLATFORM */
 /******************************************************************************/
 
+
+
 /**
  * @brief   uart send bytes
  * @param   bytes bytes to send
@@ -359,6 +335,9 @@ void UartSendFloatStr(float dataFloat)
  */
 __WEAK_ATY void UartReceiveProcess(void)
 {
+#ifdef DEBUG_PRINTF_RECEIVE
+    PrintfReceiveProcess();
+#else
     // if(uartMsgStruct_t.overCount >= 10000)
     if(uartMsgStruct_t.overCount > 2000)
     {
@@ -374,6 +353,7 @@ __WEAK_ATY void UartReceiveProcess(void)
     }
     else
         uartMsgStruct_t.overCount++;
+#endif
 }
 
 // /**
@@ -384,6 +364,25 @@ __WEAK_ATY void UartReceiveProcess(void)
 //     if(ptr->rx[0] == 'O' && ptr->rx[1] == 'K')
 //         UartSendStr("\r\nRC OK!\r\n");
 //     // UartSendStr(ptr->rx);
+
+//     if(memcmp("DSTART", (char*)ptr->rx, strlen("DSTART")) == 0)
+//     {
+//         printf("\r\nDebug START!");
+//     }
+//     else if(memcmp("temp", (char*)ptr->rx, strlen("temp")) == 0)
+//     {
+//         printf("\r\ntemp %c%c%c",
+//             ptr->rx[strlen("temp_")],
+//             ptr->rx[strlen("temp_") + 1],
+//             ptr->rx[strlen("temp_") + 2]);
+//     }
+
+//     if((ptr->rx[0] == 'O'
+//         && ptr->rx[1] == 'K'
+//         && ptr->rx[2] == '?'))
+//         UartSendStr("OK!");
+
+//     Modbus_Process(ptr->rx, ptr->rxCount);
 // }
 
 

HW_UART_ATY.h

@@ -47,6 +47,7 @@ typedef struct _uartMsgStruct{
     uint8_t txCount;
     uint8_t busyFlag;
     uint32_t overCount;
+    uint8_t rcvOverFlag;
 } uartMsgStruct;
 extern struct _uartMsgStruct uartMsgStruct_t;
 void UartInit(void);

INCLUDE_ATY.h

@@ -224,8 +224,7 @@ extern void _nop_(void);
 #define __XDATA
 
 #define __CODE
-// #include <intrins.h>    // _nop_()
-#define __NOP_ATY _nop_()
+#define __NOP_ATY __nop()
 
 #if defined(__ICCARM__)
 #define __WEAK_ATY __WEAK __ATTRIBUTES
@@ -241,6 +240,13 @@ extern void _nop_(void);
 
 
 /******************************* For user *************************************/
+// #define DBG_ATY(DBG_CODE, code)
+// do{
+// #ifdef DBG_CODE
+//     code
+// #endif
+// }while(0)
+
 
 #include "main.h"
 
@@ -275,6 +281,7 @@ extern void _nop_(void);
 #endif
 
 
+
 // #if !defined(__PRINTF_ATY) && !defined(__stdio_h) && !defined(__STM32_HAL_ATY)
 // #include "stdarg.h"
 // __WEAK_ATY void printf(uint8_t*, ...);

MODBUS_LOW_ATY.c

@@ -18,6 +18,8 @@
 *
 * @brief Familiar functions of modbus for all device
 *
+* @note 4 byte per reg, save float or uint32
+*
 * @version
 *       - 1_01_221029 > ATY
 *           -# Preliminary version, first Release

MODBUS_LOW_ATY.h

@@ -35,6 +35,13 @@
 // #define MODBUS_FLOAT_MODE
 #define MODBUS_FLOAT_CODE_MODE
 
+/* define sample */
+// #include "HW_UART_ATY.h"
+// #define MODBUS_REG_HOLDING_SIZE                    60   // set --model-large at 51
+// #include "MODBUS_LOW_ATY.h"
+// #define mbG mbRegHoding
+
+#include "main.h"
 #ifndef MODBUS_REG_HOLDING_SIZE
 #define MODBUS_REG_HOLDING_SIZE                    50   // set --model-large at 51
 #endif

MODBUS_S_LOW_ATY.c

@@ -0,0 +1,161 @@
+/**
+* @file MODBUS_S_LOW_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 modbus for all device
+*
+* @note 4 byte per reg, save float or uint32
+*
+* @version
+*       - 1_01_221029 > ATY
+*           -# Preliminary version, first Release
+********************************************************************************
+*/
+
+#ifndef __MODBUS_S_LOW_ATY_C
+#define __MODBUS_S_LOW_ATY_C
+
+#include "MODBUS_S_LOW_ATY.h"
+
+/******************************* For user *************************************/
+
+/******************************************************************************/
+
+__XDATA uint16_t mbRegHodingS[MODBUS_REG_HOLDING_SIZE] = {0};
+/**
+ * @brief   modbus process
+ * @note    only make 03/06/10 function code, others will return err 01
+ */
+void Modbus_Process(uint8_t* buf, uint8_t len)
+{
+    uint8_t sendBuf[(MODBUS_REG_HOLDING_SIZE * 2) + 4] = {0x00};
+    uint16_t sendBufSize = 4;
+    sendBuf[0] = buf[0];
+    sendBuf[1] = buf[1];
+
+    if(buf[0] != MODBUS_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
+            {
+                // case MODBUS_FUNC_READ_COILS:{break; }
+                // case MODBUS_FUNC_READ_DISCRETE_INPUTS:{break; }
+                case MODBUS_FUNC_READ_HOLDING_REGISTERS:{
+                    uint16_t i = 0, startAddr = 0, regCount = 0;
+                    startAddr = ((buf[2] << 8) + buf[3]);
+                    regCount = ((buf[4] << 8) + buf[5]);
+                    if(startAddr + regCount - 1 > MODBUS_REG_HOLDING_SIZE){
+                        sendBuf[1] = buf[1] + 0x80;
+                        sendBuf[2] = 0x02;
+                        sendBufSize = 6;
+                        break;
+                    }
+                    sendBuf[2] = regCount * 4;
+                    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;
+                    }
+                    break;
+                }
+            // case MODBUS_FUNC_READ_INPUT_REGISTERS:{break; }
+            // case MODBUS_FUNC_WRITE_SINGLE_COIL:{break; }
+                case MODBUS_FUNC_WRITE_SINGLE_HOLDING_REGISTERS:{
+                    uint16_t startAddr = 0;
+                    startAddr = (((uint16_t)buf[2] << 8) + (uint16_t)buf[3]);
+                    if(startAddr >= MODBUS_REG_HOLDING_SIZE){
+                        sendBuf[1] = buf[1] + 0x80;
+                        sendBuf[2] = 0x02;
+                        sendBufSize = 6;
+                        break;
+                    }
+#ifdef BIG_ENDIAN
+                    mbRegHodingS[startAddr] = buf[4] + buf[5] << 8;
+#else
+                    mbRegHodingS[startAddr] = buf[4] << 8 + buf[5];
+#endif
+                    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;
+                    break;
+                }
+                case MODBUS_FUNC_WRITE_MULTY_HOLDING_REGISTERS:{
+                    uint16_t i = 0, startAddr = 0, regCount = 0;
+                    startAddr = ((buf[2] << 8) + buf[3]);
+                    regCount = ((buf[4] << 8) + buf[5]);
+                    if(startAddr + regCount - 1 > MODBUS_REG_HOLDING_SIZE){
+                        sendBuf[1] = buf[1] + 0x80;
+                        sendBuf[2] = 0x02;
+                        sendBufSize = 6;
+                        break;
+                    }
+                    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
+                    }
+
+                    sendBuf[2] = startAddr >> 8;
+                    sendBuf[3] = startAddr;
+                    sendBuf[4] = regCount >> 8;
+                    sendBuf[5] = regCount;
+                    sendBufSize += 4;
+                    break; }
+                default:{
+                    sendBuf[1] = buf[1] + 0x80;
+                    sendBuf[2] = 0x01;
+                    sendBufSize = 6;
+                    break; }
+            }
+        }
+        sendBuf[sendBufSize - 2] = GenCrc16ModbusHL(sendBuf, sendBufSize - 2, 1);
+        sendBuf[sendBufSize - 1] = GenCrc16ModbusHL(sendBuf, sendBufSize - 2, 0);
+        UartSendBytes(sendBuf, sendBufSize);
+    }
+}
+
+#endif /* __MODBUS_S_LOW_ATY_C */
+
+/******************************** End Of File *********************************/

MODBUS_S_LOW_ATY.h

@@ -0,0 +1,66 @@
+/**
+* @file MODBUS_S_LOW_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 modbus for all device
+*
+* @version
+*       - 1_01_221029 > ATY
+*           -# Preliminary version, first Release
+********************************************************************************
+*/
+
+#ifndef __MODBUS_S_LOW_ATY_H
+#define __MODBUS_S_LOW_ATY_H
+
+#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
+
+#ifndef MODBUS_REG_HOLDING_SIZE
+#define MODBUS_REG_HOLDING_SIZE                    100   // set --model-large at 51
+#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
+/******************************************************************************/
+
+#define MODBUS_FUNC_READ_COILS                     0x01
+#define MODBUS_FUNC_READ_DISCRETE_INPUTS           0x02
+#define MODBUS_FUNC_READ_HOLDING_REGISTERS         0x03
+#define MODBUS_FUNC_READ_INPUT_REGISTERS           0x04
+#define MODBUS_FUNC_WRITE_SINGLE_COIL              0x05
+#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 */
+
+void Modbus_Process(uint8_t* buf, uint8_t len);
+
+#endif /* __MODBUS_S_LOW_ATY_H */
+
+/******************************** End Of File *********************************/

MOTOR_STEP_ATY.c

@@ -140,13 +140,19 @@ 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;
 }
@@ -236,10 +242,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 change
+ *          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
+ *          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
@@ -330,7 +336,7 @@ void MotorStateMachine_Step_PWM(void)
 }
 
 
-uint8_t motorLastState[2] = {0};
+uint8_t motorLastState[MOTOR_COUNT] = {0};
 /**
  * @brief   deal step motor state
  * @note    put at 1us cycle;
@@ -381,6 +387,46 @@ 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;
@@ -461,47 +507,6 @@ 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,41 +37,45 @@
 
 
 /******************************* 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
-// #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
+
+/* 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
 /******************************************************************************/
 
+
 typedef struct{
     uint8_t motorEn;
     uint8_t motorDir;
@@ -124,8 +128,6 @@ 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);
@@ -139,6 +141,78 @@ 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 */