传感器数据采集基本完成

Project/HC32F460/MDK/HC32F460.uvoptx

@@ -117,10 +117,30 @@
         <pMon>Segger\JL2CM3.dll</pMon>
       </DebugOpt>
       <TargetDriverDllRegistry>
+        <SetRegEntry>
+          <Number>0</Number>
+          <Key>ARMRTXEVENTFLAGS</Key>
+          <Name>-L70 -Z18 -C0 -M0 -T1</Name>
+        </SetRegEntry>
+        <SetRegEntry>
+          <Number>0</Number>
+          <Key>DLGTARM</Key>
+          <Name>(1010=-1,-1,-1,-1,0)(1007=-1,-1,-1,-1,0)(1008=-1,-1,-1,-1,0)(1009=-1,-1,-1,-1,0)(1012=-1,-1,-1,-1,0)</Name>
+        </SetRegEntry>
+        <SetRegEntry>
+          <Number>0</Number>
+          <Key>ARMDBGFLAGS</Key>
+          <Name></Name>
+        </SetRegEntry>
+        <SetRegEntry>
+          <Number>0</Number>
+          <Key>DLGUARM</Key>
+          <Name></Name>
+        </SetRegEntry>
         <SetRegEntry>
           <Number>0</Number>
           <Key>JL2CM3</Key>
-          <Name>-U4294967295 -O78 -S2 -ZTIFSpeedSel5000 -A0 -C0 -JU1 -JI127.0.0.1 -JP0 -RST0 -N00("ARM CoreSight SW-DP") -D00(2BA01477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -TB1 -TFE0 -FO7 -FD1FFF8000 -FC1000 -FN2 -FF0HC32F460_512K.FLM -FS00 -FL080000 -FP0($$Device:HC32F460JEUA$FlashARM\HC32F460_512K.FLM) -FF1HC32F460_otp.FLM -FS13000C00 -FL13FC -FP1($$Device:HC32F460JEUA$FlashARM\HC32F460_otp.FLM)</Name>
+          <Name>-U4294967295 -O78 -S2 -ZTIFSpeedSel5000 -A0 -C0 -JU1 -JI127.0.0.1 -JP0 -RST0 -N00("ARM CoreSight SW-DP") -D00(2BA01477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8027 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -TB1 -TFE0 -FO15 -FD1FFF8000 -FC1000 -FN2 -FF0HC32F460_512K.FLM -FS00 -FL080000 -FP0($$Device:HC32F460JEUA$FlashARM\HC32F460_512K.FLM) -FF1HC32F460_otp.FLM -FS13000C00 -FL13FC -FP1($$Device:HC32F460JEUA$FlashARM\HC32F460_otp.FLM)</Name>
         </SetRegEntry>
         <SetRegEntry>
           <Number>0</Number>
@@ -129,18 +149,35 @@
         </SetRegEntry>
       </TargetDriverDllRegistry>
       <Breakpoint/>
+      <WatchWindow1>
+        <Ww>
+          <count>0</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>LEFTLOW_CS1237Var.CS1237Delay1mSCnt,0x0A</ItemText>
+        </Ww>
+        <Ww>
+          <count>1</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>App.FeedDogDlyCnt,0x0A</ItemText>
+        </Ww>
+        <Ww>
+          <count>2</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>App.Status,0x0A</ItemText>
+        </Ww>
+      </WatchWindow1>
       <Tracepoint>
         <THDelay>0</THDelay>
       </Tracepoint>
       <DebugFlag>
         <trace>0</trace>
         <periodic>0</periodic>
-        <aLwin>0</aLwin>
+        <aLwin>1</aLwin>
         <aCover>0</aCover>
         <aSer1>0</aSer1>
         <aSer2>0</aSer2>
         <aPa>0</aPa>
-        <viewmode>0</viewmode>
+        <viewmode>1</viewmode>
         <vrSel>0</vrSel>
         <aSym>0</aSym>
         <aTbox>0</aTbox>
@@ -952,6 +989,42 @@
       <RteFlg>0</RteFlg>
       <bShared>0</bShared>
     </File>
+    <File>
+      <GroupNumber>4</GroupNumber>
+      <FileNumber>51</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\source\Module\CS1237\CS1237_LEFTUP.c</PathWithFileName>
+      <FilenameWithoutPath>CS1237_LEFTUP.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
+    <File>
+      <GroupNumber>4</GroupNumber>
+      <FileNumber>52</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\source\Module\CS1237\CS1237_RIGHTLOW.c</PathWithFileName>
+      <FilenameWithoutPath>CS1237_RIGHTLOW.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
+    <File>
+      <GroupNumber>4</GroupNumber>
+      <FileNumber>53</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\source\Module\CS1237\CS1237_RIGHTUP.c</PathWithFileName>
+      <FilenameWithoutPath>CS1237_RIGHTUP.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
   </Group>
 
   <Group>

Project/HC32F460/MDK/HC32F460.uvprojx

@@ -10,9 +10,8 @@
       <TargetName>Debug</TargetName>
       <ToolsetNumber>0x4</ToolsetNumber>
       <ToolsetName>ARM-ADS</ToolsetName>
-      <pArmCC>6160000::V6.16::ARMCLANG</pArmCC>
+      <pCCUsed>5060960::V5.06 update 7 (build 960)::ARMCC</pCCUsed>
-      <pCCUsed>6160000::V6.16::ARMCLANG</pCCUsed>
+      <uAC6>0</uAC6>
-      <uAC6>1</uAC6>
       <TargetOption>
         <TargetCommonOption>
           <Device>HC32F460JEUA</Device>
@@ -315,7 +314,7 @@
           </ArmAdsMisc>
           <Cads>
             <interw>1</interw>
-            <Optim>2</Optim>
+            <Optim>1</Optim>
             <oTime>0</oTime>
             <SplitLS>0</SplitLS>
             <OneElfS>1</OneElfS>
@@ -650,6 +649,21 @@
               <FileType>1</FileType>
               <FilePath>..\source\Module\CS1237\CS1237_LEFTLOW.c</FilePath>
             </File>
+            <File>
+              <FileName>CS1237_LEFTUP.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\source\Module\CS1237\CS1237_LEFTUP.c</FilePath>
+            </File>
+            <File>
+              <FileName>CS1237_RIGHTLOW.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\source\Module\CS1237\CS1237_RIGHTLOW.c</FilePath>
+            </File>
+            <File>
+              <FileName>CS1237_RIGHTUP.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\source\Module\CS1237\CS1237_RIGHTUP.c</FilePath>
+            </File>
           </Files>
         </Group>
         <Group>
@@ -1303,6 +1317,21 @@
               <FileType>1</FileType>
               <FilePath>..\source\Module\CS1237\CS1237_LEFTLOW.c</FilePath>
             </File>
+            <File>
+              <FileName>CS1237_LEFTUP.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\source\Module\CS1237\CS1237_LEFTUP.c</FilePath>
+            </File>
+            <File>
+              <FileName>CS1237_RIGHTLOW.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\source\Module\CS1237\CS1237_RIGHTLOW.c</FilePath>
+            </File>
+            <File>
+              <FileName>CS1237_RIGHTUP.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\source\Module\CS1237\CS1237_RIGHTUP.c</FilePath>
+            </File>
           </Files>
         </Group>
         <Group>

Project/HC32F460/source/Module/AD7924/ad7924.c

@@ -1,2 +0,0 @@
-#include "bps.h"
-

Project/HC32F460/source/Module/CS1237/CS1237_LEFTLOW.c

@@ -4,6 +4,22 @@
 #include "main.h"
 #include "Algorithm.h"
 
+#define	CS1237_DOUT_OUT()		PORT_OE(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx, Enable)
+#define	CS1237_DOUT_IN()		PORT_OE(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx, Disable)
+#define	CS1237_DOUT_H()		SET_LEFTLOW_CS1237_DOUT()
+#define	CS1237_DOUT_L()		CLR_LEFTLOW_CS1237_DOUT()
+#define  CS1237_DOUT_GET()		GET_LEFTLOW_CS1237_DOUT()
+
+#define	CS1237_SCLK_H()		SET_LEFTLOW_CS1237_SCLK()
+#define	CS1237_SCLK_L()		CLR_LEFTLOW_CS1237_SCLK()
+
+#define	CS1237_5NS(x)			delay_5ns(x)				//5ns延时
+#define	CS1237_1US(x)			Ddl_Delay1us(x)			//1us延时
+#define	CS1237_1MS(x)			Ddl_Delay1ms(x)			//1ms延时
+
+#define 	CS1237IntEnable()		ExtInt01IntEnable()
+#define 	CS1237IntDisable()	ExtInt01IntDisable()
+
 LEFTLOW_CS1237Var_t LEFTLOW_CS1237Var;
 static bool InitFlag;
 static bool CS1237IrqFlag;
@@ -18,15 +34,15 @@ extern void LEFTLOW_CS1237AinADataProcessCallBack(int32_t AD);
 static void CS1237_Clock(void)
 {
     CS1237_SCLK_H();
-    CS1237_100NS(3);
+    CS1237_5NS(60);
     CS1237_SCLK_L();
-    CS1237_100NS(3);
+    CS1237_5NS(60);
 }
 /** cs1237 休眠*/
 static void CS1237_Sleep(void)
 {
     CS1237_SCLK_H();
-    CS1237_1US(150);
+    CS1237_1US(200);
 }
 /** cs1237 唤醒*/
 static void CS1237_WakeUp(void)
@@ -48,8 +64,8 @@ static void Set_CS1237_Config(uint8_t ad_reg)
 	 CS1237IrqFlag = false;
 	 while(CS1237IrqFlag == false) //等待芯片准备好
     {
-		  if(CS1237Var.CS1237Delay1mSCnt <= 0){
+		  if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
-				DBG_LOG("LEFTLOW CS1237 Preparation Timeout...\r\n");
+				//DBG_LOG("LEFTLOW CS1237 Preparation Timeout...\r\n");
 				return;         // 超时退出
 		  }
     }
@@ -97,7 +113,7 @@ static void Set_CS1237_Config(uint8_t ad_reg)
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
         CS1237_Clock();
@@ -120,12 +136,12 @@ static int32_t Read_CS1237_Config(void)
 	 CS1237_DOUT_H();
     CS1237_DOUT_IN();
 	 CS1237_SCLK_L(); //时钟拉低
-	 CS1237Var.CS1237Delay1mSCnt = 300;
+	 LEFTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
 	 CS1237IrqFlag = false;
 	 while(CS1237IrqFlag == false) //等待芯片准备好
     {
-		  if(CS1237Var.CS1237Delay1mSCnt <= 0){
+		  if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
-				DBG_LOG("LEFTLOW CS1237 Preparation Timeout...\r\n");
+				//DBG_LOG("LEFTLOW CS1237 Preparation Timeout...\r\n");
 				return 0;         // 超时退出
 		  }
     }
@@ -167,11 +183,11 @@ static int32_t Read_CS1237_Config(void)
 	 {
 		  CS1237_SCLK_H();
 		  reg_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1237_100NS(3);//延时300ns
+		  CS1237_5NS(60);//延时300ns
-		  if(GET_CS1237_DOUT() == true) //有数值则累加
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
 			reg_temp |= 1;
 		  CS1237_SCLK_L();
-		  CS1237_100NS(3);
+		  CS1237_5NS(60);
 	 }
     /* 8: clk46 */
 	 CS1237_Clock();
@@ -192,11 +208,11 @@ static int32_t Read_CS1237_Ad_Data(void)
 	 {
 		  CS1237_SCLK_H();
 		  data_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1237_100NS(3);//延时300ns
+		  CS1237_5NS(60);//延时300ns
-		  if(GET_CS1237_DOUT() == true) //有数值则累加
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
 			data_temp |= 1;
 		  CS1237_SCLK_L();
-		  CS1237_100NS(3);
+		  CS1237_5NS(60);
 	 }
 		 
 	 /* clk25 ~ clk27 */
@@ -220,16 +236,16 @@ void LEFTLOW_CS1237_IrqCallBack(void)
 }
 void LEFTLOW_CS1237_Init(void)
 {
+	
 	CS1237IrqFlag = false;
 	BuildDelay = false;
-	CS1237IntEnable();
 	LEFTLOW_CS1237Var.AinA_AD = 0;
-	//CS1237Var.Ain2_AD = 0;
 	LEFTLOW_CS1237Var.Temp_AD = 0;
 	LEFTLOW_CS1237Var.Jump_AD = 0;
 	
+	CS1237IntEnable();
 	CS1237Port = CH_SEL_A;
-	CS1237Hz = SPEED_SEL_40Hz;
+	CS1237Hz = SPEED_SEL_640Hz;
 	CS1237PGA = PGA_SEL_128;
 	
 	uint8_t read_reg = 0x00;
@@ -241,8 +257,8 @@ void LEFTLOW_CS1237_Init(void)
 	CS1237_1MS(20);
 	if(read_reg != set_reg){
 		DBG_LOG("LEFTLOW CS1237 Init ERR...\r\n");
-		DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
+		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		InitFlag = false;
+		InitFlag = true;
 	}
 	else {
 		DBG_LOG("LEFTLOW CS1237 Init OK...\r\n");
@@ -250,6 +266,7 @@ void LEFTLOW_CS1237_Init(void)
 		CS1237Port = read_reg & 0x03;
 		InitFlag = true;
 	}
+	CS1237IntDisable();
 }
 void LEFTLOW_CS1237DataLoopCollect(void)
 { 
@@ -258,10 +275,10 @@ void LEFTLOW_CS1237DataLoopCollect(void)
 	static uint8_t TimeOutmagcnt;
 	
 	switch(LEFTLOW_CS1237Var.Status) {
-		case CS1237_STATUS_IDLE:{
+		case LLCS1237_STATUS_IDLE:{
 		break;}
 		
-		case CS1237_STATUS_START:{
+		case LLCS1237_STATUS_START:{
 			memset(&ad_array, 0x00, sizeof(ad_array));
 			adcnt = 0;
 			TimeOutmagcnt = 0;
@@ -281,35 +298,35 @@ void LEFTLOW_CS1237DataLoopCollect(void)
 				if(CS1237Hz == SPEED_SEL6_1280Hz){
 					LEFTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
 				}
-				LEFTLOW_CS1237Var.Status = CS1237_STATUS_DELAY;
+				LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_DELAY;
 			}
 			else
 			{
-				LEFTLOW_CS1237Var.Status = CS1237_STATUS_READ;
+				LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
 			}
 		break;}
 		
-		case CS1237_STATUS_DELAY:{
+		case LLCS1237_STATUS_DELAY:{
 			if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
-				LEFTLOW_CS1237Var.Status = CS1237_STATUS_READ;
+				LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
 			}		
 		break;}
 		
-		case CS1237_STATUS_READ:{
+		case LLCS1237_STATUS_READ:{
 			CS1237IrqFlag = false;
 			LEFTLOW_CS1237Var.CS1237Delay1mSCnt = 100;
-			LEFTLOW_CS1237Var.Status = CS1237_STATUS_WAIT_READ;
+			LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_WAIT_READ;
 		break;}
 		
-		case	CS1237_STATUS_WAIT_READ:{
+		case	LLCS1237_STATUS_WAIT_READ:{
 			if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
-				LEFTLOW_CS1237Var.Status = CS1237_STATUS_READ;
+				LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
 				TimeOutmagcnt++;
 			}
 			if(CS1237IrqFlag == true){
 				CS1237IrqFlag = false;
 				ad_array[adcnt++] = Read_CS1237_Ad_Data();
-				LEFTLOW_CS1237Var.Status = CS1237_STATUS_READ;
+				LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
 			}
 			if(TimeOutmagcnt >= PACK_NUM){
 				TimeOutmagcnt = 0;
@@ -326,19 +343,19 @@ void LEFTLOW_CS1237DataLoopCollect(void)
 						LEFTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
 						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
 					}
-					LEFTLOW_CS1237Var.Status = CS1237_STATUS_CH_SEL;
+					LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_CH_SEL;
 				}
 				else{
 					if(CS1237Port == CH_SEL_A){
-						DBG_LOG("CS1238 CHA TimeOut...\r\n"); 
+						DBG_LOG("LEFTLOW CS1237 CHA TimeOut...\r\n"); 
 					}
 					if(CS1237Port == CH_SEL_TEMP){
-						DBG_LOG("CS1238 Temp TimeOut...\r\n"); 
+						DBG_LOG("LEFTLOW CS1237 Temp TimeOut...\r\n"); 
 					}
 					if(CS1237Port == CH_SEL_JUMP){
-						DBG_LOG("CS1238 Jump TimeOut...\r\n"); 
+						DBG_LOG("LEFTLOW CS1237 Jump TimeOut...\r\n"); 
 					}
-					LEFTLOW_CS1237Var.Status = CS1237_STATUS_CH_SEL;
+					LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_CH_SEL;
 				}
 			}
 			if(adcnt >= PACK_NUM){
@@ -354,12 +371,12 @@ void LEFTLOW_CS1237DataLoopCollect(void)
 						LEFTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
 						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
 					}
-					LEFTLOW_CS1237Var.Status = CS1237_STATUS_CH_SEL;
+					LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_CH_SEL;
 			}
 		break;}
 		
-		case CS1237_STATUS_CH_SEL:{
+		case LLCS1237_STATUS_CH_SEL:{
-			LEFTLOW_CS1237Var.Status = CS1237_STATUS_STOP;
+			LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_STOP;
 			BuildDelay = false;
 			uint8_t read_reg;
 			if(CS1237Port == CH_SEL_A){
@@ -414,10 +431,10 @@ void LEFTLOW_CS1237DataLoopCollect(void)
 		}
 		break;}
 		
-		case CS1237_STATUS_STOP:{
+		case LLCS1237_STATUS_STOP:{
-			//CS1237Stop();
+			LEFTLOW_CS1237Stop();
-			//LEFTLOW_CS1237Var.Status = CS1237_STATUS_IDLE;
+			LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_IDLE;
-			LEFTLOW_CS1237Var.Status = CS1237_STATUS_START;//持续工作
+			//LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_START;//持续工作
 		break;}
 	}
 }
@@ -426,22 +443,22 @@ void LEFTLOW_CS12371mSRoutine(void)
 	if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt > 0) 
 		LEFTLOW_CS1237Var.CS1237Delay1mSCnt--;
 }
-void LEFTLOW_CS1238Start(void)
+void LEFTLOW_CS1237Start(void)
 {
 	CS1237_WakeUp();
 	CS1237_1MS(2);
 	BuildDelay = true;
-	LEFTLOW_CS1237IntEnable();
+	CS1237IntEnable();
 	if(!InitFlag){
 		LEFTLOW_CS1237_Init();
 		return;
 	}
-	LEFTLOW_CS1237Var.Status = CS1237_STATUS_START;
+	LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_START;
 }
 void LEFTLOW_CS1237Stop(void)
 {
-	LEFTLOW_CS1237IntDisable();
+	CS1237IntDisable();
-	CS1237_Sleep();
+	//CS1237_Sleep();
 }
 
 

Project/HC32F460/source/Module/CS1237/CS1237_LEFTLOW.h

@@ -26,18 +26,6 @@
 #define	CH_SEL_TEMP				0x02
 #define	CH_SEL_JUMP				0x03
 
-#define	CS1237_DOUT_OUT()		SetBit(((uint32_t)&M0P_GPIO->PADIR + LEFTLOW_CS1237_DOUT_PORTx), LEFTLOW_CS1237_DOUT_PINx, 0)
-#define	CS1237_DOUT_IN()		SetBit(((uint32_t)&M0P_GPIO->PADIR + LEFTLOW_CS1237_DOUT_PORTx), LEFTLOW_CS1237_DOUT_PINx, 1)
-#define	CS1237_DOUT_H()		SET_LEFTLOW_CS1237_DOUT()
-#define	CS1237_DOUT_L()		CLR_LEFTLOW_CS1237_DOUT()
-
-#define	CS1237_SCLK_H()		SET_LEFTLOW_CS1237_SCLK()
-#define	CS1237_SCLK_L()		CLR_LEFTLOW_CS1237_SCLK()
-
-#define	CS1237_1US(x)			delay_us(x)			//1us延时
-#define	CS1237_100NS(x)		delay_ns(x)			//100ns延时
-#define	CS1237_1MS(x)			delay_ms(x)			//1ms延时
-
 /*Definition of conversion time corresponding to repeatability setting*/
 /*
 	10Hz     	//建立时间300ms
@@ -54,35 +42,33 @@
 //#define  PORT_B	  		1						//采集通道B
 #define  PORT_TEMP	   0						//采集温度
 #define  PORT_JUMP	   0						//内短采集
-#define	PACK_NUM		   10						//一次采集的数据包数量
+#define	PACK_NUM		   1						//一次采集的数据包数量
-#define	FILTER_NUM		4						//滤波数
+#define	FILTER_NUM		0						//滤波数
 
 typedef enum{
-	CS1237_STATUS_IDLE,
+	LLCS1237_STATUS_IDLE,
-	CS1237_STATUS_START,
+	LLCS1237_STATUS_START,
-	CS1237_STATUS_DELAY,
+	LLCS1237_STATUS_DELAY,
-	CS1237_STATUS_READ,
+	LLCS1237_STATUS_READ,
-	CS1237_STATUS_WAIT_READ,
+	LLCS1237_STATUS_WAIT_READ,
-	CS1237_STATUS_CH_SEL,
+	LLCS1237_STATUS_CH_SEL,
-	CS1237_STATUS_STOP,
+	LLCS1237_STATUS_STOP,
-}CS1237Status_m;
+}LeftLowCS1237Status_m;
 
 typedef struct{
-	CS1237Status_m Status;
+	LeftLowCS1237Status_m Status;
 	uint32_t CS1237Delay1mSCnt;
 	
 	int32_t AinA_AD;//AINAad数据
-	//int32_t Ain2_AD;//AIN2ad数据	
+	//int32_t AinB_AD;//AINBad数据	
 	int32_t Temp_AD;//温度ad数据
 	int32_t Jump_AD;//内短ad数据	
 }
 LEFTLOW_CS1237Var_t;
-extern LEFTLOW_CS1237Var_t LEFTLOW_CS1237Var;
 
 void LEFTLOW_CS1237_Init(void);
 void LEFTLOW_CS1237_IrqCallBack(void);
 void LEFTLOW_CS1237DataLoopCollect(void);
-void LEFTLOW_CS1237LoopHandler(void); 
 void LEFTLOW_CS12371mSRoutine(void);
 void LEFTLOW_CS1237Start(void);
 void LEFTLOW_CS1237Stop(void);

Project/HC32F460/source/Module/CS1237/CS1237_LEFTUP.c

@@ -1,189 +1,203 @@
-#include "CS1238.h" 
+#include "CS1237_LEFTUP.h" 
-#include "UartDebug.h"
+#include "Debug.h"
 #include "bsp.h" 
 #include "main.h"
 #include "Algorithm.h"
 
-CS1238Var_t CS1238Var;
+#define	CS1237_DOUT_OUT()		PORT_OE(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx, Enable)
-static bool InitFlag;
+#define	CS1237_DOUT_IN()		PORT_OE(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx, Disable)
-static bool CS1238IrqFlag;
+#define	CS1237_DOUT_H()		SET_LEFTUP_CS1237_DOUT()
-static bool BuildDelay;
+#define	CS1237_DOUT_L()		CLR_LEFTUP_CS1237_DOUT()
-static uint8_t CS1238Port;
+#define  CS1237_DOUT_GET()		GET_LEFTUP_CS1237_DOUT()
-static uint8_t CS1238Hz;
-static uint8_t CS1238PGA;
-extern void CS1238Ain1DataProcessCallBack(int32_t AD);
-extern void CS1238Ain2DataProcessCallBack(int32_t AD);
-extern void CS1238TempDataProcessCallBack(int32_t AD);
-extern void CS1238JumpDataProcessCallBack(int32_t AD);
 
-/** cs1238 时序时钟*/
+#define	CS1237_SCLK_H()		SET_LEFTUP_CS1237_SCLK()
-static void CS1238_Clock(void)
+#define	CS1237_SCLK_L()		CLR_LEFTUP_CS1237_SCLK()
+
+#define	CS1237_5NS(x)			delay_5ns(x)				//5ns延时
+#define	CS1237_1US(x)			Ddl_Delay1us(x)			//1us延时
+#define	CS1237_1MS(x)			Ddl_Delay1ms(x)			//1ms延时
+
+#define 	CS1237IntEnable()		ExtInt10IntEnable()
+#define 	CS1237IntDisable()	ExtInt10IntDisable()
+
+LEFTUP_CS1237Var_t LEFTUP_CS1237Var;
+static bool InitFlag;
+static bool CS1237IrqFlag;
+static bool BuildDelay;
+static uint8_t CS1237Port;
+static uint8_t CS1237Hz;
+static uint8_t CS1237PGA;
+extern void LEFTUP_CS1237AinADataProcessCallBack(int32_t AD);
+
+
+/** cs1237 时序时钟*/
+static void CS1237_Clock(void)
 {
-    CS1238_SCLK_H();
+    CS1237_SCLK_H();
-    CS1238_100NS(3);
+    CS1237_5NS(60);
-    CS1238_SCLK_L();
+    CS1237_SCLK_L();
-    CS1238_100NS(3);
+    CS1237_5NS(60);
 }
-/** cs1238 休眠*/
+/** cs1237 休眠*/
-static void CS1238_Sleep(void)
+static void CS1237_Sleep(void)
 {
-    CS1238_SCLK_H();
+    CS1237_SCLK_H();
-    CS1238_1US(150);
+    CS1237_1US(200);
 }
-/** cs1238 唤醒*/
+/** cs1237 唤醒*/
-static void CS1238_WakeUp(void)
+static void CS1237_WakeUp(void)
 {
-    CS1238_SCLK_L();
+    CS1237_SCLK_L();
-    CS1238_1US(20);
+    CS1237_1US(20);
 }
-/**设置CS1238寄存器*/
+/**设置CS1237寄存器*/
-static void Set_CS1238_Config(uint8_t ad_reg)
+static void Set_CS1237_Config(uint8_t ad_reg)
 {
     uint16_t bit_cout = 0;
     uint8_t reg_temp = 0x00;
     //DOUT由高变低之后开始读取数据
-    CS1238_DOUT_OUT(); 
+    CS1237_DOUT_OUT(); 
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-    CS1238_DOUT_IN();
+    CS1237_DOUT_IN();
-	 CS1238_SCLK_L(); //时钟拉低
+	 CS1237_SCLK_L(); //时钟拉低
-	 CS1238Var.CS1238Delay1mSCnt = 300;
+	 LEFTUP_CS1237Var.CS1237Delay1mSCnt = 300;
-	 CS1238IrqFlag = false;
+	 CS1237IrqFlag = false;
-	 while(CS1238IrqFlag == false) //等待芯片准备好
+	 while(CS1237IrqFlag == false) //等待芯片准备好
     {
-		  if(CS1238Var.CS1238Delay1mSCnt <= 0){
+		  if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				DBG_LOG("CS1238 Preparation Timeout...\r\n");
+				//DBG_LOG("LEFTUP CS1237 Preparation Timeout...\r\n");
 				return;         // 超时退出
 		  }
     }
-	 CS1238IntDisable();
+	 CS1237IntDisable();
-	 CS1238IrqFlag = false;
+	 CS1237IrqFlag = false;
 
 	 
     /*  clk1-clk26 写期间不需要操作*/
     for (bit_cout = 0; bit_cout < 26; bit_cout++)
     {
-        CS1238_Clock(); //给一周期时钟
+        CS1237_Clock(); //给一周期时钟
     }
 	 /*  clk27  DOUT输出拉高*/
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
 	 /*  clk28 - clk29 发送写寄存器命令字 */
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
 	 
     /*  clk30 - clk36 发送写寄存器命令字 */
-	 CS1238_DOUT_OUT();
+	 CS1237_DOUT_OUT();
     reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
     for (bit_cout = 0; bit_cout < 7; bit_cout++)
     {
         if (reg_temp & 0x80) //MSB 
         {
-            CS1238_DOUT_H();
+            CS1237_DOUT_H();
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
-        CS1238_Clock();
+        CS1237_Clock();
     }
     /*  clk37写寄存器模式还是输出 */
-    CS1238_Clock();
+    CS1237_Clock();
     /*  clk38 ~ clk45 写入寄存器值 */
     reg_temp = ad_reg;//要配件的寄存器数值
     for (bit_cout = 0; bit_cout < 8; bit_cout++)
     {
         if (reg_temp & 0x80) //MSB
         {
-            CS1238_DOUT_H();
+            CS1237_DOUT_H();
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
-        CS1238_Clock();
+        CS1237_Clock();
     }
     /* 8: clk46 */
-	 CS1238_Clock();
+	 CS1237_Clock();
-    CS1238_DOUT_H();
+    CS1237_DOUT_H();
-	 CS1238_DOUT_IN();
+	 CS1237_DOUT_IN();
-	 CS1238IntEnable();
+	 CS1237IntEnable();
     return ;
 }
 
-/**读CS1238寄存器*/
+/**读CS1237寄存器*/
-static int32_t Read_CS1238_Config(void)
+static int32_t Read_CS1237_Config(void)
 {
     uint16_t bit_cout = 0;
     uint8_t reg_temp = 0x00;
     //DOUT由高变低之后开始读取数据
-    CS1238_DOUT_OUT();
+    CS1237_DOUT_OUT();
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-    CS1238_DOUT_IN();
+    CS1237_DOUT_IN();
-	 CS1238_SCLK_L(); //时钟拉低
+	 CS1237_SCLK_L(); //时钟拉低
-	 CS1238Var.CS1238Delay1mSCnt = 300;
+	 LEFTUP_CS1237Var.CS1237Delay1mSCnt = 300;
-	 CS1238IrqFlag = false;
+	 CS1237IrqFlag = false;
-	 while(CS1238IrqFlag == false) //等待芯片准备好
+	 while(CS1237IrqFlag == false) //等待芯片准备好
     {
-		  if(CS1238Var.CS1238Delay1mSCnt <= 0){
+		  if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				DBG_LOG("CS1238 Preparation Timeout...\r\n");
+				//DBG_LOG("LEFTUP CS1237 Preparation Timeout...\r\n");
 				return 0;         // 超时退出
 		  }
     }
-    CS1238IntDisable();
+    CS1237IntDisable();
-    CS1238IrqFlag = false;
+    CS1237IrqFlag = false;
 
     /*  clk1-clk26 写期间不需要操作*/
     for (bit_cout = 0; bit_cout < 26; bit_cout++)
     {
-        CS1238_Clock(); //给一周期时钟
+        CS1237_Clock(); //给一周期时钟
     }
 	 /*  clk27  DOUT输出拉高*/
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
 	 /*  clk28 - clk29 发送写寄存器命令字 */
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
 	 
     /*  clk30 - clk36 发送读寄存器命令字 */
-    CS1238_DOUT_OUT();
+    CS1237_DOUT_OUT();
 	 reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
     for (bit_cout = 0; bit_cout < 7; bit_cout++)
     {
         if (reg_temp & 0x80) //MSB 
         {
-            CS1238_DOUT_H();
+            CS1237_DOUT_H();
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
-        CS1238_Clock();
+        CS1237_Clock();
     }
     /*  clk37，读寄存器模式改输入 */
-    CS1238_Clock();
+    CS1237_Clock();
-	CS1238_DOUT_IN();
+	CS1237_DOUT_IN();
 	 for (bit_cout = 0; bit_cout < 8; bit_cout++)
 	 {
-		  CS1238_SCLK_H();
+		  CS1237_SCLK_H();
 		  reg_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1238_100NS(3);//延时300ns
+		  CS1237_5NS(60);//延时300ns
-		  if(GET_CS1238_DOUT() == true) //有数值则累加
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
 			reg_temp |= 1;
-		  CS1238_SCLK_L();
+		  CS1237_SCLK_L();
-		  CS1238_100NS(3);
+		  CS1237_5NS(60);
 	 }
     /* 8: clk46 */
-	 CS1238_Clock();
+	 CS1237_Clock();
-    CS1238_DOUT_IN();
+    CS1237_DOUT_IN();
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-	 CS1238IntEnable();
+	 CS1237IntEnable();
     return reg_temp ;
 }
-/**读取CS1238的AD数*/
+/**读取CS1237的AD数*/
-static int32_t Read_CS1238_Ad_Data(void)
+static int32_t Read_CS1237_Ad_Data(void)
 {
     uint16_t bit_cout = 0;
     int32_t data_temp = 0;
@@ -192,22 +206,22 @@ static int32_t Read_CS1238_Ad_Data(void)
     data_temp = 0;
 	 for (bit_cout = 0; bit_cout < 24; bit_cout++)
 	 {
-		  CS1238_SCLK_H();
+		  CS1237_SCLK_H();
 		  data_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1238_100NS(3);//延时300ns
+		  CS1237_5NS(60);//延时300ns
-		  if(GET_CS1238_DOUT() == true) //有数值则累加
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
 			data_temp |= 1;
-		  CS1238_SCLK_L();
+		  CS1237_SCLK_L();
-		  CS1238_100NS(3);
+		  CS1237_5NS(60);
 	 }
 		 
 	 /* clk25 ~ clk27 */
 	 for (bit_cout = 24; bit_cout < 27; bit_cout++)
 	 {
-		 CS1238_Clock(); //给一周期时钟
+		 CS1237_Clock(); //给一周期时钟
 	 }
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-	 CS1238_SCLK_L();
+	 CS1237_SCLK_L();
 	 
 	 if(data_temp > 0x7FFFFF) //取24位
 	 {
@@ -216,190 +230,172 @@ static int32_t Read_CS1238_Ad_Data(void)
     return data_temp; 
 }
 
-void CS1238_IrqCallBack(void)
+void LEFTUP_CS1237_IrqCallBack(void)
 {
-	CS1238IrqFlag = true;
+	CS1237IrqFlag = true;
 }
-void CS1238_Init(void)
+void LEFTUP_CS1237_Init(void)
 {
-	CS1238IrqFlag = false;
+	CS1237IrqFlag = false;
 	BuildDelay = false;
-	CS1238IntEnable();
+	LEFTUP_CS1237Var.AinA_AD = 0;
-	CS1238Var.Ain1_AD = 0;
+	LEFTUP_CS1237Var.Temp_AD = 0;
-	CS1238Var.Ain2_AD = 0;
+	LEFTUP_CS1237Var.Jump_AD = 0;
-	CS1238Var.Temp_AD = 0;
-	CS1238Var.Jump_AD = 0;
 	
-	CS1238Port = CH_SEL_A;
+	CS1237IntEnable();
-	CS1238Hz = SPEED_SEL_640Hz;
+	CS1237Port = CH_SEL_A;
-	CS1238PGA = PGA_SEL_128;
+	CS1237Hz = SPEED_SEL_640Hz;
+	CS1237PGA = PGA_SEL_128;
 	
 	uint8_t read_reg = 0x00;
-	uint8_t set_reg = REFO_ON | CS1238Hz | CS1238PGA | CS1238Port;
+	uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
-	CS1238_1MS(20);
+	CS1237_1MS(20);
-	Set_CS1238_Config(set_reg);
+	Set_CS1237_Config(set_reg);
-	CS1238_1MS(20);
+	CS1237_1MS(20);
-	read_reg = Read_CS1238_Config();
+	read_reg = Read_CS1237_Config();
-	CS1238_1MS(20);
+	CS1237_1MS(20);
 	if(read_reg != set_reg){
-		DBG_LOG("CS1238 Init ERR...\r\n");
+		DBG_LOG("LEFTUP CS1237 Init ERR...\r\n");
-		DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		InitFlag = false;
-	}
-	else {
-		DBG_LOG("CS1238 Init OK...\r\n");
 		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		CS1238Port = read_reg & 0x03;
 		InitFlag = true;
 	}
+	else {
+		DBG_LOG("LEFTUP CS1237 Init OK...\r\n");
+		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
+		CS1237Port = read_reg & 0x03;
+		InitFlag = true;
+	}
+	CS1237IntDisable();
 }
-void CS1238DataLoopCollect(void)
+void LEFTUP_CS1237DataLoopCollect(void)
 { 
 	static int32_t ad_array[PACK_NUM];
 	static uint8_t adcnt;
 	static uint8_t TimeOutmagcnt;
 	
-	switch(CS1238Var.Status) {
+	switch(LEFTUP_CS1237Var.Status) {
-		case CS1238_STATUS_IDLE:{
+		case LUCS1237_STATUS_IDLE:{
 		break;}
 		
-		case CS1238_STATUS_START:{
+		case LUCS1237_STATUS_START:{
 			memset(&ad_array, 0x00, sizeof(ad_array));
 			adcnt = 0;
 			TimeOutmagcnt = 0;
-			memset(&CS1238Var, NULL, sizeof(CS1238Var));
+			memset(&LEFTUP_CS1237Var, NULL, sizeof(LEFTUP_CS1237Var));
 			if(BuildDelay == true)
 			{
 				BuildDelay = false;
-				if(CS1238Hz == SPEED_SEL_10Hz){
+				if(CS1237Hz == SPEED_SEL_10Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_10Hz;
+					LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
 				}
-				if(CS1238Hz == SPEED_SEL_40Hz){
+				if(CS1237Hz == SPEED_SEL_40Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_40Hz;
+					LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
 				}
-				if(CS1238Hz == SPEED_SEL_640Hz){
+				if(CS1237Hz == SPEED_SEL_640Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_640Hz;
+					LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
 				}
-				if(CS1238Hz == SPEED_SEL6_1280Hz){
+				if(CS1237Hz == SPEED_SEL6_1280Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_1280Hz;
+					LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
 				}
-				CS1238Var.Status = CS1238_STATUS_DELAY;
+				LEFTUP_CS1237Var.Status = LUCS1237_STATUS_DELAY;
 			}
 			else
 			{
-				CS1238Var.Status = CS1238_STATUS_READ;
+				LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
 			}
 		break;}
 		
-		case CS1238_STATUS_DELAY:{
+		case LUCS1237_STATUS_DELAY:{
-			if(CS1238Var.CS1238Delay1mSCnt <= 0){
+			if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				CS1238Var.Status = CS1238_STATUS_READ;
+				LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
 			}		
 		break;}
 		
-		case CS1238_STATUS_READ:{
+		case LUCS1237_STATUS_READ:{
-			CS1238IrqFlag = false;
+			CS1237IrqFlag = false;
-			CS1238Var.CS1238Delay1mSCnt = 100;
+			LEFTUP_CS1237Var.CS1237Delay1mSCnt = 100;
-			CS1238Var.Status = CS1238_STATUS_WAIT_READ;
+			LEFTUP_CS1237Var.Status = LUCS1237_STATUS_WAIT_READ;
 		break;}
 		
-		case	CS1238_STATUS_WAIT_READ:{
+		case	LUCS1237_STATUS_WAIT_READ:{
-			if(CS1238Var.CS1238Delay1mSCnt <= 0){
+			if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				CS1238Var.Status = CS1238_STATUS_READ;
+				LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
 				TimeOutmagcnt++;
 			}
-			if(CS1238IrqFlag == true){
+			if(CS1237IrqFlag == true){
-				CS1238IrqFlag = false;
+				CS1237IrqFlag = false;
-				ad_array[adcnt++] = Read_CS1238_Ad_Data();
+				ad_array[adcnt++] = Read_CS1237_Ad_Data();
-				CS1238Var.Status = CS1238_STATUS_READ;
+				LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
 			}
 			if(TimeOutmagcnt >= PACK_NUM){
 				TimeOutmagcnt = 0;
 				if(adcnt > 0){
-					if(CS1238Port == CH_SEL_A){
+					if(CS1237Port == CH_SEL_A){
-						CS1238Var.Ain1_AD = IntFilter_32t(ad_array, adcnt, 4);
+						LEFTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain1DataProcessCallBack(CS1238Var.Ain1_AD);
+						LEFTUP_CS1237AinADataProcessCallBack(LEFTUP_CS1237Var.AinA_AD);
 					}
-					if(CS1238Port == CH_SEL_B){
+					if(CS1237Port == CH_SEL_TEMP){
-						CS1238Var.Ain2_AD = IntFilter_32t(ad_array, adcnt, 4);
+						LEFTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain2DataProcessCallBack(CS1238Var.Ain2_AD);
+						//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
 					}
-					if(CS1238Port == CH_SEL_TEMP){
+					if(CS1237Port == CH_SEL_JUMP){
-						CS1238Var.Temp_AD = IntFilter_32t(ad_array, adcnt, 4);
+						LEFTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238TempDataProcessCallBack(CS1238Var.Temp_AD);
+						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
 					}
-					if(CS1238Port == CH_SEL_JUMP){
+					LEFTUP_CS1237Var.Status = LUCS1237_STATUS_CH_SEL;
-						CS1238Var.Jump_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238JumpDataProcessCallBack(CS1238Var.Jump_AD);
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
 				}
 				else{
-					if(CS1238Port == CH_SEL_A){
+					if(CS1237Port == CH_SEL_A){
-						DBG_LOG("CS1238 CHA TimeOut...\r\n"); 
+						DBG_LOG("LEFTUPs CS1237 CHA TimeOut...\r\n"); 
 					}
-					if(CS1238Port == CH_SEL_B){
+					if(CS1237Port == CH_SEL_TEMP){
-						DBG_LOG("CS1238 CHB TimeOut...\r\n"); 
+						DBG_LOG("LEFTUP CS1237 Temp TimeOut...\r\n"); 
 					}
-					if(CS1238Port == CH_SEL_TEMP){
+					if(CS1237Port == CH_SEL_JUMP){
-						DBG_LOG("CS1238 Temp TimeOut...\r\n"); 
+						DBG_LOG("LEFTUP CS1237 Jump TimeOut...\r\n"); 
 					}
-					if(CS1238Port == CH_SEL_JUMP){
+					LEFTUP_CS1237Var.Status = LUCS1237_STATUS_CH_SEL;
-						DBG_LOG("CS1238 Jump TimeOut...\r\n"); 
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
 				}
 			}
 			if(adcnt >= PACK_NUM){
-				if(CS1238Port == CH_SEL_A){
+				if(CS1237Port == CH_SEL_A){
-						CS1238Var.Ain1_AD = IntFilter_32t(ad_array, adcnt, 4);
+						LEFTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain1DataProcessCallBack(CS1238Var.Ain1_AD);
+						LEFTUP_CS1237AinADataProcessCallBack(LEFTUP_CS1237Var.AinA_AD);
 					}
-					if(CS1238Port == CH_SEL_B){
+					if(CS1237Port == CH_SEL_TEMP){
-						CS1238Var.Ain2_AD = IntFilter_32t(ad_array, adcnt, 4);
+						LEFTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain2DataProcessCallBack(CS1238Var.Ain2_AD);
+						//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
 					}
-					if(CS1238Port == CH_SEL_TEMP){
+					if(CS1237Port == CH_SEL_JUMP){
-						CS1238Var.Temp_AD = IntFilter_32t(ad_array, adcnt, 4);
+						LEFTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238TempDataProcessCallBack(CS1238Var.Temp_AD);
+						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
 					}
-					if(CS1238Port == CH_SEL_JUMP){
+					LEFTUP_CS1237Var.Status = LUCS1237_STATUS_CH_SEL;
-						CS1238Var.Jump_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238JumpDataProcessCallBack(CS1238Var.Jump_AD);
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
 			}
 		break;}
 		
-		case CS1238_STATUS_CH_SEL:{
+		case LUCS1237_STATUS_CH_SEL:{
-			CS1238Var.Status = CS1238_STATUS_STOP;
+			LEFTUP_CS1237Var.Status = LUCS1237_STATUS_STOP;
 			BuildDelay = false;
 			uint8_t read_reg;
-			if(CS1238Port == CH_SEL_A){
+			if(CS1237Port == CH_SEL_A){
 #if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
+			CS1237Port = CH_SEL_TEMP;
 			BuildDelay = true;
 			break;
 #endif
 #if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
+			CS1237Port = CH_SEL_JUMP;
 			BuildDelay = true;
 			break;
 #endif
 			}
 			
-			if(CS1238Port == CH_SEL_B){
+			if(CS1237Port == CH_SEL_TEMP){
-#if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
-			BuildDelay = true;
-			break;
-#endif
 #if(PORT_JUMP == 1)
 			read_reg = Read_CS1238_Config();
 			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
@@ -408,77 +404,60 @@ void CS1238DataLoopCollect(void)
 			break;
 #endif
 #if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
+			CS1237Port = CH_SEL_A;
 			BuildDelay = true;
 			break;
 #endif
 		}
 		
-			if(CS1238Port == CH_SEL_TEMP){
+			if(CS1237Port == CH_SEL_JUMP){
-#if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
-			BuildDelay = true;
-			break;
-#endif
 #if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
+			CS1237Port = CH_SEL_A;
-			BuildDelay = true;
-			break;
-#endif
-		}
-		
-			if(CS1238Port == CH_SEL_JUMP){
-#if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
 			BuildDelay = true;
 			break;
 #endif
 #if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
+			CS1237Port = CH_SEL_TEMP;
 			BuildDelay = true;
 			break;
 #endif
 		}
 		break;}
 		
-		case CS1238_STATUS_STOP:{
+		case LUCS1237_STATUS_STOP:{
-			//CS1238Stop();
+			LEFTUP_CS1237Stop();
-			//CS1238Var.Status = CS1238_STATUS_IDLE;
+			LEFTUP_CS1237Var.Status = LUCS1237_STATUS_IDLE;
-			CS1238Var.Status = CS1238_STATUS_START;//持续工作
+			//LEFTUP_CS1237Var.Status = LUCS1237_STATUS_START;//持续工作
 		break;}
 	}
 }
-void CS12381mSRoutine(void)
+void LEFTUP_CS12371mSRoutine(void)
 {
-	if(CS1238Var.CS1238Delay1mSCnt > 0) 
+	if(LEFTUP_CS1237Var.CS1237Delay1mSCnt > 0) 
-		CS1238Var.CS1238Delay1mSCnt--;
+		LEFTUP_CS1237Var.CS1237Delay1mSCnt--;
 }
-void CS1238Start(void)
+void LEFTUP_CS1237Start(void)
 {
-	CS1238_WakeUp();
+	CS1237_WakeUp();
-	CS1238_1MS(2);
+	CS1237_1MS(2);
 	BuildDelay = true;
-	CS1238IntEnable();
+	CS1237IntEnable();
 	if(!InitFlag){
-		CS1238_Init();
+		LEFTUP_CS1237_Init();
 		return;
 	}
-	CS1238Var.Status = CS1238_STATUS_START;
+	LEFTUP_CS1237Var.Status = LUCS1237_STATUS_START;
 }
-void CS1238Stop(void)
+void LEFTUP_CS1237Stop(void)
 {
-	CS1238IntDisable();
+	CS1237IntDisable();
-	CS1238_Sleep();
+	//CS1237_Sleep();
 }
 
 

Project/HC32F460/source/Module/CS1237/CS1237_LEFTUP.h

@@ -1,7 +1,7 @@
 #include "bsp.h" 
 
-#ifndef _CS1238_H_ 
+#ifndef _CS1237_LEFTUP_H_ 
-#define _CS1238_H_ 
+#define _CS1237_LEFTUP_H_ 
 
 #define	READ_CONFIG_CMD		0x56
 #define	WRITE_CONFIG_CMD		0x65
@@ -22,21 +22,11 @@
 #define	PGA_SEL_128				0x0C
 
 #define	CH_SEL_A					0x00
-#define	CH_SEL_B					0x01
+//#define	CH_SEL_B					0x01
 #define	CH_SEL_TEMP				0x02
 #define	CH_SEL_JUMP				0x03
 
-#define	CS1238_DOUT_OUT()		SetBit(((uint32_t)&M0P_GPIO->PADIR + CS1238_DOUT_PORTx), CS1238_DOUT_PINx, 0)
-#define	CS1238_DOUT_IN()		SetBit(((uint32_t)&M0P_GPIO->PADIR + CS1238_DOUT_PORTx), CS1238_DOUT_PINx, 1)
-#define	CS1238_DOUT_H()		SET_CS1238_DOUT()
-#define	CS1238_DOUT_L()		CLR_CS1238_DOUT()
 
-#define	CS1238_SCLK_H()		SET_CS1238_SCLK()
-#define	CS1238_SCLK_L()		CLR_CS1238_SCLK()
-
-#define	CS1238_1US(x)				delay_us(x)			//1us延时
-#define	CS1238_100NS(x)			delay_ns(x)			//100ns延时
-#define	CS1238_1MS(x)				delay_ms(x)			//1ms延时
 
 /*Definition of conversion time corresponding to repeatability setting*/
 /*
@@ -51,40 +41,39 @@
 #define tCon_1280Hz		4	/* ms. */
 
 #define  PORT_A	  		1						//采集通道A
-#define  PORT_B	  		1						//采集通道B
+//#define  PORT_B	  		1						//采集通道B
 #define  PORT_TEMP	   0						//采集温度
 #define  PORT_JUMP	   0						//内短采集
-#define	 PACK_NUM			10						//一次采集的数据包数量
+#define	PACK_NUM		   1						//一次采集的数据包数量
+#define	FILTER_NUM		0						//滤波数
 
 typedef enum{
-	CS1238_STATUS_IDLE,
+	LUCS1237_STATUS_IDLE,
-	CS1238_STATUS_START,
+	LUCS1237_STATUS_START,
-	CS1238_STATUS_DELAY,
+	LUCS1237_STATUS_DELAY,
-	CS1238_STATUS_READ,
+	LUCS1237_STATUS_READ,
-	CS1238_STATUS_WAIT_READ,
+	LUCS1237_STATUS_WAIT_READ,
-	CS1238_STATUS_CH_SEL,
+	LUCS1237_STATUS_CH_SEL,
-	CS1238_STATUS_STOP,
+	LUCS1237_STATUS_STOP,
-}CS1238Status_m;
+}LeftUpCS1237Status_m;
 
 typedef struct{
-	CS1238Status_m Status;
+	LeftUpCS1237Status_m Status;
-	uint32_t CS1238Delay1mSCnt;
+	uint32_t CS1237Delay1mSCnt;
 	
-	int32_t Ain1_AD;//AIN1ad数据
+	int32_t AinA_AD;//AINAad数据
-	int32_t Ain2_AD;//AIN2ad数据	
+	//int32_t AinB_AD;//AINBad数据	
 	int32_t Temp_AD;//温度ad数据
 	int32_t Jump_AD;//内短ad数据	
 }
-CS1238Var_t;
+LEFTUP_CS1237Var_t;
-extern CS1238Var_t CS1238Var;
 
-void CS1238_Init(void);
+void LEFTUP_CS1237_Init(void);
-void CS1238_IrqCallBack(void);
+void LEFTUP_CS1237_IrqCallBack(void);
-void CS1238DataLoopCollect(void);
+void LEFTUP_CS1237DataLoopCollect(void);
-void CS1238LoopHandler(void); 
+void LEFTUP_CS12371mSRoutine(void);
-void CS12381mSRoutine(void);
+void LEFTUP_CS1237Start(void);
-void CS1238Start(void);
+void LEFTUP_CS1237Stop(void);
-void CS1238Stop(void);
 #endif 
 
 

Project/HC32F460/source/Module/CS1237/CS1237_RIGHRLOW.c

@@ -1,485 +0,0 @@
-#include "CS1238.h" 
-#include "UartDebug.h"
-#include "bsp.h" 
-#include "main.h"
-#include "Algorithm.h"
-
-CS1238Var_t CS1238Var;
-static bool InitFlag;
-static bool CS1238IrqFlag;
-static bool BuildDelay;
-static uint8_t CS1238Port;
-static uint8_t CS1238Hz;
-static uint8_t CS1238PGA;
-extern void CS1238Ain1DataProcessCallBack(int32_t AD);
-extern void CS1238Ain2DataProcessCallBack(int32_t AD);
-extern void CS1238TempDataProcessCallBack(int32_t AD);
-extern void CS1238JumpDataProcessCallBack(int32_t AD);
-
-/** cs1238 时序时钟*/
-static void CS1238_Clock(void)
-{
-    CS1238_SCLK_H();
-    CS1238_100NS(3);
-    CS1238_SCLK_L();
-    CS1238_100NS(3);
-}
-/** cs1238 休眠*/
-static void CS1238_Sleep(void)
-{
-    CS1238_SCLK_H();
-    CS1238_1US(150);
-}
-/** cs1238 唤醒*/
-static void CS1238_WakeUp(void)
-{
-    CS1238_SCLK_L();
-    CS1238_1US(20);
-}
-/**设置CS1238寄存器*/
-static void Set_CS1238_Config(uint8_t ad_reg)
-{
-    uint16_t bit_cout = 0;
-    uint8_t reg_temp = 0x00;
-    //DOUT由高变低之后开始读取数据
-    CS1238_DOUT_OUT(); 
-	 CS1238_DOUT_H();
-    CS1238_DOUT_IN();
-	 CS1238_SCLK_L(); //时钟拉低
-	 CS1238Var.CS1238Delay1mSCnt = 300;
-	 CS1238IrqFlag = false;
-	 while(CS1238IrqFlag == false) //等待芯片准备好
-    {
-		  if(CS1238Var.CS1238Delay1mSCnt <= 0){
-				DBG_LOG("CS1238 Preparation Timeout...\r\n");
-				return;         // 超时退出
-		  }
-    }
-	 CS1238IntDisable();
-	 CS1238IrqFlag = false;
-
-	 
-    /*  clk1-clk26 写期间不需要操作*/
-    for (bit_cout = 0; bit_cout < 26; bit_cout++)
-    {
-        CS1238_Clock(); //给一周期时钟
-    }
-	 /*  clk27  DOUT输出拉高*/
-	 CS1238_Clock(); //给一周期时钟
-	 CS1238_DOUT_H();
-	 /*  clk28 - clk29 发送写寄存器命令字 */
-	 CS1238_Clock(); //给一周期时钟
-	 CS1238_Clock(); //给一周期时钟
-	 
-    /*  clk30 - clk36 发送写寄存器命令字 */
-	 CS1238_DOUT_OUT();
-    reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
-    for (bit_cout = 0; bit_cout < 7; bit_cout++)
-    {
-        if (reg_temp & 0x80) //MSB 
-        {
-            CS1238_DOUT_H();
-        }
-        else
-        {
-            CS1238_DOUT_L();
-        }
-        reg_temp = reg_temp << 1;
-        CS1238_Clock();
-    }
-    /*  clk37写寄存器模式还是输出 */
-    CS1238_Clock();
-    /*  clk38 ~ clk45 写入寄存器值 */
-    reg_temp = ad_reg;//要配件的寄存器数值
-    for (bit_cout = 0; bit_cout < 8; bit_cout++)
-    {
-        if (reg_temp & 0x80) //MSB
-        {
-            CS1238_DOUT_H();
-        }
-        else
-        {
-            CS1238_DOUT_L();
-        }
-        reg_temp = reg_temp << 1;
-        CS1238_Clock();
-    }
-    /* 8: clk46 */
-	 CS1238_Clock();
-    CS1238_DOUT_H();
-	 CS1238_DOUT_IN();
-	 CS1238IntEnable();
-    return ;
-}
-
-/**读CS1238寄存器*/
-static int32_t Read_CS1238_Config(void)
-{
-    uint16_t bit_cout = 0;
-    uint8_t reg_temp = 0x00;
-    //DOUT由高变低之后开始读取数据
-    CS1238_DOUT_OUT();
-	 CS1238_DOUT_H();
-    CS1238_DOUT_IN();
-	 CS1238_SCLK_L(); //时钟拉低
-	 CS1238Var.CS1238Delay1mSCnt = 300;
-	 CS1238IrqFlag = false;
-	 while(CS1238IrqFlag == false) //等待芯片准备好
-    {
-		  if(CS1238Var.CS1238Delay1mSCnt <= 0){
-				DBG_LOG("CS1238 Preparation Timeout...\r\n");
-				return 0;         // 超时退出
-		  }
-    }
-    CS1238IntDisable();
-    CS1238IrqFlag = false;
-
-    /*  clk1-clk26 写期间不需要操作*/
-    for (bit_cout = 0; bit_cout < 26; bit_cout++)
-    {
-        CS1238_Clock(); //给一周期时钟
-    }
-	 /*  clk27  DOUT输出拉高*/
-	 CS1238_Clock(); //给一周期时钟
-	 CS1238_DOUT_H();
-	 /*  clk28 - clk29 发送写寄存器命令字 */
-	 CS1238_Clock(); //给一周期时钟
-	 CS1238_Clock(); //给一周期时钟
-	 
-    /*  clk30 - clk36 发送读寄存器命令字 */
-    CS1238_DOUT_OUT();
-	 reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
-    for (bit_cout = 0; bit_cout < 7; bit_cout++)
-    {
-        if (reg_temp & 0x80) //MSB 
-        {
-            CS1238_DOUT_H();
-        }
-        else
-        {
-            CS1238_DOUT_L();
-        }
-        reg_temp = reg_temp << 1;
-        CS1238_Clock();
-    }
-    /*  clk37，读寄存器模式改输入 */
-    CS1238_Clock();
-	CS1238_DOUT_IN();
-	 for (bit_cout = 0; bit_cout < 8; bit_cout++)
-	 {
-		  CS1238_SCLK_H();
-		  reg_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1238_100NS(3);//延时300ns
-		  if(GET_CS1238_DOUT() == true) //有数值则累加
-			reg_temp |= 1;
-		  CS1238_SCLK_L();
-		  CS1238_100NS(3);
-	 }
-    /* 8: clk46 */
-	 CS1238_Clock();
-    CS1238_DOUT_IN();
-	 CS1238_DOUT_H();
-	 CS1238IntEnable();
-    return reg_temp ;
-}
-/**读取CS1238的AD数*/
-static int32_t Read_CS1238_Ad_Data(void)
-{
-    uint16_t bit_cout = 0;
-    int32_t data_temp = 0;
-
-    /* clk1 ~ clk24 ADC数据*/
-    data_temp = 0;
-	 for (bit_cout = 0; bit_cout < 24; bit_cout++)
-	 {
-		  CS1238_SCLK_H();
-		  data_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1238_100NS(3);//延时300ns
-		  if(GET_CS1238_DOUT() == true) //有数值则累加
-			data_temp |= 1;
-		  CS1238_SCLK_L();
-		  CS1238_100NS(3);
-	 }
-		 
-	 /* clk25 ~ clk27 */
-	 for (bit_cout = 24; bit_cout < 27; bit_cout++)
-	 {
-		 CS1238_Clock(); //给一周期时钟
-	 }
-	 CS1238_DOUT_H();
-	 CS1238_SCLK_L();
-	 
-	 if(data_temp > 0x7FFFFF) //取24位
-	 {
-		 data_temp |= 0xFF000000;
-	 } 
-    return data_temp; 
-}
-
-void CS1238_IrqCallBack(void)
-{
-	CS1238IrqFlag = true;
-}
-void CS1238_Init(void)
-{
-	CS1238IrqFlag = false;
-	BuildDelay = false;
-	CS1238IntEnable();
-	CS1238Var.Ain1_AD = 0;
-	CS1238Var.Ain2_AD = 0;
-	CS1238Var.Temp_AD = 0;
-	CS1238Var.Jump_AD = 0;
-	
-	CS1238Port = CH_SEL_A;
-	CS1238Hz = SPEED_SEL_640Hz;
-	CS1238PGA = PGA_SEL_128;
-	
-	uint8_t read_reg = 0x00;
-	uint8_t set_reg = REFO_ON | CS1238Hz | CS1238PGA | CS1238Port;
-	CS1238_1MS(20);
-	Set_CS1238_Config(set_reg);
-	CS1238_1MS(20);
-	read_reg = Read_CS1238_Config();
-	CS1238_1MS(20);
-	if(read_reg != set_reg){
-		DBG_LOG("CS1238 Init ERR...\r\n");
-		DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		InitFlag = false;
-	}
-	else {
-		DBG_LOG("CS1238 Init OK...\r\n");
-		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		CS1238Port = read_reg & 0x03;
-		InitFlag = true;
-	}
-}
-void CS1238DataLoopCollect(void)
-{ 
-	static int32_t ad_array[PACK_NUM];
-	static uint8_t adcnt;
-	static uint8_t TimeOutmagcnt;
-	
-	switch(CS1238Var.Status) {
-		case CS1238_STATUS_IDLE:{
-		break;}
-		
-		case CS1238_STATUS_START:{
-			memset(&ad_array, 0x00, sizeof(ad_array));
-			adcnt = 0;
-			TimeOutmagcnt = 0;
-			memset(&CS1238Var, NULL, sizeof(CS1238Var));
-			if(BuildDelay == true)
-			{
-				BuildDelay = false;
-				if(CS1238Hz == SPEED_SEL_10Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_10Hz;
-				}
-				if(CS1238Hz == SPEED_SEL_40Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_40Hz;
-				}
-				if(CS1238Hz == SPEED_SEL_640Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_640Hz;
-				}
-				if(CS1238Hz == SPEED_SEL6_1280Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_1280Hz;
-				}
-				CS1238Var.Status = CS1238_STATUS_DELAY;
-			}
-			else
-			{
-				CS1238Var.Status = CS1238_STATUS_READ;
-			}
-		break;}
-		
-		case CS1238_STATUS_DELAY:{
-			if(CS1238Var.CS1238Delay1mSCnt <= 0){
-				CS1238Var.Status = CS1238_STATUS_READ;
-			}		
-		break;}
-		
-		case CS1238_STATUS_READ:{
-			CS1238IrqFlag = false;
-			CS1238Var.CS1238Delay1mSCnt = 100;
-			CS1238Var.Status = CS1238_STATUS_WAIT_READ;
-		break;}
-		
-		case	CS1238_STATUS_WAIT_READ:{
-			if(CS1238Var.CS1238Delay1mSCnt <= 0){
-				CS1238Var.Status = CS1238_STATUS_READ;
-				TimeOutmagcnt++;
-			}
-			if(CS1238IrqFlag == true){
-				CS1238IrqFlag = false;
-				ad_array[adcnt++] = Read_CS1238_Ad_Data();
-				CS1238Var.Status = CS1238_STATUS_READ;
-			}
-			if(TimeOutmagcnt >= PACK_NUM){
-				TimeOutmagcnt = 0;
-				if(adcnt > 0){
-					if(CS1238Port == CH_SEL_A){
-						CS1238Var.Ain1_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238Ain1DataProcessCallBack(CS1238Var.Ain1_AD);
-					}
-					if(CS1238Port == CH_SEL_B){
-						CS1238Var.Ain2_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238Ain2DataProcessCallBack(CS1238Var.Ain2_AD);
-					}
-					if(CS1238Port == CH_SEL_TEMP){
-						CS1238Var.Temp_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238TempDataProcessCallBack(CS1238Var.Temp_AD);
-					}
-					if(CS1238Port == CH_SEL_JUMP){
-						CS1238Var.Jump_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238JumpDataProcessCallBack(CS1238Var.Jump_AD);
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
-				}
-				else{
-					if(CS1238Port == CH_SEL_A){
-						DBG_LOG("CS1238 CHA TimeOut...\r\n"); 
-					}
-					if(CS1238Port == CH_SEL_B){
-						DBG_LOG("CS1238 CHB TimeOut...\r\n"); 
-					}
-					if(CS1238Port == CH_SEL_TEMP){
-						DBG_LOG("CS1238 Temp TimeOut...\r\n"); 
-					}
-					if(CS1238Port == CH_SEL_JUMP){
-						DBG_LOG("CS1238 Jump TimeOut...\r\n"); 
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
-				}
-			}
-			if(adcnt >= PACK_NUM){
-				if(CS1238Port == CH_SEL_A){
-						CS1238Var.Ain1_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238Ain1DataProcessCallBack(CS1238Var.Ain1_AD);
-					}
-					if(CS1238Port == CH_SEL_B){
-						CS1238Var.Ain2_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238Ain2DataProcessCallBack(CS1238Var.Ain2_AD);
-					}
-					if(CS1238Port == CH_SEL_TEMP){
-						CS1238Var.Temp_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238TempDataProcessCallBack(CS1238Var.Temp_AD);
-					}
-					if(CS1238Port == CH_SEL_JUMP){
-						CS1238Var.Jump_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238JumpDataProcessCallBack(CS1238Var.Jump_AD);
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
-			}
-		break;}
-		
-		case CS1238_STATUS_CH_SEL:{
-			CS1238Var.Status = CS1238_STATUS_STOP;
-			BuildDelay = false;
-			uint8_t read_reg;
-			if(CS1238Port == CH_SEL_A){
-#if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
-			BuildDelay = true;
-			break;
-#endif
-#if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
-			BuildDelay = true;
-			break;
-#endif
-			}
-			
-			if(CS1238Port == CH_SEL_B){
-#if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
-			BuildDelay = true;
-			break;
-#endif
-#if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
-			BuildDelay = true;
-			break;
-#endif
-#if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
-			BuildDelay = true;
-			break;
-#endif
-		}	
-			
-			if(CS1238Port == CH_SEL_TEMP){
-#if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
-			BuildDelay = true;
-			break;
-#endif
-#if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
-			BuildDelay = true;
-			break;
-#endif
-		}
-		
-			if(CS1238Port == CH_SEL_JUMP){
-#if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
-			BuildDelay = true;
-			break;
-#endif
-#if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
-			BuildDelay = true;
-			break;
-#endif
-		}
-		break;}
-		
-		case CS1238_STATUS_STOP:{
-			//CS1238Stop();
-			//CS1238Var.Status = CS1238_STATUS_IDLE;
-			CS1238Var.Status = CS1238_STATUS_START;//持续工作
-		break;}
-	}
-}
-void CS12381mSRoutine(void)
-{
-	if(CS1238Var.CS1238Delay1mSCnt > 0) 
-		CS1238Var.CS1238Delay1mSCnt--;
-}
-void CS1238Start(void)
-{
-	CS1238_WakeUp();
-	CS1238_1MS(2);
-	BuildDelay = true;
-	CS1238IntEnable();
-	if(!InitFlag){
-		CS1238_Init();
-		return;
-	}
-	CS1238Var.Status = CS1238_STATUS_START;
-}
-void CS1238Stop(void)
-{
-	CS1238IntDisable();
-	CS1238_Sleep();
-}
-
-
-

Project/HC32F460/source/Module/CS1237/CS1237_RIGHRLOW.h

@@ -1,91 +0,0 @@
-#include "bsp.h" 
-
-#ifndef _CS1238_H_ 
-#define _CS1238_H_ 
-
-#define	READ_CONFIG_CMD		0x56
-#define	WRITE_CONFIG_CMD		0x65
-
-#define	CONFIG_RST				0x0C
-
-#define	REFO_OFF					0x40
-#define	REFO_ON					0x00
-
-#define	SPEED_SEL_10Hz			0x00
-#define	SPEED_SEL_40Hz			0x10
-#define	SPEED_SEL_640Hz		0x20
-#define	SPEED_SEL6_1280Hz		0x30
-
-#define	PGA_SEL_1				0x00
-#define	PGA_SEL_2				0x04
-#define	PGA_SEL_64				0x08
-#define	PGA_SEL_128				0x0C
-
-#define	CH_SEL_A					0x00
-#define	CH_SEL_B					0x01
-#define	CH_SEL_TEMP				0x02
-#define	CH_SEL_JUMP				0x03
-
-#define	CS1238_DOUT_OUT()		SetBit(((uint32_t)&M0P_GPIO->PADIR + CS1238_DOUT_PORTx), CS1238_DOUT_PINx, 0)
-#define	CS1238_DOUT_IN()		SetBit(((uint32_t)&M0P_GPIO->PADIR + CS1238_DOUT_PORTx), CS1238_DOUT_PINx, 1)
-#define	CS1238_DOUT_H()		SET_CS1238_DOUT()
-#define	CS1238_DOUT_L()		CLR_CS1238_DOUT()
-
-#define	CS1238_SCLK_H()		SET_CS1238_SCLK()
-#define	CS1238_SCLK_L()		CLR_CS1238_SCLK()
-
-#define	CS1238_1US(x)				delay_us(x)			//1us延时
-#define	CS1238_100NS(x)			delay_ns(x)			//100ns延时
-#define	CS1238_1MS(x)				delay_ms(x)			//1ms延时
-
-/*Definition of conversion time corresponding to repeatability setting*/
-/*
-	10Hz     	//建立时间300ms
-	40Hz	  		//建立时间75ms
-	640Hz    	//建立时间6.25ms
-	1280Hz    	//建立时间3.125ms
-*/
-#define tCon_10Hz			300	/* ms. */
-#define tCon_40Hz			75	/* ms. */
-#define tCon_640Hz		7	/* ms. */
-#define tCon_1280Hz		4	/* ms. */
-
-#define  PORT_A	  		1						//采集通道A
-#define  PORT_B	  		1						//采集通道B
-#define  PORT_TEMP	  0						//采集温度
-#define  PORT_JUMP	  0						//内短采集
-#define	 PACK_NUM			10						//一次采集的数据包数量
-
-typedef enum{
-	CS1238_STATUS_IDLE,
-	CS1238_STATUS_START,
-	CS1238_STATUS_DELAY,
-	CS1238_STATUS_READ,
-	CS1238_STATUS_WAIT_READ,
-	CS1238_STATUS_CH_SEL,
-	CS1238_STATUS_STOP,
-}CS1238Status_m;
-
-typedef struct{
-	CS1238Status_m Status;
-	uint32_t CS1238Delay1mSCnt;
-	
-	int32_t Ain1_AD;//AIN1ad数据
-	int32_t Ain2_AD;//AIN2ad数据	
-	int32_t Temp_AD;//温度ad数据
-	int32_t Jump_AD;//内短ad数据	
-}
-CS1238Var_t;
-extern CS1238Var_t CS1238Var;
-
-void CS1238_Init(void);
-void CS1238_IrqCallBack(void);
-void CS1238DataLoopCollect(void);
-void CS1238LoopHandler(void); 
-void CS12381mSRoutine(void);
-void CS1238Start(void);
-void CS1238Stop(void);
-#endif 
-
-
-

Project/HC32F460/source/Module/CS1237/CS1237_RIGHTLOW.c

@@ -0,0 +1,464 @@
+#include "CS1237_RIGHTLOW.h" 
+#include "Debug.h"
+#include "bsp.h" 
+#include "main.h"
+#include "Algorithm.h"
+
+#define	CS1237_DOUT_OUT()		PORT_OE(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx, Enable)
+#define	CS1237_DOUT_IN()		PORT_OE(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx, Disable)
+#define	CS1237_DOUT_H()		SET_RIGHTLOW_CS1237_DOUT()
+#define	CS1237_DOUT_L()		CLR_RIGHTLOW_CS1237_DOUT()
+#define  CS1237_DOUT_GET()		GET_RIGHTLOW_CS1237_DOUT()
+
+#define	CS1237_SCLK_H()		SET_RIGHTLOW_CS1237_SCLK()
+#define	CS1237_SCLK_L()		CLR_RIGHTLOW_CS1237_SCLK()
+
+#define	CS1237_5NS(x)			delay_5ns(x)				//5ns延时
+#define	CS1237_1US(x)			Ddl_Delay1us(x)			//1us延时
+#define	CS1237_1MS(x)			Ddl_Delay1ms(x)			//1ms延时
+
+#define 	CS1237IntEnable()		ExtInt06IntEnable()
+#define 	CS1237IntDisable()	ExtInt06IntDisable()
+
+RIGHTLOW_CS1237Var_t RIGHTLOW_CS1237Var;
+static bool InitFlag;
+static bool CS1237IrqFlag;
+static bool BuildDelay;
+static uint8_t CS1237Port;
+static uint8_t CS1237Hz;
+static uint8_t CS1237PGA;
+extern void RIGHTLOW_CS1237AinADataProcessCallBack(int32_t AD);
+
+
+/** cs1237 时序时钟*/
+static void CS1237_Clock(void)
+{
+    CS1237_SCLK_H();
+    CS1237_5NS(60);
+    CS1237_SCLK_L();
+    CS1237_5NS(60);
+}
+/** cs1237 休眠*/
+static void CS1237_Sleep(void)
+{
+    CS1237_SCLK_H();
+    CS1237_1US(200);
+}
+/** cs1237 唤醒*/
+static void CS1237_WakeUp(void)
+{
+    CS1237_SCLK_L();
+    CS1237_1US(20);
+}
+/**设置CS1237寄存器*/
+static void Set_CS1237_Config(uint8_t ad_reg)
+{
+    uint16_t bit_cout = 0;
+    uint8_t reg_temp = 0x00;
+    //DOUT由高变低之后开始读取数据
+    CS1237_DOUT_OUT(); 
+	 CS1237_DOUT_H();
+    CS1237_DOUT_IN();
+	 CS1237_SCLK_L(); //时钟拉低
+	 RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
+	 CS1237IrqFlag = false;
+	 while(CS1237IrqFlag == false) //等待芯片准备好
+    {
+		  if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
+				//DBG_LOG("RIGHTLOW CS1237 Preparation Timeout...\r\n");
+				return;         // 超时退出
+		  }
+    }
+	 CS1237IntDisable();
+	 CS1237IrqFlag = false;
+
+	 
+    /*  clk1-clk26 写期间不需要操作*/
+    for (bit_cout = 0; bit_cout < 26; bit_cout++)
+    {
+        CS1237_Clock(); //给一周期时钟
+    }
+	 /*  clk27  DOUT输出拉高*/
+	 CS1237_Clock(); //给一周期时钟
+	 CS1237_DOUT_H();
+	 /*  clk28 - clk29 发送写寄存器命令字 */
+	 CS1237_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
+	 
+    /*  clk30 - clk36 发送写寄存器命令字 */
+	 CS1237_DOUT_OUT();
+    reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
+    for (bit_cout = 0; bit_cout < 7; bit_cout++)
+    {
+        if (reg_temp & 0x80) //MSB 
+        {
+            CS1237_DOUT_H();
+        }
+        else
+        {
+            CS1237_DOUT_L();
+        }
+        reg_temp = reg_temp << 1;
+        CS1237_Clock();
+    }
+    /*  clk37写寄存器模式还是输出 */
+    CS1237_Clock();
+    /*  clk38 ~ clk45 写入寄存器值 */
+    reg_temp = ad_reg;//要配件的寄存器数值
+    for (bit_cout = 0; bit_cout < 8; bit_cout++)
+    {
+        if (reg_temp & 0x80) //MSB
+        {
+            CS1237_DOUT_H();
+        }
+        else
+        {
+            CS1237_DOUT_L();
+        }
+        reg_temp = reg_temp << 1;
+        CS1237_Clock();
+    }
+    /* 8: clk46 */
+	 CS1237_Clock();
+    CS1237_DOUT_H();
+	 CS1237_DOUT_IN();
+	 CS1237IntEnable();
+    return ;
+}
+
+/**读CS1237寄存器*/
+static int32_t Read_CS1237_Config(void)
+{
+    uint16_t bit_cout = 0;
+    uint8_t reg_temp = 0x00;
+    //DOUT由高变低之后开始读取数据
+    CS1237_DOUT_OUT();
+	 CS1237_DOUT_H();
+    CS1237_DOUT_IN();
+	 CS1237_SCLK_L(); //时钟拉低
+	 RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
+	 CS1237IrqFlag = false;
+	 while(CS1237IrqFlag == false) //等待芯片准备好
+    {
+		  if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
+				//DBG_LOG("RIGHTLOW CS1237 Preparation Timeout...\r\n");
+				return 0;         // 超时退出
+		  }
+    }
+    CS1237IntDisable();
+    CS1237IrqFlag = false;
+
+    /*  clk1-clk26 写期间不需要操作*/
+    for (bit_cout = 0; bit_cout < 26; bit_cout++)
+    {
+        CS1237_Clock(); //给一周期时钟
+    }
+	 /*  clk27  DOUT输出拉高*/
+	 CS1237_Clock(); //给一周期时钟
+	 CS1237_DOUT_H();
+	 /*  clk28 - clk29 发送写寄存器命令字 */
+	 CS1237_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
+	 
+    /*  clk30 - clk36 发送读寄存器命令字 */
+    CS1237_DOUT_OUT();
+	 reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
+    for (bit_cout = 0; bit_cout < 7; bit_cout++)
+    {
+        if (reg_temp & 0x80) //MSB 
+        {
+            CS1237_DOUT_H();
+        }
+        else
+        {
+            CS1237_DOUT_L();
+        }
+        reg_temp = reg_temp << 1;
+        CS1237_Clock();
+    }
+    /*  clk37，读寄存器模式改输入 */
+    CS1237_Clock();
+	CS1237_DOUT_IN();
+	 for (bit_cout = 0; bit_cout < 8; bit_cout++)
+	 {
+		  CS1237_SCLK_H();
+		  reg_temp <<= 1;    //左移1位准备接受数据 初始默认0
+		  CS1237_5NS(60);//延时300ns
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
+			reg_temp |= 1;
+		  CS1237_SCLK_L();
+		  CS1237_5NS(60);
+	 }
+    /* 8: clk46 */
+	 CS1237_Clock();
+    CS1237_DOUT_IN();
+	 CS1237_DOUT_H();
+	 CS1237IntEnable();
+    return reg_temp ;
+}
+/**读取CS1237的AD数*/
+static int32_t Read_CS1237_Ad_Data(void)
+{
+    uint16_t bit_cout = 0;
+    int32_t data_temp = 0;
+
+    /* clk1 ~ clk24 ADC数据*/
+    data_temp = 0;
+	 for (bit_cout = 0; bit_cout < 24; bit_cout++)
+	 {
+		  CS1237_SCLK_H();
+		  data_temp <<= 1;    //左移1位准备接受数据 初始默认0
+		  CS1237_5NS(60);//延时300ns
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
+			data_temp |= 1;
+		  CS1237_SCLK_L();
+		  CS1237_5NS(60);
+	 }
+		 
+	 /* clk25 ~ clk27 */
+	 for (bit_cout = 24; bit_cout < 27; bit_cout++)
+	 {
+		 CS1237_Clock(); //给一周期时钟
+	 }
+	 CS1237_DOUT_H();
+	 CS1237_SCLK_L();
+	 
+	 if(data_temp > 0x7FFFFF) //取24位
+	 {
+		 data_temp |= 0xFF000000;
+	 } 
+    return data_temp; 
+}
+
+void RIGHTLOW_CS1237_IrqCallBack(void)
+{
+	CS1237IrqFlag = true;
+}
+void RIGHTLOW_CS1237_Init(void)
+{
+	CS1237IrqFlag = false;
+	BuildDelay = false;
+	RIGHTLOW_CS1237Var.AinA_AD = 0;
+	RIGHTLOW_CS1237Var.Temp_AD = 0;
+	RIGHTLOW_CS1237Var.Jump_AD = 0;
+	
+	CS1237IntEnable();
+	CS1237Port = CH_SEL_A;
+	CS1237Hz = SPEED_SEL_640Hz;
+	CS1237PGA = PGA_SEL_128;
+	
+	uint8_t read_reg = 0x00;
+	uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
+	CS1237_1MS(20);
+	Set_CS1237_Config(set_reg);
+	CS1237_1MS(20);
+	read_reg = Read_CS1237_Config();
+	CS1237_1MS(20);
+	if(read_reg != set_reg){
+		DBG_LOG("RIGHTLOW CS1237 Init ERR...\r\n");
+		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
+		InitFlag = true;
+	}
+	else {
+		DBG_LOG("RIGHTLOW CS1237 Init OK...\r\n");
+		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
+		CS1237Port = read_reg & 0x03;
+		InitFlag = true;
+	}
+	CS1237IntDisable();
+}
+void RIGHTLOW_CS1237DataLoopCollect(void)
+{ 
+	static int32_t ad_array[PACK_NUM];
+	static uint8_t adcnt;
+	static uint8_t TimeOutmagcnt;
+	
+	switch(RIGHTLOW_CS1237Var.Status) {
+		case RLCS1237_STATUS_IDLE:{
+		break;}
+		
+		case RLCS1237_STATUS_START:{
+			memset(&ad_array, 0x00, sizeof(ad_array));
+			adcnt = 0;
+			TimeOutmagcnt = 0;
+			memset(&RIGHTLOW_CS1237Var, NULL, sizeof(RIGHTLOW_CS1237Var));
+			if(BuildDelay == true)
+			{
+				BuildDelay = false;
+				if(CS1237Hz == SPEED_SEL_10Hz){
+					RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
+				}
+				if(CS1237Hz == SPEED_SEL_40Hz){
+					RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
+				}
+				if(CS1237Hz == SPEED_SEL_640Hz){
+					RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
+				}
+				if(CS1237Hz == SPEED_SEL6_1280Hz){
+					RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
+				}
+				RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_DELAY;
+			}
+			else
+			{
+				RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
+			}
+		break;}
+		
+		case RLCS1237_STATUS_DELAY:{
+			if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
+				RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
+			}		
+		break;}
+		
+		case RLCS1237_STATUS_READ:{
+			CS1237IrqFlag = false;
+			RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = 100;
+			RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_WAIT_READ;
+		break;}
+		
+		case	RLCS1237_STATUS_WAIT_READ:{
+			if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
+				RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
+				TimeOutmagcnt++;
+			}
+			if(CS1237IrqFlag == true){
+				CS1237IrqFlag = false;
+				ad_array[adcnt++] = Read_CS1237_Ad_Data();
+				RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
+			}
+			if(TimeOutmagcnt >= PACK_NUM){
+				TimeOutmagcnt = 0;
+				if(adcnt > 0){
+					if(CS1237Port == CH_SEL_A){
+						RIGHTLOW_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
+						RIGHTLOW_CS1237AinADataProcessCallBack(RIGHTLOW_CS1237Var.AinA_AD);
+					}
+					if(CS1237Port == CH_SEL_TEMP){
+						RIGHTLOW_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
+						//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
+					}
+					if(CS1237Port == CH_SEL_JUMP){
+						RIGHTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
+						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
+					}
+					RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_CH_SEL;
+				}
+				else{
+					if(CS1237Port == CH_SEL_A){
+						DBG_LOG("RIGHTLOW CS1237 CHA TimeOut...\r\n"); 
+					}
+					if(CS1237Port == CH_SEL_TEMP){
+						DBG_LOG("RIGHTLOW CS1237 Temp TimeOut...\r\n"); 
+					}
+					if(CS1237Port == CH_SEL_JUMP){
+						DBG_LOG("RIGHTLOW CS1237 Jump TimeOut...\r\n"); 
+					}
+					RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_CH_SEL;
+				}
+			}
+			if(adcnt >= PACK_NUM){
+				if(CS1237Port == CH_SEL_A){
+						RIGHTLOW_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
+						RIGHTLOW_CS1237AinADataProcessCallBack(RIGHTLOW_CS1237Var.AinA_AD);
+					}
+					if(CS1237Port == CH_SEL_TEMP){
+						RIGHTLOW_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
+						//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
+					}
+					if(CS1237Port == CH_SEL_JUMP){
+						RIGHTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
+						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
+					}
+					RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_CH_SEL;
+			}
+		break;}
+		
+		case RLCS1237_STATUS_CH_SEL:{
+			RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_STOP;
+			BuildDelay = false;
+			uint8_t read_reg;
+			if(CS1237Port == CH_SEL_A){
+#if(PORT_TEMP == 1)
+			read_reg = Read_CS1237_Config();
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
+			CS1237Port = CH_SEL_TEMP;
+			BuildDelay = true;
+			break;
+#endif
+#if(PORT_JUMP == 1)
+			read_reg = Read_CS1237_Config();
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
+			CS1237Port = CH_SEL_JUMP;
+			BuildDelay = true;
+			break;
+#endif
+			}
+			
+			if(CS1237Port == CH_SEL_TEMP){
+#if(PORT_JUMP == 1)
+			read_reg = Read_CS1238_Config();
+			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
+			CS1238Port = CH_SEL_JUMP;
+			BuildDelay = true;
+			break;
+#endif
+#if(PORT_A == 1)
+			read_reg = Read_CS1237_Config();
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
+			CS1237Port = CH_SEL_A;
+			BuildDelay = true;
+			break;
+#endif
+		}
+		
+			if(CS1237Port == CH_SEL_JUMP){
+#if(PORT_A == 1)
+			read_reg = Read_CS1237_Config();
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
+			CS1237Port = CH_SEL_A;
+			BuildDelay = true;
+			break;
+#endif
+#if(PORT_TEMP == 1)
+			read_reg = Read_CS1237_Config();
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
+			CS1237Port = CH_SEL_TEMP;
+			BuildDelay = true;
+			break;
+#endif
+		}
+		break;}
+		
+		case RLCS1237_STATUS_STOP:{
+			RIGHTLOW_CS1237Stop();
+			RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_IDLE;
+			//RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_START;//持续工作
+		break;}
+	}
+}
+void RIGHTLOW_CS12371mSRoutine(void)
+{
+	if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt > 0) 
+		RIGHTLOW_CS1237Var.CS1237Delay1mSCnt--;
+}
+void RIGHTLOW_CS1237Start(void)
+{
+	CS1237_WakeUp();
+	CS1237_1MS(2);
+	BuildDelay = true;
+	CS1237IntEnable();
+	if(!InitFlag){
+		RIGHTLOW_CS1237_Init();
+		return;
+	}
+	RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_START;
+}
+void RIGHTLOW_CS1237Stop(void)
+{
+	CS1237IntDisable();
+	//CS1237_Sleep();
+}
+
+
+

Project/HC32F460/source/Module/CS1237/CS1237_RIGHTLOW.h

@@ -0,0 +1,78 @@
+#include "bsp.h" 
+
+#ifndef _CS1237_RIGHTLOW_H_ 
+#define _CS1237_RIGHTLOW_H_ 
+
+#define	READ_CONFIG_CMD		0x56
+#define	WRITE_CONFIG_CMD		0x65
+
+#define	CONFIG_RST				0x0C
+
+#define	REFO_OFF					0x40
+#define	REFO_ON					0x00
+
+#define	SPEED_SEL_10Hz			0x00
+#define	SPEED_SEL_40Hz			0x10
+#define	SPEED_SEL_640Hz		0x20
+#define	SPEED_SEL6_1280Hz		0x30
+
+#define	PGA_SEL_1				0x00
+#define	PGA_SEL_2				0x04
+#define	PGA_SEL_64				0x08
+#define	PGA_SEL_128				0x0C
+
+#define	CH_SEL_A					0x00
+//#define	CH_SEL_B					0x01
+#define	CH_SEL_TEMP				0x02
+#define	CH_SEL_JUMP				0x03
+
+/*Definition of conversion time corresponding to repeatability setting*/
+/*
+	10Hz     	//建立时间300ms
+	40Hz	  		//建立时间75ms
+	640Hz    	//建立时间6.25ms
+	1280Hz    	//建立时间3.125ms
+*/
+#define tCon_10Hz			300	/* ms. */
+#define tCon_40Hz			75	/* ms. */
+#define tCon_640Hz		7	/* ms. */
+#define tCon_1280Hz		4	/* ms. */
+
+#define  PORT_A	  		1						//采集通道A
+//#define  PORT_B	  		1						//采集通道B
+#define  PORT_TEMP	   0						//采集温度
+#define  PORT_JUMP	   0						//内短采集
+#define	PACK_NUM		   1						//一次采集的数据包数量
+#define	FILTER_NUM		0						//滤波数
+
+typedef enum{
+	RLCS1237_STATUS_IDLE,
+	RLCS1237_STATUS_START,
+	RLCS1237_STATUS_DELAY,
+	RLCS1237_STATUS_READ,
+	RLCS1237_STATUS_WAIT_READ,
+	RLCS1237_STATUS_CH_SEL,
+	RLCS1237_STATUS_STOP,
+}RightLowCS1237Status_m;
+
+typedef struct{
+	RightLowCS1237Status_m Status;
+	uint32_t CS1237Delay1mSCnt;
+	
+	int32_t AinA_AD;//AINAad数据
+	//int32_t AinB_AD;//AINBad数据	
+	int32_t Temp_AD;//温度ad数据
+	int32_t Jump_AD;//内短ad数据	
+}
+RIGHTLOW_CS1237Var_t;
+
+void RIGHTLOW_CS1237_Init(void);
+void RIGHTLOW_CS1237_IrqCallBack(void);
+void RIGHTLOW_CS1237DataLoopCollect(void);
+void RIGHTLOW_CS12371mSRoutine(void);
+void RIGHTLOW_CS1237Start(void);
+void RIGHTLOW_CS1237Stop(void);
+#endif 
+
+
+

Project/HC32F460/source/Module/CS1237/CS1237_RIGHTUP.c

@@ -1,189 +1,203 @@
-#include "CS1238.h" 
+#include "CS1237_RIGHTUP.h" 
-#include "UartDebug.h"
+#include "Debug.h"
 #include "bsp.h" 
 #include "main.h"
 #include "Algorithm.h"
 
-CS1238Var_t CS1238Var;
+#define	CS1237_DOUT_OUT()		PORT_OE(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx, Enable)
-static bool InitFlag;
+#define	CS1237_DOUT_IN()		PORT_OE(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx, Disable)
-static bool CS1238IrqFlag;
+#define	CS1237_DOUT_H()		SET_RIGHTUP_CS1237_DOUT()
-static bool BuildDelay;
+#define	CS1237_DOUT_L()		CLR_RIGHTUP_CS1237_DOUT()
-static uint8_t CS1238Port;
+#define  CS1237_DOUT_GET()		GET_RIGHTUP_CS1237_DOUT()
-static uint8_t CS1238Hz;
-static uint8_t CS1238PGA;
-extern void CS1238Ain1DataProcessCallBack(int32_t AD);
-extern void CS1238Ain2DataProcessCallBack(int32_t AD);
-extern void CS1238TempDataProcessCallBack(int32_t AD);
-extern void CS1238JumpDataProcessCallBack(int32_t AD);
 
-/** cs1238 时序时钟*/
+#define	CS1237_SCLK_H()		SET_RIGHTUP_CS1237_SCLK()
-static void CS1238_Clock(void)
+#define	CS1237_SCLK_L()		CLR_RIGHTUP_CS1237_SCLK()
+
+#define	CS1237_5NS(x)			delay_5ns(x)				//5ns延时
+#define	CS1237_1US(x)			Ddl_Delay1us(x)			//1us延时
+#define	CS1237_1MS(x)			Ddl_Delay1ms(x)			//1ms延时
+
+#define 	CS1237IntEnable()		ExtInt04IntEnable()
+#define 	CS1237IntDisable()	ExtInt04IntDisable()
+
+RIGHTUP_CS1237Var_t RIGHTUP_CS1237Var;
+static bool InitFlag;
+static bool CS1237IrqFlag;
+static bool BuildDelay;
+static uint8_t CS1237Port;
+static uint8_t CS1237Hz;
+static uint8_t CS1237PGA;
+extern void RIGHTUP_CS1237AinADataProcessCallBack(int32_t AD);
+
+
+/** cs1237 时序时钟*/
+static void CS1237_Clock(void)
 {
-    CS1238_SCLK_H();
+    CS1237_SCLK_H();
-    CS1238_100NS(3);
+    CS1237_5NS(60);
-    CS1238_SCLK_L();
+    CS1237_SCLK_L();
-    CS1238_100NS(3);
+    CS1237_5NS(60);
 }
-/** cs1238 休眠*/
+/** cs1237 休眠*/
-static void CS1238_Sleep(void)
+static void CS1237_Sleep(void)
 {
-    CS1238_SCLK_H();
+    CS1237_SCLK_H();
-    CS1238_1US(150);
+    CS1237_1US(200);
 }
-/** cs1238 唤醒*/
+/** cs1237 唤醒*/
-static void CS1238_WakeUp(void)
+static void CS1237_WakeUp(void)
 {
-    CS1238_SCLK_L();
+    CS1237_SCLK_L();
-    CS1238_1US(20);
+    CS1237_1US(20);
 }
-/**设置CS1238寄存器*/
+/**设置CS1237寄存器*/
-static void Set_CS1238_Config(uint8_t ad_reg)
+static void Set_CS1237_Config(uint8_t ad_reg)
 {
     uint16_t bit_cout = 0;
     uint8_t reg_temp = 0x00;
     //DOUT由高变低之后开始读取数据
-    CS1238_DOUT_OUT(); 
+    CS1237_DOUT_OUT(); 
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-    CS1238_DOUT_IN();
+    CS1237_DOUT_IN();
-	 CS1238_SCLK_L(); //时钟拉低
+	 CS1237_SCLK_L(); //时钟拉低
-	 CS1238Var.CS1238Delay1mSCnt = 300;
+	 RIGHTUP_CS1237Var.CS1237Delay1mSCnt = 300;
-	 CS1238IrqFlag = false;
+	 CS1237IrqFlag = false;
-	 while(CS1238IrqFlag == false) //等待芯片准备好
+	 while(CS1237IrqFlag == false) //等待芯片准备好
     {
-		  if(CS1238Var.CS1238Delay1mSCnt <= 0){
+		  if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				DBG_LOG("CS1238 Preparation Timeout...\r\n");
+				//DBG_LOG("RIGHTUP CS1237 Preparation Timeout...\r\n");
 				return;         // 超时退出
 		  }
     }
-	 CS1238IntDisable();
+	 CS1237IntDisable();
-	 CS1238IrqFlag = false;
+	 CS1237IrqFlag = false;
 
 	 
     /*  clk1-clk26 写期间不需要操作*/
     for (bit_cout = 0; bit_cout < 26; bit_cout++)
     {
-        CS1238_Clock(); //给一周期时钟
+        CS1237_Clock(); //给一周期时钟
     }
 	 /*  clk27  DOUT输出拉高*/
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
 	 /*  clk28 - clk29 发送写寄存器命令字 */
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
 	 
     /*  clk30 - clk36 发送写寄存器命令字 */
-	 CS1238_DOUT_OUT();
+	 CS1237_DOUT_OUT();
     reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
     for (bit_cout = 0; bit_cout < 7; bit_cout++)
     {
         if (reg_temp & 0x80) //MSB 
         {
-            CS1238_DOUT_H();
+            CS1237_DOUT_H();
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
-        CS1238_Clock();
+        CS1237_Clock();
     }
     /*  clk37写寄存器模式还是输出 */
-    CS1238_Clock();
+    CS1237_Clock();
     /*  clk38 ~ clk45 写入寄存器值 */
     reg_temp = ad_reg;//要配件的寄存器数值
     for (bit_cout = 0; bit_cout < 8; bit_cout++)
     {
         if (reg_temp & 0x80) //MSB
         {
-            CS1238_DOUT_H();
+            CS1237_DOUT_H();
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
-        CS1238_Clock();
+        CS1237_Clock();
     }
     /* 8: clk46 */
-	 CS1238_Clock();
+	 CS1237_Clock();
-    CS1238_DOUT_H();
+    CS1237_DOUT_H();
-	 CS1238_DOUT_IN();
+	 CS1237_DOUT_IN();
-	 CS1238IntEnable();
+	 CS1237IntEnable();
     return ;
 }
 
-/**读CS1238寄存器*/
+/**读CS1237寄存器*/
-static int32_t Read_CS1238_Config(void)
+static int32_t Read_CS1237_Config(void)
 {
     uint16_t bit_cout = 0;
     uint8_t reg_temp = 0x00;
     //DOUT由高变低之后开始读取数据
-    CS1238_DOUT_OUT();
+    CS1237_DOUT_OUT();
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-    CS1238_DOUT_IN();
+    CS1237_DOUT_IN();
-	 CS1238_SCLK_L(); //时钟拉低
+	 CS1237_SCLK_L(); //时钟拉低
-	 CS1238Var.CS1238Delay1mSCnt = 300;
+	 RIGHTUP_CS1237Var.CS1237Delay1mSCnt = 300;
-	 CS1238IrqFlag = false;
+	 CS1237IrqFlag = false;
-	 while(CS1238IrqFlag == false) //等待芯片准备好
+	 while(CS1237IrqFlag == false) //等待芯片准备好
     {
-		  if(CS1238Var.CS1238Delay1mSCnt <= 0){
+		  if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				DBG_LOG("CS1238 Preparation Timeout...\r\n");
+				//DBG_LOG("RIGHTUP CS1237 Preparation Timeout...\r\n");
 				return 0;         // 超时退出
 		  }
     }
-    CS1238IntDisable();
+    CS1237IntDisable();
-    CS1238IrqFlag = false;
+    CS1237IrqFlag = false;
 
     /*  clk1-clk26 写期间不需要操作*/
     for (bit_cout = 0; bit_cout < 26; bit_cout++)
     {
-        CS1238_Clock(); //给一周期时钟
+        CS1237_Clock(); //给一周期时钟
     }
 	 /*  clk27  DOUT输出拉高*/
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
 	 /*  clk28 - clk29 发送写寄存器命令字 */
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
-	 CS1238_Clock(); //给一周期时钟
+	 CS1237_Clock(); //给一周期时钟
 	 
     /*  clk30 - clk36 发送读寄存器命令字 */
-    CS1238_DOUT_OUT();
+    CS1237_DOUT_OUT();
 	 reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
     for (bit_cout = 0; bit_cout < 7; bit_cout++)
     {
         if (reg_temp & 0x80) //MSB 
         {
-            CS1238_DOUT_H();
+            CS1237_DOUT_H();
         }
         else
         {
-            CS1238_DOUT_L();
+            CS1237_DOUT_L();
         }
         reg_temp = reg_temp << 1;
-        CS1238_Clock();
+        CS1237_Clock();
     }
     /*  clk37，读寄存器模式改输入 */
-    CS1238_Clock();
+    CS1237_Clock();
-	CS1238_DOUT_IN();
+	CS1237_DOUT_IN();
 	 for (bit_cout = 0; bit_cout < 8; bit_cout++)
 	 {
-		  CS1238_SCLK_H();
+		  CS1237_SCLK_H();
 		  reg_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1238_100NS(3);//延时300ns
+		  CS1237_5NS(60);//延时300ns
-		  if(GET_CS1238_DOUT() == true) //有数值则累加
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
 			reg_temp |= 1;
-		  CS1238_SCLK_L();
+		  CS1237_SCLK_L();
-		  CS1238_100NS(3);
+		  CS1237_5NS(60);
 	 }
     /* 8: clk46 */
-	 CS1238_Clock();
+	 CS1237_Clock();
-    CS1238_DOUT_IN();
+    CS1237_DOUT_IN();
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-	 CS1238IntEnable();
+	 CS1237IntEnable();
     return reg_temp ;
 }
-/**读取CS1238的AD数*/
+/**读取CS1237的AD数*/
-static int32_t Read_CS1238_Ad_Data(void)
+static int32_t Read_CS1237_Ad_Data(void)
 {
     uint16_t bit_cout = 0;
     int32_t data_temp = 0;
@@ -192,22 +206,22 @@ static int32_t Read_CS1238_Ad_Data(void)
     data_temp = 0;
 	 for (bit_cout = 0; bit_cout < 24; bit_cout++)
 	 {
-		  CS1238_SCLK_H();
+		  CS1237_SCLK_H();
 		  data_temp <<= 1;    //左移1位准备接受数据 初始默认0
-		  CS1238_100NS(3);//延时300ns
+		  CS1237_5NS(60);//延时300ns
-		  if(GET_CS1238_DOUT() == true) //有数值则累加
+		  if(CS1237_DOUT_GET() == true) //有数值则累加
 			data_temp |= 1;
-		  CS1238_SCLK_L();
+		  CS1237_SCLK_L();
-		  CS1238_100NS(3);
+		  CS1237_5NS(60);
 	 }
 		 
 	 /* clk25 ~ clk27 */
 	 for (bit_cout = 24; bit_cout < 27; bit_cout++)
 	 {
-		 CS1238_Clock(); //给一周期时钟
+		 CS1237_Clock(); //给一周期时钟
 	 }
-	 CS1238_DOUT_H();
+	 CS1237_DOUT_H();
-	 CS1238_SCLK_L();
+	 CS1237_SCLK_L();
 	 
 	 if(data_temp > 0x7FFFFF) //取24位
 	 {
@@ -216,190 +230,172 @@ static int32_t Read_CS1238_Ad_Data(void)
     return data_temp; 
 }
 
-void CS1238_IrqCallBack(void)
+void RIGHTUP_CS1237_IrqCallBack(void)
 {
-	CS1238IrqFlag = true;
+	CS1237IrqFlag = true;
 }
-void CS1238_Init(void)
+void RIGHTUP_CS1237_Init(void)
 {
-	CS1238IrqFlag = false;
+	CS1237IrqFlag = false;
 	BuildDelay = false;
-	CS1238IntEnable();
+	RIGHTUP_CS1237Var.AinA_AD = 0;
-	CS1238Var.Ain1_AD = 0;
+	RIGHTUP_CS1237Var.Temp_AD = 0;
-	CS1238Var.Ain2_AD = 0;
+	RIGHTUP_CS1237Var.Jump_AD = 0;
-	CS1238Var.Temp_AD = 0;
-	CS1238Var.Jump_AD = 0;
 	
-	CS1238Port = CH_SEL_A;
+	CS1237IntEnable();
-	CS1238Hz = SPEED_SEL_640Hz;
+	CS1237Port = CH_SEL_A;
-	CS1238PGA = PGA_SEL_128;
+	CS1237Hz = SPEED_SEL_640Hz;
+	CS1237PGA = PGA_SEL_128;
 	
 	uint8_t read_reg = 0x00;
-	uint8_t set_reg = REFO_ON | CS1238Hz | CS1238PGA | CS1238Port;
+	uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
-	CS1238_1MS(20);
+	CS1237_1MS(20);
-	Set_CS1238_Config(set_reg);
+	Set_CS1237_Config(set_reg);
-	CS1238_1MS(20);
+	CS1237_1MS(20);
-	read_reg = Read_CS1238_Config();
+	read_reg = Read_CS1237_Config();
-	CS1238_1MS(20);
+	CS1237_1MS(20);
 	if(read_reg != set_reg){
-		DBG_LOG("CS1238 Init ERR...\r\n");
+		DBG_LOG("RIGHTUP CS1237 Init ERR...\r\n");
-		DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		InitFlag = false;
-	}
-	else {
-		DBG_LOG("CS1238 Init OK...\r\n");
 		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
-		CS1238Port = read_reg & 0x03;
 		InitFlag = true;
 	}
+	else {
+		DBG_LOG("RIGHTUP CS1237 Init OK...\r\n");
+		//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
+		CS1237Port = read_reg & 0x03;
+		InitFlag = true;
+	}
+	CS1237IntDisable();
 }
-void CS1238DataLoopCollect(void)
+void RIGHTUP_CS1237DataLoopCollect(void)
 { 
 	static int32_t ad_array[PACK_NUM];
 	static uint8_t adcnt;
 	static uint8_t TimeOutmagcnt;
 	
-	switch(CS1238Var.Status) {
+	switch(RIGHTUP_CS1237Var.Status) {
-		case CS1238_STATUS_IDLE:{
+		case RUCS1237_STATUS_IDLE:{
 		break;}
 		
-		case CS1238_STATUS_START:{
+		case RUCS1237_STATUS_START:{
 			memset(&ad_array, 0x00, sizeof(ad_array));
 			adcnt = 0;
 			TimeOutmagcnt = 0;
-			memset(&CS1238Var, NULL, sizeof(CS1238Var));
+			memset(&RIGHTUP_CS1237Var, NULL, sizeof(RIGHTUP_CS1237Var));
 			if(BuildDelay == true)
 			{
 				BuildDelay = false;
-				if(CS1238Hz == SPEED_SEL_10Hz){
+				if(CS1237Hz == SPEED_SEL_10Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_10Hz;
+					RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
 				}
-				if(CS1238Hz == SPEED_SEL_40Hz){
+				if(CS1237Hz == SPEED_SEL_40Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_40Hz;
+					RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
 				}
-				if(CS1238Hz == SPEED_SEL_640Hz){
+				if(CS1237Hz == SPEED_SEL_640Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_640Hz;
+					RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
 				}
-				if(CS1238Hz == SPEED_SEL6_1280Hz){
+				if(CS1237Hz == SPEED_SEL6_1280Hz){
-					CS1238Var.CS1238Delay1mSCnt = tCon_1280Hz;
+					RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
 				}
-				CS1238Var.Status = CS1238_STATUS_DELAY;
+				RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_DELAY;
 			}
 			else
 			{
-				CS1238Var.Status = CS1238_STATUS_READ;
+				RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
 			}
 		break;}
 		
-		case CS1238_STATUS_DELAY:{
+		case RUCS1237_STATUS_DELAY:{
-			if(CS1238Var.CS1238Delay1mSCnt <= 0){
+			if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				CS1238Var.Status = CS1238_STATUS_READ;
+				RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
 			}		
 		break;}
 		
-		case CS1238_STATUS_READ:{
+		case RUCS1237_STATUS_READ:{
-			CS1238IrqFlag = false;
+			CS1237IrqFlag = false;
-			CS1238Var.CS1238Delay1mSCnt = 100;
+			RIGHTUP_CS1237Var.CS1237Delay1mSCnt = 100;
-			CS1238Var.Status = CS1238_STATUS_WAIT_READ;
+			RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_WAIT_READ;
 		break;}
 		
-		case	CS1238_STATUS_WAIT_READ:{
+		case	RUCS1237_STATUS_WAIT_READ:{
-			if(CS1238Var.CS1238Delay1mSCnt <= 0){
+			if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
-				CS1238Var.Status = CS1238_STATUS_READ;
+				RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
 				TimeOutmagcnt++;
 			}
-			if(CS1238IrqFlag == true){
+			if(CS1237IrqFlag == true){
-				CS1238IrqFlag = false;
+				CS1237IrqFlag = false;
-				ad_array[adcnt++] = Read_CS1238_Ad_Data();
+				ad_array[adcnt++] = Read_CS1237_Ad_Data();
-				CS1238Var.Status = CS1238_STATUS_READ;
+				RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
 			}
 			if(TimeOutmagcnt >= PACK_NUM){
 				TimeOutmagcnt = 0;
 				if(adcnt > 0){
-					if(CS1238Port == CH_SEL_A){
+					if(CS1237Port == CH_SEL_A){
-						CS1238Var.Ain1_AD = IntFilter_32t(ad_array, adcnt, 4);
+						RIGHTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain1DataProcessCallBack(CS1238Var.Ain1_AD);
+						RIGHTUP_CS1237AinADataProcessCallBack(RIGHTUP_CS1237Var.AinA_AD);
 					}
-					if(CS1238Port == CH_SEL_B){
+					if(CS1237Port == CH_SEL_TEMP){
-						CS1238Var.Ain2_AD = IntFilter_32t(ad_array, adcnt, 4);
+						RIGHTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain2DataProcessCallBack(CS1238Var.Ain2_AD);
+						//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
 					}
-					if(CS1238Port == CH_SEL_TEMP){
+					if(CS1237Port == CH_SEL_JUMP){
-						CS1238Var.Temp_AD = IntFilter_32t(ad_array, adcnt, 4);
+						RIGHTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238TempDataProcessCallBack(CS1238Var.Temp_AD);
+						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
 					}
-					if(CS1238Port == CH_SEL_JUMP){
+					RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_CH_SEL;
-						CS1238Var.Jump_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238JumpDataProcessCallBack(CS1238Var.Jump_AD);
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
 				}
 				else{
-					if(CS1238Port == CH_SEL_A){
+					if(CS1237Port == CH_SEL_A){
-						DBG_LOG("CS1238 CHA TimeOut...\r\n"); 
+						DBG_LOG("RIGHTUP CS1237 CHA TimeOut...\r\n"); 
 					}
-					if(CS1238Port == CH_SEL_B){
+					if(CS1237Port == CH_SEL_TEMP){
-						DBG_LOG("CS1238 CHB TimeOut...\r\n"); 
+						DBG_LOG("RIGHTUP CS1237 Temp TimeOut...\r\n"); 
 					}
-					if(CS1238Port == CH_SEL_TEMP){
+					if(CS1237Port == CH_SEL_JUMP){
-						DBG_LOG("CS1238 Temp TimeOut...\r\n"); 
+						DBG_LOG("RIGHTUP CS1237 Jump TimeOut...\r\n"); 
 					}
-					if(CS1238Port == CH_SEL_JUMP){
+					RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_CH_SEL;
-						DBG_LOG("CS1238 Jump TimeOut...\r\n"); 
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
 				}
 			}
 			if(adcnt >= PACK_NUM){
-				if(CS1238Port == CH_SEL_A){
+				if(CS1237Port == CH_SEL_A){
-						CS1238Var.Ain1_AD = IntFilter_32t(ad_array, adcnt, 4);
+						RIGHTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain1DataProcessCallBack(CS1238Var.Ain1_AD);
+						RIGHTUP_CS1237AinADataProcessCallBack(RIGHTUP_CS1237Var.AinA_AD);
 					}
-					if(CS1238Port == CH_SEL_B){
+					if(CS1237Port == CH_SEL_TEMP){
-						CS1238Var.Ain2_AD = IntFilter_32t(ad_array, adcnt, 4);
+						RIGHTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238Ain2DataProcessCallBack(CS1238Var.Ain2_AD);
+						//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
 					}
-					if(CS1238Port == CH_SEL_TEMP){
+					if(CS1237Port == CH_SEL_JUMP){
-						CS1238Var.Temp_AD = IntFilter_32t(ad_array, adcnt, 4);
+						RIGHTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
-						CS1238TempDataProcessCallBack(CS1238Var.Temp_AD);
+						//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
 					}
-					if(CS1238Port == CH_SEL_JUMP){
+					RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_CH_SEL;
-						CS1238Var.Jump_AD = IntFilter_32t(ad_array, adcnt, 4);
-						CS1238JumpDataProcessCallBack(CS1238Var.Jump_AD);
-					}
-					CS1238Var.Status = CS1238_STATUS_CH_SEL;
 			}
 		break;}
 		
-		case CS1238_STATUS_CH_SEL:{
+		case RUCS1237_STATUS_CH_SEL:{
-			CS1238Var.Status = CS1238_STATUS_STOP;
+			RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_STOP;
 			BuildDelay = false;
 			uint8_t read_reg;
-			if(CS1238Port == CH_SEL_A){
+			if(CS1237Port == CH_SEL_A){
 #if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
+			CS1237Port = CH_SEL_TEMP;
 			BuildDelay = true;
 			break;
 #endif
 #if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
+			CS1237Port = CH_SEL_JUMP;
 			BuildDelay = true;
 			break;
 #endif
 			}
 			
-			if(CS1238Port == CH_SEL_B){
+			if(CS1237Port == CH_SEL_TEMP){
-#if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
-			BuildDelay = true;
-			break;
-#endif
 #if(PORT_JUMP == 1)
 			read_reg = Read_CS1238_Config();
 			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
@@ -408,77 +404,60 @@ void CS1238DataLoopCollect(void)
 			break;
 #endif
 #if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
+			CS1237Port = CH_SEL_A;
 			BuildDelay = true;
 			break;
 #endif
 		}
 		
-			if(CS1238Port == CH_SEL_TEMP){
+			if(CS1237Port == CH_SEL_JUMP){
-#if(PORT_JUMP == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
-			CS1238Port = CH_SEL_JUMP;
-			BuildDelay = true;
-			break;
-#endif
 #if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
+			CS1237Port = CH_SEL_A;
-			BuildDelay = true;
-			break;
-#endif
-		}
-		
-			if(CS1238Port == CH_SEL_JUMP){
-#if(PORT_A == 1)
-			read_reg = Read_CS1238_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_A);
-			CS1238Port = CH_SEL_A;
 			BuildDelay = true;
 			break;
 #endif
 #if(PORT_TEMP == 1)
-			read_reg = Read_CS1238_Config();
+			read_reg = Read_CS1237_Config();
-			Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_TEMP);
+			Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
-			CS1238Port = CH_SEL_TEMP;
+			CS1237Port = CH_SEL_TEMP;
 			BuildDelay = true;
 			break;
 #endif
 		}
 		break;}
 		
-		case CS1238_STATUS_STOP:{
+		case RUCS1237_STATUS_STOP:{
-			//CS1238Stop();
+			RIGHTUP_CS1237Stop();
-			//CS1238Var.Status = CS1238_STATUS_IDLE;
+			RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_IDLE;
-			CS1238Var.Status = CS1238_STATUS_START;//持续工作
+			//RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_START;//持续工作
 		break;}
 	}
 }
-void CS12381mSRoutine(void)
+void RIGHTUP_CS12371mSRoutine(void)
 {
-	if(CS1238Var.CS1238Delay1mSCnt > 0) 
+	if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt > 0) 
-		CS1238Var.CS1238Delay1mSCnt--;
+		RIGHTUP_CS1237Var.CS1237Delay1mSCnt--;
 }
-void CS1238Start(void)
+void RIGHTUP_CS1237Start(void)
 {
-	CS1238_WakeUp();
+	CS1237_WakeUp();
-	CS1238_1MS(2);
+	CS1237_1MS(2);
 	BuildDelay = true;
-	CS1238IntEnable();
+	CS1237IntEnable();
 	if(!InitFlag){
-		CS1238_Init();
+		RIGHTUP_CS1237_Init();
 		return;
 	}
-	CS1238Var.Status = CS1238_STATUS_START;
+	RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_START;
 }
-void CS1238Stop(void)
+void RIGHTUP_CS1237Stop(void)
 {
-	CS1238IntDisable();
+	CS1237IntDisable();
-	CS1238_Sleep();
+	//CS1237_Sleep();
 }
 
 

Project/HC32F460/source/Module/CS1237/CS1237_RIGHTUP.h

@@ -1,7 +1,7 @@
 #include "bsp.h" 
 
-#ifndef _CS1238_H_ 
+#ifndef _CS1237_RIGHTUP_H_ 
-#define _CS1238_H_ 
+#define _CS1237_RIGHTUP_H_ 
 
 #define	READ_CONFIG_CMD		0x56
 #define	WRITE_CONFIG_CMD		0x65
@@ -22,21 +22,11 @@
 #define	PGA_SEL_128				0x0C
 
 #define	CH_SEL_A					0x00
-#define	CH_SEL_B					0x01
+//#define	CH_SEL_B					0x01
 #define	CH_SEL_TEMP				0x02
 #define	CH_SEL_JUMP				0x03
 
-#define	CS1238_DOUT_OUT()		SetBit(((uint32_t)&M0P_GPIO->PADIR + CS1238_DOUT_PORTx), CS1238_DOUT_PINx, 0)
-#define	CS1238_DOUT_IN()		SetBit(((uint32_t)&M0P_GPIO->PADIR + CS1238_DOUT_PORTx), CS1238_DOUT_PINx, 1)
-#define	CS1238_DOUT_H()		SET_CS1238_DOUT()
-#define	CS1238_DOUT_L()		CLR_CS1238_DOUT()
 
-#define	CS1238_SCLK_H()		SET_CS1238_SCLK()
-#define	CS1238_SCLK_L()		CLR_CS1238_SCLK()
-
-#define	CS1238_1US(x)				delay_us(x)			//1us延时
-#define	CS1238_100NS(x)			delay_ns(x)			//100ns延时
-#define	CS1238_1MS(x)				delay_ms(x)			//1ms延时
 
 /*Definition of conversion time corresponding to repeatability setting*/
 /*
@@ -51,40 +41,39 @@
 #define tCon_1280Hz		4	/* ms. */
 
 #define  PORT_A	  		1						//采集通道A
-#define  PORT_B	  		1						//采集通道B
+//#define  PORT_B	  		1						//采集通道B
 #define  PORT_TEMP	   0						//采集温度
 #define  PORT_JUMP	   0						//内短采集
-#define	 PACK_NUM			10						//一次采集的数据包数量
+#define	PACK_NUM		   1						//一次采集的数据包数量
+#define	FILTER_NUM		0						//滤波数
 
 typedef enum{
-	CS1238_STATUS_IDLE,
+	RUCS1237_STATUS_IDLE,
-	CS1238_STATUS_START,
+	RUCS1237_STATUS_START,
-	CS1238_STATUS_DELAY,
+	RUCS1237_STATUS_DELAY,
-	CS1238_STATUS_READ,
+	RUCS1237_STATUS_READ,
-	CS1238_STATUS_WAIT_READ,
+	RUCS1237_STATUS_WAIT_READ,
-	CS1238_STATUS_CH_SEL,
+	RUCS1237_STATUS_CH_SEL,
-	CS1238_STATUS_STOP,
+	RUCS1237_STATUS_STOP,
-}CS1238Status_m;
+}RightUpCS1237Status_m;
 
 typedef struct{
-	CS1238Status_m Status;
+	RightUpCS1237Status_m Status;
-	uint32_t CS1238Delay1mSCnt;
+	uint32_t CS1237Delay1mSCnt;
 	
-	int32_t Ain1_AD;//AIN1ad数据
+	int32_t AinA_AD;//AINAad数据
-	int32_t Ain2_AD;//AIN2ad数据	
+	//int32_t AinB_AD;//AINBad数据	
 	int32_t Temp_AD;//温度ad数据
 	int32_t Jump_AD;//内短ad数据	
 }
-CS1238Var_t;
+RIGHTUP_CS1237Var_t;
-extern CS1238Var_t CS1238Var;
 
-void CS1238_Init(void);
+void RIGHTUP_CS1237_Init(void);
-void CS1238_IrqCallBack(void);
+void RIGHTUP_CS1237_IrqCallBack(void);
-void CS1238DataLoopCollect(void);
+void RIGHTUP_CS1237DataLoopCollect(void);
-void CS1238LoopHandler(void); 
+void RIGHTUP_CS12371mSRoutine(void);
-void CS12381mSRoutine(void);
+void RIGHTUP_CS1237Start(void);
-void CS1238Start(void);
+void RIGHTUP_CS1237Stop(void);
-void CS1238Stop(void);
 #endif 
 
 

Project/HC32F460/source/User/Inc/bsp.h

@@ -11,10 +11,10 @@
 
 /*模块启用与关闭*/
 #define	USE_DEBUG 					1					//DEBUG开关，0、关闭，1、启用
-#define 	USE_VBAT_AD				  	0					//锂电池电压AD获取选择，0、关闭，1、启用
+#define 	USE_AD				  		0					//AD获取选择，0、关闭，1、启用
 #define	USE_WDT					  	0					//看门狗选择，0、关闭，1启用
 #define	USE_EXFALSE				  	0					//外部FALSE存储选择，0、关闭，1、启用
-#define  USE_RTC 					  	1					//RTC时钟开关，0、关闭，1、开启
+#define  USE_RTC 					  	0					//RTC时钟开关，0、关闭，1、开启
 #define	USE_LPTIM0					0					//LPTIM0开关，0、关闭，1、开启
 #define	USE_DMA						0					//DMA开关，0、关闭，1、开启
 #define  USE_RS485					0					//RS485开关，0、关闭，1、启用
@@ -27,7 +27,7 @@
 #define	USE_CS1237_LEFTUP			1					//左上CS1237开关，0、关闭，1、启用
 #define	USE_CS1237_LEFTLOW		1					//左下CS1237开关，0、关闭，1、启用
 #define	USE_CS1237_RIGHTUP		1					//右上CS1237开关，0、关闭，1、启用
-#define	USE_CS1237_RIGHRLOW		1					//右上CS1237开关，0、关闭，1、启用
+#define	USE_CS1237_RIGHTLOW		1					//右上CS1237开关，0、关闭，1、启用
 
 //<<----------------------------	MCU  -------------------------------->>
 //<   	DEBUG
@@ -46,6 +46,8 @@
 #define	DBG_FCG1_PERIPH						(PWC_FCG1_PERIPH_USART1)
 #define	DBG_RXPIN_EXIT_CH						(ExtiCh13)
 #define	DBG_RXPIN_EXIT_SRC					(INT_PORT_EIRQ13)
+#define	DBG_RX_IRQn								(Int000_IRQn)
+#define	DBG_ER_IRQn								(Int001_IRQn)
 #endif
 
 //			SPI3
@@ -107,59 +109,68 @@
 #define	RTC_IRQn									Int001_IRQn
 #endif
 //<<-----------------------------	CS1237  ------------------------------->>
-//<		LEFTUP CS1237
+//<		左上 CS1237
 #if(USE_CS1237_LEFTUP == 1)
+#define	LEFTUP_CS1237_IRQn					(Int001_IRQn)
 #define	LEFTUP_CS1237_DOUT_PORTx			(PortB)
-#define	LEFTUP_CS1237_DOUT_PINx				(Pin00)
+#define	LEFTUP_CS1237_DOUT_PINx				(Pin10)
 #define	SET_LEFTUP_CS1237_DOUT()			PORT_SetBits(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)//拉高
 #define	CLR_LEFTUP_CS1237_DOUT()			PORT_ResetBits(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)//拉低
-#define	GET_LEFTUP_CS1237_DOUT()			Gpio_GetInputIO(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)
+#define	GET_LEFTUP_CS1237_DOUT()			PORT_GetBit(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)
 
 #define	LEFTUP_CS1237_SCLK_PORTx			(PortB)
-#define	LEFTUP_CS1237_SCLK_PINx				(Pin01)
+#define	LEFTUP_CS1237_SCLK_PINx				(Pin02)
 #define	SET_LEFTUP_CS1237_SCLK()			PORT_SetBits(LEFTUP_CS1237_SCLK_PORTx, LEFTUP_CS1237_SCLK_PINx)//拉高
 #define	CLR_LEFTUP_CS1237_SCLK()			PORT_ResetBits(LEFTUP_CS1237_SCLK_PORTx, LEFTUP_CS1237_SCLK_PINx)//拉低
 #endif
-//<		LEFTLOW CS1237
+//<		左下 CS1237
 #if(USE_CS1237_LEFTLOW == 1)
+#define	LEFTLOW_CS1237_IRQn					(Int002_IRQn)
 #define	LEFTLOW_CS1237_DOUT_PORTx			(PortB)
-#define	LEFTLOW_CS1237_DOUT_PINx			(Pin02)
+#define	LEFTLOW_CS1237_DOUT_PINx			(Pin01)
 #define	SET_LEFTLOW_CS1237_DOUT()			PORT_SetBits(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)//拉高
 #define	CLR_LEFTLOW_CS1237_DOUT()			PORT_ResetBits(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)//拉低
-#define	GET_LEFTLOW_CS1237_DOUT()			Gpio_GetInputIO(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)
+#define	GET_LEFTLOW_CS1237_DOUT()			PORT_GetBit(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)
 
 #define	LEFTLOW_CS1237_SCLK_PORTx			(PortB)
-#define	LEFTLOW_CS1237_SCLK_PINx			(Pin10)
+#define	LEFTLOW_CS1237_SCLK_PINx			(Pin00)
 #define	SET_LEFTLOW_CS1237_SCLK()			PORT_SetBits(LEFTLOW_CS1237_SCLK_PORTx, LEFTLOW_CS1237_SCLK_PINx)//拉高
 #define	CLR_LEFTLOW_CS1237_SCLK()			PORT_ResetBits(LEFTLOW_CS1237_SCLK_PORTx, LEFTLOW_CS1237_SCLK_PINx)//拉低
 #endif
-//<		RIGHTUP CS1237
+//<		右上 CS1237
 #if(USE_CS1237_RIGHTUP == 1)
+#define	RIGHTUP_CS1237_IRQn					(Int003_IRQn)
 #define	RIGHTUP_CS1237_DOUT_PORTx			(PortA)
-#define	RIGHTUP_CS1237_DOUT_PINx			(Pin06)
+#define	RIGHTUP_CS1237_DOUT_PINx			(Pin04)
 #define	SET_RIGHTUP_CS1237_DOUT()			PORT_SetBits(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)//拉高
 #define	CLR_RIGHTUP_CS1237_DOUT()			PORT_ResetBits(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)//拉低
-#define	GET_RIGHTUP_CS1237_DOUT()			Gpio_GetInputIO(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)
+#define	GET_RIGHTUP_CS1237_DOUT()			PORT_GetBit(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)
 
 #define	RIGHTUP_CS1237_SCLK_PORTx			(PortA)
-#define	RIGHTUP_CS1237_SCLK_PINx			(Pin07)
+#define	RIGHTUP_CS1237_SCLK_PINx			(Pin05)
 #define	SET_RIGHTUP_CS1237_SCLK()			PORT_SetBits(RIGHTUP_CS1237_SCLK_PORTx, RIGHTUP_CS1237_SCLK_PINx)//拉高
 #define	CLR_RIGHTUP_CS1237_SCLK()			PORT_ResetBits(RIGHTUP_CS1237_SCLK_PORTx, RIGHTUP_CS1237_SCLK_PINx)//拉低
 #endif
-//<		RIGHRLOW CS1237
+//<		右下 CS1237
-#if(USE_CS1237_RIGHRLOW == 1)
+#if(USE_CS1237_RIGHTLOW == 1)
-#define	RIGHRLOW_CS1237_DOUT_PORTx			(PortA)
+#define	RIGHTLOW_CS1237_IRQn					(Int004_IRQn)
-#define	RIGHRLOW_CS1237_DOUT_PINx			(Pin04)
+#define	RIGHTLOW_CS1237_DOUT_PORTx			(PortA)
-#define	SET_RIGHRLOW_CS1237_DOUT()			PORT_SetBits(RIGHRLOW_CS1237_DOUT_PORTx, RIGHRLOW_CS1237_DOUT_PINx)//拉高
+#define	RIGHTLOW_CS1237_DOUT_PINx			(Pin06)
-#define	CLR_RIGHRLOW_CS1237_DOUT()			PORT_ResetBits(RIGHRLOW_CS1237_DOUT_PORTx, RIGHRLOW_CS1237_DOUT_PINx)//拉低
+#define	SET_RIGHTLOW_CS1237_DOUT()			PORT_SetBits(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx)//拉高
-#define	GET_RIGHRLOW_CS1237_DOUT()			Gpio_GetInputIO(RIGHRLOW_CS1237_DOUT_PORTx, RIGHRLOW_CS1237_DOUT_PINx)
+#define	CLR_RIGHTLOW_CS1237_DOUT()			PORT_ResetBits(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx)//拉低
+#define	GET_RIGHTLOW_CS1237_DOUT()			PORT_GetBit(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx)
 
-#define	RIGHRLOW_CS1237_SCLK_PORTx			(PortA)
+#define	RIGHTLOW_CS1237_SCLK_PORTx			(PortA)
-#define	RIGHRLOW_CS1237_SCLK_PINx			(Pin05)
+#define	RIGHTLOW_CS1237_SCLK_PINx			(Pin07)
-#define	SET_RIGHRLOW_CS1237_SCLK()			PORT_SetBits(RIGHRLOW_CS1237_SCLK_PORTx, RIGHRLOW_CS1237_SCLK_PINx)//拉高
+#define	SET_RIGHTLOW_CS1237_SCLK()			PORT_SetBits(RIGHTLOW_CS1237_SCLK_PORTx, RIGHTLOW_CS1237_SCLK_PINx)//拉高
-#define	CLR_RIGHRLOW_CS1237_SCLK()			PORT_ResetBits(RIGHRLOW_CS1237_SCLK_PORTx, RIGHRLOW_CS1237_SCLK_PINx)//拉低
+#define	CLR_RIGHTLOW_CS1237_SCLK()			PORT_ResetBits(RIGHTLOW_CS1237_SCLK_PORTx, RIGHTLOW_CS1237_SCLK_PINx)//拉低
 #endif
 
+typedef struct {
+
+	uint32_t FactoryFlag;//出厂标志位
+}AppPara_T, *pAppPara;
+
 
 void BSP_Init(void);
 uint8_t DbgUartRec(void);
@@ -206,4 +217,18 @@ void TimeGet(struct tm *cTime);
 int TimeTs(void);
 void TimeShow(uint32_t dwStamp);
 void TimeSync(time_t ts) ;
+
+void delay_5ns(uint32_t ns);
+
+void ExtInt10IntEnable(void);
+void ExtInt10IntDisable(void);
+void ExtInt01IntEnable(void);
+void ExtInt01IntDisable(void);
+void ExtInt04IntEnable(void);
+void ExtInt04IntDisable(void);
+void ExtInt06IntEnable(void);
+void ExtInt06IntDisable(void);
 #endif
+
+
+

Project/HC32F460/source/User/Inc/main.h

@@ -1,5 +1,6 @@
 #ifndef __MAIN__H
 #define __MAIN__H
+#include <stdlib.h>
 #include "bsp.h"
 
 
@@ -7,18 +8,87 @@
 #define	SDCARD_BLOCK_MAX								(10000)
 
 
+#define OSC_CNT    			40
+#define SLOPE_CNT				30
+
+typedef struct{
+	int32_t Slope_VPT;
+	
+	int32_t LeftUpVPT;//左上设备阈值
+	int32_t LeftLowVPT;//左下设备阈值
+	int32_t RightUpVPT;//右上设备阈值
+	int32_t RightLowVPT;//右下设备阈值
+	
+	int32_t LeftUp_Org_AdZero;//左上设备原始AD零点
+	int32_t LeftLow_Org_AdZero;//左上设备原始AD零点
+	int32_t RightUp_Org_AdZero;//右上设备原始AD零点
+	int32_t RightLow_Org_AdZero;//右上设备原始AD零点
+}ADTrack_t;
+
+/*数据读取状态机*/
+typedef enum {
+	READ_STATUS_IDLE,
+	READ_STATUS_START,
+	READ_STATUS_LEFTUP,
+	READ_STATUS_WAIT_LEFTUP,
+	READ_STATUS_LEFTLOW,
+	READ_STATUS_WAIT_LEFTLOW,
+	READ_STATUS_RIGHTUP,
+	READ_STATUS_WAIT_RIGHTUP,
+	READ_STATUS_RIGHTLOW,
+	READ_STATUS_WAIT_RIGHTLOW,
+	READ_STATUS_SUPPORT_CONT
+}ReadStatus_m;
+
+/*主程序状态机*/
+typedef enum {
+	APP_STATUS_IDLE,
+	APP_STATUS_ON,
+	APP_STATUS_OFF,
+	APP_STATUS_WAIT,
+}AppStatus_m;
+
+typedef struct{
+	__IO uint16_t rPayLen;
+	__IO bool HeaderFrame;
+	__IO uint16_t RxLen;
+	uint8_t RxBuff[10];
+}Uart1Rx_t;
 
 typedef struct {
-	uint16_t Acc[3];
+	AppStatus_m Status;//状态
-	uint16_t SensorValue[4];
+	ReadStatus_m RStatus;
-}SendData_t, *SendData;
+	AppPara_T Para;
+	Uart1Rx_t RxUart1Data;
 
+	ADTrack_t ADTrack;	
+	uint32_t TD1mSDelayCnt;
+	uint32_t Read1mSDelayCnt;
+	uint32_t Uart1Delay1mSCnt;
+	uint32_t StopCollDelay1mSCnt;
+	uint32_t EvenRunDelay1mSCnt;
+	uint8_t FeedDogDlyCnt;
 	
-typedef struct {
+	bool UpFlag;//上升标志位
-	uint16_t ADValue[4];
+	bool DownFlag;//下降标志位
-	uint16_t Index;
+	bool StopFlag;//停止标志位
-}SaveData_t, *SaveData;
+	bool EvenRunning;//平稳运行标志位
 
+	bool LeftUpCS1237ReadEndFlag;
+	bool LeftLowCS1237ReadEndFlag;
+	bool RightUpCS1237ReadEndFlag;
+	bool RightLowCS1237ReadEndFlag;	
 
+	int32_t LeftUpCS1237_TrendArray[OSC_CNT];
+	int32_t LeftLowCS1237_TrendArray[OSC_CNT];
+	int32_t RightUpCS1237_TrendArray[OSC_CNT];
+	int32_t RightLowCS1237_TrendArray[OSC_CNT];
+	
+	int32_t LeftUpCS1237_SlopeArray[SLOPE_CNT];
+	int32_t LeftLowCS1237_SlopeArray[SLOPE_CNT];
+	int32_t RightUpCS1237_SlopeArray[SLOPE_CNT];
+	int32_t RightLowCS1237_SlopeArray[SLOPE_CNT];
+}AppDetect_t;
+extern AppDetect_t App;
 
 #endif

Project/HC32F460/source/User/Src/Algorithm.c

@@ -746,6 +746,38 @@ bool isAllZero(uint8_t *arr, int size)
     return true;  // 遍历完数组后，若所有元素都为0，则返回true
 }
 
-
+/*****************************************************************************************
+* 函数名称: HexToAscii
+* 功能描述: 16进制转ASCII码
+* 参    数: HexData，16进制数组
+				ASCData，ASCII码
+				sLen，数据长度
+* 返 回 值: true或false
+*****************************************************************************************/
+void HexToAscii(uint8_t *HexData, char *ASCData, uint8_t sLen)
+{
+	uint8_t temp;
+	
+	for(int i = 0; i < sLen; i++) {
+		temp = (HexData[i] >> 4) & 0x0f;
+		if(temp < 10)
+			temp += '0';
+		else 
+			temp = (temp - 10) + 'A';
+		
+		ASCData[i * 2] = temp;
+		
+		temp = HexData[i] & 0x0f;
+		if(temp < 10)
+			temp += '0';
+		else 
+			temp = (temp - 10) + 'A';
+		
+		ASCData[i * 2 + 1] = temp;
+	}
+	ASCData[sLen * 2] = '\r';
+	ASCData[sLen * 2 + 1] = '\n';
+	ASCData[sLen * 2 + 2] = 0;
+}
 
 

Project/HC32F460/source/User/Src/bsp.c

@@ -3,23 +3,21 @@
 #include "Debug.h"
 #include "hc32f460_efm.h"
 
-
+#include "CS1237_LEFTUP.h" 
+#include "CS1237_LEFTLOW.h" 
+#include "CS1237_RIGHTUP.h" 
+#include "CS1237_RIGHTLOW.h" 
 
 
 #define SPI_MASTER_MODE	
 #define SPI3_MASTER_MODE
 
-
 #define	FLASH_WRITE_ADDR			(0x0003C000u)
 
 
 static void SystemClockConfig(void);
 uint16_t m_au16Adc1SaValue[4];
 
-
-
-
-
 void FlashWrite(uint32_t *wData, uint32_t wLen)
 {
 	EFM_Unlock();
@@ -85,9 +83,9 @@ static void SystemClockConfig(void)
 	/* Config Xtal and Enable Xtal */
     stcXtalCfg.enMode = ClkXtalModeOsc;
     stcXtalCfg.enDrv = ClkXtalLowDrv;
-    stcXtalCfg.enFastStartup = Enable;
+    stcXtalCfg.enFastStartup = Disable;
     CLK_XtalConfig(&stcXtalCfg);
-    CLK_XtalCmd(Enable);
+    CLK_XtalCmd(Disable);
 
 	/* Config Hrc and enable HRC */
 	CLK_HrcTrim(SystemCoreClock);
@@ -104,13 +102,13 @@ static void SystemClockConfig(void)
 	EFM_SetLatency(EFM_LATENCY_5);
 	EFM_Lock();
 
-	/* MPLL config (XTAL / pllmDiv * plln / PllpDiv = 200M). */
+	/* MPLL config (HRC / pllmDiv * plln / PllpDiv = 200M). */
 	stcMpllCfg.pllmDiv = 1ul;
-	stcMpllCfg.plln    = 50ul;
+	stcMpllCfg.plln    = 25ul;
 	stcMpllCfg.PllpDiv = 2ul;
 	stcMpllCfg.PllqDiv = 2ul;
 	stcMpllCfg.PllrDiv = 2ul;
-	CLK_SetPllSource(ClkPllSrcXTAL);
+	CLK_SetPllSource(ClkPllSrcHRC);
 	CLK_MpllConfig(&stcMpllCfg);
 
 	/* Enable MPLL. */
@@ -128,14 +126,14 @@ static void SystemClockConfig(void)
 
 void FeedDog(void)
 {
-#if (USE_DEBUG == 1)	
+#if (USE_WDT == 1)	
 	 SWDT_RefreshCounter();
 #endif	
 }
 
 /*****************************************************************************************
 * 函数名称: Xtal32_ClockConfig
-* 功能描述: 系统低速时钟配置
+* 功能描述: 外部低速时钟配置
 * 参    数: 无
 * 返 回 值: 无
 *****************************************************************************************/
@@ -158,7 +156,14 @@ static void Xtal32_ClockConfig(void)
     /* wait for xtal32 running */
     Ddl_Delay1ms(100u);
 }
-
+void delay_5ns(uint32_t ns)
+{
+	for(uint32_t i = 0; i < ns; i++)
+	{
+		__NOP();
+	}
+}
+#if(USE_RS485 == 1)
 /*****************************************************************************************
 * 函数名称: RS485Uart_Config
 * 功能描述: RS485串口初始化
@@ -244,7 +249,6 @@ static void RS485Uart_Config(uint32_t BaudRate)
 	USART_FuncCmd(RS485_USART_CH, UsartRxInt, Enable);
 }
 
-
 void RS485UartSend(uint8_t *sData, uint16_t sLen)
 {
     RS485_TX();
@@ -297,7 +301,9 @@ static void RS485RxWakeupInit(void)
 	NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);			 /* Enable NVIC */
 	enIntWakeupEnable(Extint2WU);
 }
+#endif
 
+#if(USE_DEBUG == 1)
 static void DbgUart_Config(uint32_t BaudRate)
 {
 	stc_usart_uart_init_t stcInitCfg;
@@ -335,7 +341,7 @@ static void DbgUart_Config(uint32_t BaudRate)
 		Error_Handler();
 	}
 	
-	stcIrqRegiCfg.enIRQn = DBGUART_IRQn;
+	stcIrqRegiCfg.enIRQn = DBG_RX_IRQn;
 	stcIrqRegiCfg.pfnCallback = &DbgUsartRxIrqCallback;
 	stcIrqRegiCfg.enIntSrc = DBG_USART_RI_NUM;
 	enIrqRegistration(&stcIrqRegiCfg);
@@ -343,9 +349,8 @@ static void DbgUart_Config(uint32_t BaudRate)
 	NVIC_ClearPendingIRQ(stcIrqRegiCfg.enIRQn);
 	NVIC_EnableIRQ(stcIrqRegiCfg.enIRQn);
 
-
 	/* Set USART RX error IRQ */
-	stcIrqRegiCfg.enIRQn = DBGUART_EI_IRQn;
+	stcIrqRegiCfg.enIRQn = DBG_ER_IRQn;
 	stcIrqRegiCfg.pfnCallback = &DBGUsartErrIrqCallback;
 	stcIrqRegiCfg.enIntSrc = DBG_USART_EI_NUM;
 	enIrqRegistration(&stcIrqRegiCfg);
@@ -414,7 +419,7 @@ static void DBGRxWakeupInit(void)
 	stcExtiConfig.enExtiLvl = ExIntRisingEdge;
 	EXINT_Init(&stcExtiConfig);
 	stcIrqRegiConf.enIntSrc = DBG_RXPIN_EXIT_SRC;		 /* Select External Int Ch.1 */
-	stcIrqRegiConf.enIRQn = DBG_RXPIN_IRQn;					/* Register External Int to Vect.No.000 */
+	stcIrqRegiConf.enIRQn = DBG_RX_IRQn;					/* Register External Int to Vect.No.000 */
 	stcIrqRegiConf.pfnCallback = &DBG_RxPinIntCallBack;		 /* Callback function */
 	enIrqRegistration(&stcIrqRegiConf);		 /* Registration IRQ */
 	NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);			 /* Clear pending */
@@ -422,36 +427,314 @@ static void DBGRxWakeupInit(void)
 	NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);			 /* Enable NVIC */
 	enIntWakeupEnable(Extint2WU);
 }
-
+#endif
 static void GPIO_Config(void)
 {
 	stc_port_init_t stcPortInit;
-	stc_port_pub_set_t stcPortPub;
-//	stc_exint_config_t stcExtiConfig;
-//	stc_irq_regi_conf_t stcIrqRegiConf;
-	
-	PORT_DebugPortSetting(TDO_SWO, Disable);
-	PORT_DebugPortSetting(TDI, Disable);
-	PORT_DebugPortSetting(TRST, Disable);
 	
 	MEM_ZERO_STRUCT(stcPortInit);
-	MEM_ZERO_STRUCT(stcPortPub);
-	
-	stcPortPub.enReadWait = WaitCycle3;
-	PORT_PubSetting(&stcPortPub);
 	
+	/********************************** GPIO输出 ****************************************/
 	stcPortInit.enPinMode = Pin_Mode_Out;
 	stcPortInit.enPinOType = Pin_OType_Cmos;
 	stcPortInit.enPinDrv = Pin_Drv_H;
-	stcPortInit.enPullUp = Disable;
+	stcPortInit.enPullUp = Disable;//无上拉
 
-	PORT_Init(RS485_CTRL_PORT, RS485_CTRL_PIN, &stcPortInit);
+	PORT_Init(LEFTUP_CS1237_SCLK_PORTx, LEFTUP_CS1237_SCLK_PINx, &stcPortInit);
-	RS485_RX();
+	PORT_Init(LEFTLOW_CS1237_SCLK_PORTx, LEFTLOW_CS1237_SCLK_PINx, &stcPortInit);
+	PORT_Init(RIGHTUP_CS1237_SCLK_PORTx, RIGHTUP_CS1237_SCLK_PINx, &stcPortInit);
+	PORT_Init(RIGHTLOW_CS1237_SCLK_PORTx, RIGHTLOW_CS1237_SCLK_PINx, &stcPortInit);
 	
-    PORT_Init(LED_Blue_PORT, LED_Blue_PIN, &stcPortInit);
-    PORT_Init(LED_Green_PORT, LED_Green_PIN, &stcPortInit);
 }
+/*********************************左上传感器
+ *******************************************************************************
+ ** \brief ExtInt00 callback function
+ **
+ ** \param  None
+ **
+ ** \retval None
+ **
+ ******************************************************************************/
+void ExtInt10_Callback(void)
+{
+    if (Set == EXINT_IrqFlgGet(ExtiCh10))
+    {
+		 LEFTUP_CS1237_IrqCallBack();
+       EXINT_IrqFlgClr(ExtiCh10);
+    }
+}
+void ExtiCh10_Init(void)
+{
+	 stc_exint_config_t stcExtiConfig;
+    stc_irq_regi_conf_t stcIrqRegiConf;
+    stc_port_init_t stcPortInit;
 
+    /* configuration structure initialization */
+    MEM_ZERO_STRUCT(stcExtiConfig);
+    MEM_ZERO_STRUCT(stcIrqRegiConf);
+    MEM_ZERO_STRUCT(stcPortInit);
+
+    /**************************************************************************/
+    /* External Int Ch.10                                                      */
+    /**************************************************************************/
+    stcExtiConfig.enExitCh = ExtiCh10;
+
+    /* Filter setting */
+    stcExtiConfig.enFilterEn = Enable;
+    stcExtiConfig.enFltClk = Pclk3Div8;
+    stcExtiConfig.enExtiLvl = ExIntFallingEdge;
+    EXINT_Init(&stcExtiConfig);
+
+    /* Set External Int */
+    MEM_ZERO_STRUCT(stcPortInit);
+    stcPortInit.enExInt = Enable;
+    PORT_Init(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx, &stcPortInit);
+
+    /* Select External Int Ch.10 */
+    stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ10;
+
+    /* Register External Int to Vect.No.004 */
+    stcIrqRegiConf.enIRQn = LEFTUP_CS1237_IRQn;
+
+    /* Callback function */
+    stcIrqRegiConf.pfnCallback = &ExtInt10_Callback;
+
+    /* Registration IRQ */
+    enIrqRegistration(&stcIrqRegiConf);
+
+    /* Clear pending */
+    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
+
+    /* Set priority */
+    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
+}
+void ExtInt10IntEnable(void)
+{
+	/* Enable NVIC */
+	NVIC_EnableIRQ(LEFTUP_CS1237_IRQn);
+}
+void ExtInt10IntDisable(void)
+{
+	/* Disable NVIC */
+	NVIC_DisableIRQ(LEFTUP_CS1237_IRQn);
+}
+/*******************************左下传感器
+ *******************************************************************************
+ ** \brief ExtInt01 callback function
+ **
+ ** \param  None
+ **
+ ** \retval None
+ **
+ ******************************************************************************/
+void ExtInt01_Callback(void)
+{
+    if (Set == EXINT_IrqFlgGet(ExtiCh01))
+    {
+		 LEFTLOW_CS1237_IrqCallBack();
+       EXINT_IrqFlgClr(ExtiCh01);
+    }
+}
+void ExtiCh01_Init(void)
+{
+	 stc_exint_config_t stcExtiConfig;
+    stc_irq_regi_conf_t stcIrqRegiConf;
+    stc_port_init_t stcPortInit;
+
+    /* configuration structure initialization */
+    MEM_ZERO_STRUCT(stcExtiConfig);
+    MEM_ZERO_STRUCT(stcIrqRegiConf);
+    MEM_ZERO_STRUCT(stcPortInit);
+
+    /**************************************************************************/
+    /* External Int Ch.1                                                      */
+    /**************************************************************************/
+    stcExtiConfig.enExitCh = ExtiCh01;
+
+    /* Filter setting */
+    stcExtiConfig.enFilterEn = Enable;
+    stcExtiConfig.enFltClk = Pclk3Div8;
+    stcExtiConfig.enExtiLvl = ExIntFallingEdge;
+    EXINT_Init(&stcExtiConfig);
+
+    /* Set External Int */
+    MEM_ZERO_STRUCT(stcPortInit);
+    stcPortInit.enExInt = Enable;
+    PORT_Init(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx, &stcPortInit);
+
+    /* Select External Int Ch.1 */
+    stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ1;
+
+    /* Register External Int to Vect.No.005 */
+    stcIrqRegiConf.enIRQn = LEFTLOW_CS1237_IRQn;
+
+    /* Callback function */
+    stcIrqRegiConf.pfnCallback = &ExtInt01_Callback;
+
+    /* Registration IRQ */
+    enIrqRegistration(&stcIrqRegiConf);
+
+    /* Clear pending */
+    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
+
+    /* Set priority */
+    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
+}
+void ExtInt01IntEnable(void)
+{
+	/* Enable NVIC */
+	NVIC_EnableIRQ(LEFTLOW_CS1237_IRQn);
+}
+void ExtInt01IntDisable(void)
+{
+	/* Disable NVIC */
+	NVIC_DisableIRQ(LEFTLOW_CS1237_IRQn);
+}
+/*******************************右上传感器
+ *******************************************************************************
+ ** \brief ExtInt04 callback function
+ **
+ ** \param  None
+ **
+ ** \retval None
+ **
+ ******************************************************************************/
+void ExtInt04_Callback(void)
+{
+    if (Set == EXINT_IrqFlgGet(ExtiCh04))
+    {
+		 RIGHTUP_CS1237_IrqCallBack();
+       EXINT_IrqFlgClr(ExtiCh04);
+    }
+}
+void ExtiCh04_Init(void)
+{
+	 stc_exint_config_t stcExtiConfig;
+    stc_irq_regi_conf_t stcIrqRegiConf;
+    stc_port_init_t stcPortInit;
+
+    /* configuration structure initialization */
+    MEM_ZERO_STRUCT(stcExtiConfig);
+    MEM_ZERO_STRUCT(stcIrqRegiConf);
+    MEM_ZERO_STRUCT(stcPortInit);
+
+    /**************************************************************************/
+    /* External Int Ch.4                                                      */
+    /**************************************************************************/
+    stcExtiConfig.enExitCh = ExtiCh04;
+
+    /* Filter setting */
+    stcExtiConfig.enFilterEn = Enable;
+    stcExtiConfig.enFltClk = Pclk3Div8;
+    stcExtiConfig.enExtiLvl = ExIntFallingEdge;
+    EXINT_Init(&stcExtiConfig);
+
+    /* Set External Int */
+    MEM_ZERO_STRUCT(stcPortInit);
+    stcPortInit.enExInt = Enable;
+    PORT_Init(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx, &stcPortInit);
+
+    /* Select External Int Ch.4 */
+    stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ4;
+
+    /* Register External Int to Vect.No.006 */
+    stcIrqRegiConf.enIRQn = RIGHTUP_CS1237_IRQn;
+
+    /* Callback function */
+    stcIrqRegiConf.pfnCallback = &ExtInt04_Callback;
+
+    /* Registration IRQ */
+    enIrqRegistration(&stcIrqRegiConf);
+
+    /* Clear pending */
+    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
+
+    /* Set priority */
+    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
+}
+void ExtInt04IntEnable(void)
+{
+	/* Enable NVIC */
+	NVIC_EnableIRQ(RIGHTUP_CS1237_IRQn);
+}
+void ExtInt04IntDisable(void)
+{
+	/* Disable NVIC */
+	NVIC_DisableIRQ(RIGHTUP_CS1237_IRQn);
+}
+/*******************************右下传感器
+ *******************************************************************************
+ ** \brief ExtInt04 callback function
+ **
+ ** \param  None
+ **
+ ** \retval None
+ **
+ ******************************************************************************/
+void ExtInt06_Callback(void)
+{
+    if (Set == EXINT_IrqFlgGet(ExtiCh06))
+    {
+		 RIGHTLOW_CS1237_IrqCallBack();
+       EXINT_IrqFlgClr(ExtiCh06);
+    }
+}
+void ExtiCh06_Init(void)
+{
+	 stc_exint_config_t stcExtiConfig;
+    stc_irq_regi_conf_t stcIrqRegiConf;
+    stc_port_init_t stcPortInit;
+
+    /* configuration structure initialization */
+    MEM_ZERO_STRUCT(stcExtiConfig);
+    MEM_ZERO_STRUCT(stcIrqRegiConf);
+    MEM_ZERO_STRUCT(stcPortInit);
+
+    /**************************************************************************/
+    /* External Int Ch.6                                                      */
+    /**************************************************************************/
+    stcExtiConfig.enExitCh = ExtiCh06;
+
+    /* Filter setting */
+    stcExtiConfig.enFilterEn = Enable;
+    stcExtiConfig.enFltClk = Pclk3Div8;
+    stcExtiConfig.enExtiLvl = ExIntFallingEdge;
+    EXINT_Init(&stcExtiConfig);
+
+    /* Set External Int */
+    MEM_ZERO_STRUCT(stcPortInit);
+    stcPortInit.enExInt = Enable;
+    PORT_Init(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx, &stcPortInit);
+
+    /* Select External Int Ch.6 */
+    stcIrqRegiConf.enIntSrc = INT_PORT_EIRQ6;
+
+    /* Register External Int to Vect.No.006 */
+    stcIrqRegiConf.enIRQn = RIGHTLOW_CS1237_IRQn;
+
+    /* Callback function */
+    stcIrqRegiConf.pfnCallback = &ExtInt06_Callback;
+
+    /* Registration IRQ */
+    enIrqRegistration(&stcIrqRegiConf);
+
+    /* Clear pending */
+    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
+
+    /* Set priority */
+    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
+}
+void ExtInt06IntEnable(void)
+{
+	/* Enable NVIC */
+	NVIC_EnableIRQ(RIGHTLOW_CS1237_IRQn);
+}
+void ExtInt06IntDisable(void)
+{
+	/* Disable NVIC */
+	NVIC_DisableIRQ(RIGHTLOW_CS1237_IRQn);
+}
+#if(USE_SPI1 == 1)
 static void Spi_Config(void)
 {
 	stc_spi_init_t stcSpiInit;
@@ -546,10 +829,10 @@ uint16_t SpiSendReceive(uint16_t sData)
 	
 	return rData;
 }
+#endif
 
 
-
+#if(USE_SPI3 == 1)
-//SPI3
 static void Spi3_Config(void)
 {
 	stc_spi_init_t stcSpiInit;
@@ -674,9 +957,10 @@ uint8_t Spi3_RWByte(M4_SPI_TypeDef *SPIx, uint8_t u8Data)
 		}
     return SPIx->DR;
 }
+#endif
 
 
-
+#if(USE_RTC == 1)
 /*****************************************************************************************
 * 函数名称: Rtc_Config
 * 功能描述: RTC配置
@@ -805,7 +1089,8 @@ void TimeSync(time_t ts)
     DBG_LOG("TimeSync = %d-%d-%d %d:%d:%d\n", RtcDateTime.u8Year, RtcDateTime.u8Month, \
             RtcDateTime.u8Day, RtcDateTime.u8Hour, RtcDateTime.u8Minute, RtcDateTime.u8Second);
 }
-
+#endif
+#if(USE_AD == 1)
 /*****************************************************************************************
 * 函数名称: AdcInitConfig
 * 功能描述: ADC初始化配置
@@ -957,7 +1242,8 @@ static void AdcDmaConfig(void)
 	PWC_Fcg0PeriphClockCmd(PWC_FCG0_PERIPH_AOS, Enable);
 	DMA_SetTriggerSrc(M4_DMA1, DmaCh0, EVT_ADC1_EOCA);
 }
-
+#endif
+#if(USE_DMA == 1)
 /*****************************************************************************************
 * 函数名称: DmaIrqRegister
 * 功能描述: DMA中断寄存器配置
@@ -1012,7 +1298,7 @@ static void Dma_Config(void)
     AdcDmaConfig();
     DmaIrqConfig();
 }
-
+#endif
 /*****************************************************************************************
 * 函数名称: ReadAdcValue
 * 功能描述: 读取AD值
@@ -1053,26 +1339,32 @@ void ReadAdcValue(uint16_t *ADValue)
 
 void BSP_Init(void)
 {
+	
 	stc_clk_freq_t Freq;
 	SystemClockConfig();
 	SystemCoreClockUpdate();
-	Xtal32_ClockConfig();
+	//Xtal32_ClockConfig();
 	GPIO_Config();
-	DbgUart_Config(500000);
+	ExtiCh10_Init();
-   RS485Uart_Config(9600);
+	ExtiCh01_Init();
-	Rtc_Config();
+	ExtiCh06_Init();
-//	SdioInit();
+	ExtiCh04_Init();
-	//Spi_Config();
-    Spi3_Config();
 	
-	Adc1_Config();
+	DbgUart_Config(500000);
-	Dma_Config();
+	//RS485Uart_Config(9600);
-	FeedDog();
+	
-	SysTick_Init(1000);
+	//Rtc_Config();
+	//SdioInit();
+	//Spi_Config();
+   // Spi3_Config();
+
+	//Adc1_Config();
+	//Dma_Config();
+	//FeedDog();
+	SysTick_Init(1000u);
 	SysTick_Delay(1000);
 	CLK_GetClockFreq(&Freq);
-	TimeSync(1705578500);
+	//DBG_LOG("SysFreq = %d\r\n", Freq.sysclkFreq);
-	DBG_LOG("SysFreq = %d\r\n", Freq.sysclkFreq);
 }
 
 /*****************************************************************************************
@@ -1087,7 +1379,7 @@ void EnterStop(void)
 	stc_port_init_t stcPortInit;
 	uint16_t AnaPin;
 	
-	PWC_Fcg1PeriphClockCmd(SPI3_UNIT_CLOCK, Disable);
+	//PWC_Fcg1PeriphClockCmd(SPI3_UNIT_CLOCK, Disable);
 	PWC_Fcg1PeriphClockCmd(DBG_FCG1_PERIPH, Disable);
 	DBGRxWakeupInit();
 	
@@ -1126,12 +1418,12 @@ extern uint8_t BDRxData[256];
 *****************************************************************************************/
 void Wakeup(void)
 {
-	NVIC_DisableIRQ(DBG_RXPIN_IRQn);
+	NVIC_DisableIRQ(DBG_RX_IRQn);
 	PWC_ClkRecover();
 	//SystemClockConfig();
-	Spi3_Config();
+	//Spi3_Config();
 	DbgUart_Config(5000000);
-    RS485Uart_Config(9600);
+   // RS485Uart_Config(9600);
 	//GPIO_Config();
 	//SysTick_Resume();
 	SysTick_Init(1000);
@@ -1148,12 +1440,10 @@ void Error_Handler(void)
 
 
 
-
+#if(USE_RS485 == 1)
-
-
-
 __WEAK void RS485UsartErrIrqCallback(void)
 {
+
 	if(RS485_USART_CH->SR_f.ORE) {
 		RS485_USART_CH->CR1_f.CORE = 1;
 		USART_RecData(RS485_USART_CH);
@@ -1164,12 +1454,8 @@ __WEAK void RS485UsartErrIrqCallback(void)
 	
 	if(RS485_USART_CH->SR_f.FE)
 		RS485_USART_CH->CR1_f.CFE = 1;
+
 }
-
-
-
-
-
 __WEAK void RS485_RxPinIntCallBack(void)
 {
     
@@ -1178,6 +1464,7 @@ __WEAK void RS485_RxPinIntCallBack(void)
 
 
 
+#endif
 __WEAK void DBGUsartErrIrqCallback(void)
 {
 	if(DBG_USART_CH->SR_f.ORE) {

Project/HC32F460/source/User/Src/main.c

@@ -4,62 +4,435 @@
 #include "main.h"
 #include "Encryption.h"
 #include "Debug.h"
-
+#include "Algorithm.h"
+#include "CS1237_LEFTUP.h" 
+#include "CS1237_LEFTLOW.h" 
+#include "CS1237_RIGHTUP.h" 
+#include "CS1237_RIGHTLOW.h" 
 
 #define	MAIN_DBG_LOG(...)								DBG_LOG(__VA_ARGS__)
 #define	MAIN_DBG_ARRAY(ARRAY, SIZE)				DBG_ARRAY(ARRAY,SIZE)
 
-uint8_t TestData[16 * 512];
+#define	SOFTWARE_VERSION								10	//软件版本
+#define	HARDWARE_VERSION								20	//硬件版本
 
+AppDetect_t App;
 
-
+static void show(uint8_t ch,int32_t ad)
-
-void HexToAscii(uint8_t *HexData, char *ASCData, uint8_t sLen)
 {
-	uint8_t temp;
+		uint8_t bao[7];
-	
+	bao[0] = 0x5A;
-	for(int i = 0; i < sLen; i++) {
+	bao[1] = ch;
-		temp = (HexData[i] >> 4) & 0x0f;
+	bao[2] = ad & 0xFF;
-		if(temp < 10)
+	bao[3] = ad >> 8 & 0xFF;
-			temp += '0';
+	bao[4] = ad >> 16 & 0xFF;
-		else 
+	bao[5] = ad >> 24 & 0xFF;
-			temp = (temp - 10) + 'A';
+	bao[6] = 0xA5;
-		
+	DebugUartSend(bao,7);
-		ASCData[i * 2] = temp;
+}
-		
+void LEFTUP_CS1237AinADataProcessCallBack(int32_t AD)
-		temp = HexData[i] & 0x0f;
+{
-		if(temp < 10)
+	show(1,AD);
-			temp += '0';
+	for(int i = OSC_CNT-1; i > 0; i--)
-		else 
+	{
-			temp = (temp - 10) + 'A';
+		App.LeftUpCS1237_TrendArray[i] = App.LeftUpCS1237_TrendArray[i - 1];
-		
-		ASCData[i * 2 + 1] = temp;
 	}
-	ASCData[sLen * 2] = '\r';
+	App.LeftUpCS1237_TrendArray[0] = AD;
-	ASCData[sLen * 2 + 1] = '\n';
+	App.LeftUpCS1237ReadEndFlag = true;
-	ASCData[sLen * 2 + 2] = 0;
 }
-
+void LEFTLOW_CS1237AinADataProcessCallBack(int32_t AD)
-
-
-
-void ADC_DMA_CallBack(void)
 {
+	show(2,AD);
+	for(int i = OSC_CNT-1; i > 0; i--)
+	{
+		App.LeftLowCS1237_TrendArray[i] = App.LeftLowCS1237_TrendArray[i - 1];
+	}
+	App.LeftLowCS1237_TrendArray[0] = AD;
+	App.LeftLowCS1237ReadEndFlag = true;
+}
+void RIGHTUP_CS1237AinADataProcessCallBack(int32_t AD)
+{
+	show(3,AD);
+	for(int i = OSC_CNT-1; i > 0; i--)
+	{
+		App.RightUpCS1237_TrendArray[i] = App.RightUpCS1237_TrendArray[i - 1];
+	}
+	App.RightUpCS1237_TrendArray[0] = AD;
+	App.RightUpCS1237ReadEndFlag = true;
+}
+void RIGHTLOW_CS1237AinADataProcessCallBack(int32_t AD)
+{
+	show(4,AD);
+	for(int i = OSC_CNT-1; i > 0; i--)
+	{
+		App.RightLowCS1237_TrendArray[i] = App.RightLowCS1237_TrendArray[i - 1];
+	}
+	App.RightLowCS1237_TrendArray[0] = AD;
+	App.RightLowCS1237ReadEndFlag = true;
+}
+#if 0
+void SupportControlHandle(int32_t *Ain1_ad, int32_t *Ain2_ad)
+{
+	int32_t A1_diff[OSC_CNT], A2_diff[OSC_CNT], O1_diff1, O1_diff2, O1_diff3, O2_diff1, O2_diff2, O2_diff3;
+	O1_diff1 = Ain1_ad[0] - App.ADTrack.Ain1_Org_AdZero;
+	O1_diff2 = Ain1_ad[1] - App.ADTrack.Ain1_Org_AdZero;
+	O1_diff3 = Ain1_ad[2] - App.ADTrack.Ain1_Org_AdZero;
+	O2_diff1 = Ain2_ad[0] - App.ADTrack.Ain2_Org_AdZero;
+	O2_diff2 = Ain2_ad[1] - App.ADTrack.Ain2_Org_AdZero;
+	O2_diff3 = Ain2_ad[2] - App.ADTrack.Ain2_Org_AdZero;
+	for(int i = 0; i < OSC_CNT; i++)
+	{
+		A1_diff[i] = Ain1_ad[i] - Ain1_ad[OSC_CNT - 1];
+		A2_diff[i] = Ain2_ad[i] - Ain2_ad[OSC_CNT - 1];
+	}
+	TrendResult result_A1 = analyze_trend(A1_diff, OSC_CNT);
+	TrendResult result_A2 = analyze_trend(A2_diff, OSC_CNT);
 	
+	int32_t A1_slope = result_A1.slope;
+	int32_t A2_slope = result_A2.slope;
+	//show2(A2_slope);
+
+	for(int i = SLOPE_CNT-1; i > 0; i--)
+	{
+		App.LeftUpCS1237_SlopeArray[i] = App.LeftUpCS1237_SlopeArray[i - 1];
+		App.LeftLowCS1237_SlopeArray[i] = App.LeftLowCS1237_SlopeArray[i - 1];
+	}
+	App.LeftUpCS1237_SlopeArray[0] = A1_slope;
+	App.LeftLowCS1237_SlopeArray[0] = A2_slope;
+	
+	PeakValleyCheck result1_K = check_peaks_valleys(App.LeftUpCS1237_SlopeArray, SLOPE_CNT);
+	PeakValleyCheck result2_K = check_peaks_valleys(App.LeftLowCS1237_SlopeArray, SLOPE_CNT);
+	
+	if(App.StopFlag == true)
+	{
+		if(App.StopCollDelay1mSCnt <= 0)
+		{
+			if(((App.LeftUpCS1237_SlopeArray[0] <= -App.ADTrack.Slope_VPT) 
+			&& (App.LeftUpCS1237_SlopeArray[1] <= -App.ADTrack.Slope_VPT) 
+			&& (App.LeftUpCS1237_SlopeArray[2] <= -App.ADTrack.Slope_VPT) 
+			&& (App.LeftLowCS1237_SlopeArray[0] >= App.ADTrack.Slope_VPT)
+			&& (App.LeftLowCS1237_SlopeArray[1] >= App.ADTrack.Slope_VPT)
+			&& (App.LeftLowCS1237_SlopeArray[2] >= App.ADTrack.Slope_VPT)) 
+			|| ((O1_diff1 >= App.ADTrack.Ain1VPT)
+			&& (O1_diff2 >= App.ADTrack.Ain1VPT)
+			&& (O1_diff3 >= App.ADTrack.Ain1VPT)
+			&& (O2_diff1 <= -App.ADTrack.Ain2VPT)
+			&& (O2_diff2 <= -App.ADTrack.Ain2VPT)
+			&& (O2_diff3 <= -App.ADTrack.Ain2VPT)))
+			{
+				//BDC_UP();
+				App.UpFlag = true;
+				App.StopFlag = false;
+				App.DownFlag = false;
+			}
+			else if(((App.Ain1_SlopeArray[0] >= App.ADTrack.Slope_VPT) 
+			&& (App.Ain1_SlopeArray[1] >= App.ADTrack.Slope_VPT) 
+			&& (App.Ain1_SlopeArray[2] >= App.ADTrack.Slope_VPT) 
+			&& (App.Ain2_SlopeArray[0] <= -App.ADTrack.Slope_VPT)
+			&& (App.Ain2_SlopeArray[1] <= -App.ADTrack.Slope_VPT)
+			&& (App.Ain2_SlopeArray[2] <= -App.ADTrack.Slope_VPT))
+			|| ((O1_diff1 <= -App.ADTrack.Ain1VPT) 
+			&& (O1_diff2 <= -App.ADTrack.Ain1VPT)
+			&& (O1_diff3 <= -App.ADTrack.Ain1VPT)
+			&& (O2_diff1 >= App.ADTrack.Ain2VPT)
+			&& (O2_diff2 >= App.ADTrack.Ain2VPT)
+			&& (O2_diff3 >= App.ADTrack.Ain2VPT)))
+			{
+				//BDC_DOWN();
+				App.DownFlag = true;
+				App.StopFlag = false;
+				App.UpFlag = false;
+			}
+		}
+	}
+	else if(App.DownFlag == true)
+	{
+		if(A1_slope < -App.ADTrack.Slope_VPT
+		&& A2_slope > App.ADTrack.Slope_VPT)
+		{
+			//BDC_STOP();
+			App.StopFlag = true;
+			App.DownFlag = false;
+			App.UpFlag = false;
+			App.StopCollDelay1mSCnt = 1000;
+		}
+		else if(O1_diff1 > -(App.ADTrack.Ain1VPT / 2)
+		&& O2_diff1 < (App.ADTrack.Ain2VPT / 2))
+		{
+			//BDC_STOP();
+			App.StopFlag = true;
+			App.DownFlag = false;
+			App.UpFlag = false;
+			App.StopCollDelay1mSCnt = 1000;
+		}
+	}
+	else if(App.UpFlag == true)
+	{
+		if(A1_slope > App.ADTrack.Slope_VPT
+		&& A2_slope < -App.ADTrack.Slope_VPT)
+		{
+				//BDC_STOP();
+				App.StopFlag = true;
+				App.DownFlag = false;
+				App.UpFlag = false;
+				App.StopCollDelay1mSCnt = 1000;
+		}
+		else if(O1_diff1 < (App.ADTrack.Ain1VPT / 2)
+		&& O2_diff1 > -(App.ADTrack.Ain2VPT / 2))
+		{
+			//BDC_STOP();
+			App.StopFlag = true;
+			App.DownFlag = false;
+			App.UpFlag = false;
+			App.StopCollDelay1mSCnt = 1000;
+		}
+	}
+	
+	if (result1_K.peaks_positive 
+		&& result1_K.valleys_negative 
+		&& A1_diff[0] < App.ADTrack.Slope_VPT / 2 
+		&& A1_diff[0] > -App.ADTrack.Slope_VPT / 2
+		&& A1_diff[1] < App.ADTrack.Slope_VPT / 2 
+		&& A1_diff[1] > -App.ADTrack.Slope_VPT / 2
+		&& A1_diff[2] < App.ADTrack.Slope_VPT / 2 
+		&& A1_diff[2] > -App.ADTrack.Slope_VPT / 2
+		&& result2_K.peaks_positive 
+		&& result2_K.valleys_negative 
+		&& A2_diff[0] < App.ADTrack.Slope_VPT / 2 
+		&& A2_diff[0] > -App.ADTrack.Slope_VPT / 2
+		&& A2_diff[1] < App.ADTrack.Slope_VPT / 2 
+		&& A2_diff[1] > -App.ADTrack.Slope_VPT / 2
+		&& A2_diff[2] < App.ADTrack.Slope_VPT / 2 
+		&& A2_diff[2] > -App.ADTrack.Slope_VPT / 2) 
+	{
+		if(App.StopFlag == true && App.StopCollDelay1mSCnt <= 0){
+			App.ADTrack.Ain1_Org_AdZero = Ain1_ad[0];
+			App.ADTrack.Ain2_Org_AdZero = Ain2_ad[0];
+		}
+		else if(App.StopFlag == false)
+		{
+			App.EvenRunning = true;
+			App.EvenRunDelay1mSCnt = 0;
+		}
+	}
+	else
+	{
+		App.EvenRunning = false;
+		App.EvenRunDelay1mSCnt = 0;
+	}
+	if(App.EvenRunDelay1mSCnt >= 2000)
+	{
+		App.EvenRunning = false;
+		App.EvenRunDelay1mSCnt = 0;
+		App.ADTrack.Ain1_Org_AdZero = Ain1_ad[0];
+		App.ADTrack.Ain2_Org_AdZero = Ain2_ad[0];
+	}
+}
+#endif
+static void AppInit(void)
+{
+	DBG_LOG("\r\n\r\n");
+	DBG_LOG("****************************************************\r\n");
+	DBG_LOG("**                                                **\r\n");
+	DBG_LOG("**           	Acc_Support_29V            	  **\r\n");
+	DBG_LOG("**                SoftWare V:%d.%d                  **\r\n", SOFTWARE_VERSION / 10, SOFTWARE_VERSION % 10);
+	DBG_LOG("**                HardWare V:%d.%d                  **\r\n", HARDWARE_VERSION / 10, HARDWARE_VERSION % 10);
+	DBG_LOG("**         Compile: %s %s          **\r\n", __DATE__, __TIME__);
+	DBG_LOG("**                                                **\r\n");
+	DBG_LOG("****************************************************\r\n\r\n");
+	
+	//FeedDog();
+	LEFTUP_CS1237_Init();
+	LEFTLOW_CS1237_Init();
+	RIGHTUP_CS1237_Init();
+	RIGHTLOW_CS1237_Init();
+	
+	App.Status = APP_STATUS_WAIT;
+	App.TD1mSDelayCnt = 2000;
+	App.RStatus = READ_STATUS_START;
+}
+static void ReadLoopHandler(void)
+{
+	switch(App.RStatus){
+		case READ_STATUS_IDLE:{
+		break;}
+		
+		case READ_STATUS_START:{
+			App.LeftUpCS1237ReadEndFlag = false;
+			App.LeftLowCS1237ReadEndFlag = false;
+			App.RightUpCS1237ReadEndFlag = false;
+			App.RightLowCS1237ReadEndFlag = false;
+			App.RStatus = READ_STATUS_LEFTUP;
+		break;}
+		
+		case READ_STATUS_LEFTUP:{
+			LEFTUP_CS1237Start();
+			App.Read1mSDelayCnt = 50;
+			App.RStatus = READ_STATUS_WAIT_LEFTUP;
+		break;}
+		
+		case READ_STATUS_WAIT_LEFTUP:{
+			if(App.Read1mSDelayCnt <= 0)
+			{
+				App.RStatus = READ_STATUS_LEFTLOW;
+			}
+			else if(App.LeftUpCS1237ReadEndFlag == true)
+			{
+				App.RStatus = READ_STATUS_LEFTLOW;
+			}
+		break;}
+		
+		case READ_STATUS_LEFTLOW:{
+			LEFTLOW_CS1237Start();
+			App.Read1mSDelayCnt = 50;
+			App.RStatus = READ_STATUS_WAIT_LEFTLOW;
+		break;}
+		
+		case READ_STATUS_WAIT_LEFTLOW:{
+			if(App.Read1mSDelayCnt <= 0)
+			{
+				App.RStatus = READ_STATUS_RIGHTUP;
+			}
+			else if(App.LeftLowCS1237ReadEndFlag == true)
+			{
+				App.RStatus = READ_STATUS_RIGHTUP;
+			}
+		break;} 
+				
+		case READ_STATUS_RIGHTUP:{
+			RIGHTUP_CS1237Start();
+			App.Read1mSDelayCnt = 50;
+			App.RStatus = READ_STATUS_WAIT_RIGHTUP;
+		break;}
+		
+		case READ_STATUS_WAIT_RIGHTUP:{
+			if(App.Read1mSDelayCnt <= 0)
+			{
+				App.RStatus = READ_STATUS_RIGHTLOW;
+			}
+			else if(App.RightUpCS1237ReadEndFlag == true)
+			{
+				App.RStatus = READ_STATUS_RIGHTLOW;
+			}
+		break;}
+		
+		case READ_STATUS_RIGHTLOW:{
+				RIGHTLOW_CS1237Start();
+			App.Read1mSDelayCnt = 50;
+			App.RStatus = READ_STATUS_WAIT_RIGHTLOW;
+		break;}
+		
+		case READ_STATUS_WAIT_RIGHTLOW:{
+			if(App.Read1mSDelayCnt <= 0)
+			{
+				App.RStatus = READ_STATUS_SUPPORT_CONT;
+			}
+			else if(App.RightLowCS1237ReadEndFlag == true)
+			{
+				App.RStatus = READ_STATUS_SUPPORT_CONT;
+			}
+		break;}
+		
+		case READ_STATUS_SUPPORT_CONT:{
+			if(App.LeftUpCS1237ReadEndFlag == true && 
+				App.LeftLowCS1237ReadEndFlag == true &&
+				App.RightUpCS1237ReadEndFlag == true &&
+				App.RightLowCS1237ReadEndFlag == true)
+			{
+				App.LeftUpCS1237ReadEndFlag = false;
+				App.LeftUpCS1237ReadEndFlag = false;
+				App.RightUpCS1237ReadEndFlag = false;
+				App.RightLowCS1237ReadEndFlag = false;
+				//SupportControlHandle(App.Ain1_TrendArray, App.Ain2_TrendArray);
+			}
+			App.RStatus = READ_STATUS_START;
+		break;}
+	}
 }
 
+static void AppLoopHandler(void)
+{
+	switch(App.Status) {
+		case APP_STATUS_IDLE:{
+			break;}
 		
+		case APP_STATUS_ON:{
+			App.Status = APP_STATUS_IDLE;
+		break;}
 		
+		case APP_STATUS_OFF:{
 		
+			App.Status = APP_STATUS_IDLE;
+		break;}
 		
+		case APP_STATUS_WAIT:{
+			if(App.TD1mSDelayCnt <= 0)
+			{				
+				App.UpFlag = false;
+				App.DownFlag = false;
+				App.StopFlag = true;
+				App.EvenRunning = false;
+				
+				App.ADTrack.Slope_VPT = 1000;
+				App.ADTrack.LeftUpVPT = 20000;
+				App.ADTrack.LeftLowVPT = 20000;
+				App.ADTrack.RightUpVPT = 20000;
+				App.ADTrack.RightLowVPT = 20000;			
+				
+				App.ADTrack.LeftUp_Org_AdZero = App.LeftUpCS1237_TrendArray[0];
+				App.ADTrack.LeftLow_Org_AdZero = App.LeftLowCS1237_TrendArray[0];
+				App.ADTrack.RightUp_Org_AdZero = App.RightUpCS1237_TrendArray[0];
+				App.ADTrack.RightLow_Org_AdZero = App.RightLowCS1237_TrendArray[0];
+				DBG_LOG("Frist Pack Data LeftUp Zero AD: %08d\tLeftUp Zero AD: %08d\tRightUp Zero AD: %08d\tRightLow Zero AD: %08d\r\n", 
+				App.ADTrack.LeftUp_Org_AdZero, 
+				App.ADTrack.LeftLow_Org_AdZero,
+				App.ADTrack.RightUp_Org_AdZero,
+				App.ADTrack.RightLow_Org_AdZero);
+				App.Status = APP_STATUS_IDLE;
+			}
+		break;}
+	}
+}
+static void App1mSRoutine(void)
+{
+	if(App.TD1mSDelayCnt > 0)
+		App.TD1mSDelayCnt--;
+	if(App.Read1mSDelayCnt > 0)
+		App.Read1mSDelayCnt--;
+	if(App.Uart1Delay1mSCnt > 0)
+		App.Uart1Delay1mSCnt--;
+	if(App.StopCollDelay1mSCnt > 0)
+		App.StopCollDelay1mSCnt--;
+	
+	if(App.EvenRunning == true)
+		App.EvenRunDelay1mSCnt++;
+
+	App.FeedDogDlyCnt++;
+}
+void FeedDogHandler(void)
+{
+	if(App.FeedDogDlyCnt >= 200) {
+		FeedDog(); 
+		App.FeedDogDlyCnt = 0;
+	}
+}
 int main(void) 
 {
 	BSP_Init();
-    DBG_LOG("**********************************************\r\n");
+   AppInit();
-    DBG_LOG("*             Ver 1.0 2024-01-15             *\r\n");
-    DBG_LOG("**********************************************\r\n");
 	while(1) {
+#if(USE_WDT == 1)
+		FeedDogHandler();
+#endif
+#if(USE_DEBUG == 1)
 		DebugLoopHandler();
+#endif
+		LEFTUP_CS1237DataLoopCollect();
+		LEFTLOW_CS1237DataLoopCollect();
+		RIGHTUP_CS1237DataLoopCollect();
+		RIGHTLOW_CS1237DataLoopCollect();
+		ReadLoopHandler();
+		AppLoopHandler();
 	}
 }
 
@@ -72,7 +445,12 @@ int main(void)
 void SysTick_IrqHandler(void)
 {
 	SysTick_IncTick();
+	App1mSRoutine();
 	Dbg1msRoutine();
+	LEFTUP_CS12371mSRoutine();
+	LEFTLOW_CS12371mSRoutine();
+	RIGHTUP_CS12371mSRoutine();
+	RIGHTLOW_CS12371mSRoutine();
 }
 
 /*****************************************************************************************
@@ -93,4 +471,7 @@ void RtcPeriod_IrqCallback(void)
     //PORT_Toggle(LED_Green_PORT, LED_Green_PIN);
 }
 
+void ADC_DMA_CallBack(void)
+{
+}
 

driver/inc/hc32f460_gpio.h

@@ -272,6 +272,7 @@ extern en_flag_status_t PORT_GetBit(en_port_t enPort, en_pin_t enPin);
 extern en_result_t PORT_SetPortData(en_port_t enPort, uint16_t u16Pin);
 extern en_result_t PORT_ResetPortData(en_port_t enPort, uint16_t u16Pin);
 extern en_result_t PORT_OE(en_port_t enPort, uint16_t u16Pin, en_functional_state_t enNewState);
+extern en_result_t PORT_PIDR(en_port_t enPort, uint16_t u16Pin, en_functional_state_t enNewState);
 extern en_result_t PORT_SetBits(en_port_t enPort, uint16_t u16Pin);
 extern en_result_t PORT_ResetBits(en_port_t enPort, uint16_t u16Pin);
 extern en_result_t PORT_Toggle(en_port_t enPort, uint16_t u16Pin);

driver/inc/hc32f460_icg.h

@@ -258,7 +258,7 @@ extern "C"
  ** \brief SWDT hardware start configuration
  ******************************************************************************/
 /*!< Enable or disable SWDT hardware start */
-#if (USE_DEBUG == 1)
+#if (USE_WDT == 1)
 #define ICG0_SWDT_HARDWARE_START                (ICG_FUNCTION_ON)
 #else
 #define ICG0_SWDT_HARDWARE_START                (ICG_FUNCTION_OFF)

driver/src/hc32f460_gpio.c

@@ -483,7 +483,6 @@ en_result_t PORT_OE(en_port_t enPort, uint16_t u16Pin, en_functional_state_t enN
     return Ok;
 
 }
-
 /**
  *******************************************************************************
  ** \brief   Set Port Pin
@@ -507,7 +506,6 @@ en_result_t PORT_SetBits(en_port_t enPort, uint16_t u16Pin)
     return Ok;
 
 }
-
 /**
  *******************************************************************************
  ** \brief   Reset Port Pin

mcu/common/hc32_common.h

@@ -139,7 +139,7 @@ typedef enum en_result
     #define __UNUSED                    __attribute__((unused))
   #endif /* __UNUSED */
   #ifndef __RAM_FUNC
-    #define __RAM_FUNC                  __attribute__((long_call, section(".ramfunc")))
+    #define __RAM_FUNC                  __attribute__((section(".ramfunc")))
     /* Usage: void __RAM_FUNC foo(void) */
   #endif /* __RAM_FUNC */
 #elif defined (__ICCARM__)                ///< IAR Compiler