F030C8T6_Kbus_MIX.git

QuakeGod

2024-07-27 842bb64195f958b050867c50db66fc0aa413dafb

提交 \| 用户 \| age
5dd1b7	1
Q	2	/**
	3	******************************************************************************
	4	* @file : main.c
	5	* @brief : Main program body
	6	******************************************************************************
	7	** This notice applies to any and all portions of this file
	8	* that are not between comment pairs USER CODE BEGIN and
	9	* USER CODE END. Other portions of this file, whether
	10	* inserted by the user or by software development tools
	11	* are owned by their respective copyright owners.
	12	*
	13	* COPYRIGHT(c) 2018 STMicroelectronics
	14	*
	15	* Redistribution and use in source and binary forms, with or without modification,
	16	* are permitted provided that the following conditions are met:
	17	* 1. Redistributions of source code must retain the above copyright notice,
	18	* this list of conditions and the following disclaimer.
	19	* 2. Redistributions in binary form must reproduce the above copyright notice,
	20	* this list of conditions and the following disclaimer in the documentation
	21	* and/or other materials provided with the distribution.
	22	* 3. Neither the name of STMicroelectronics nor the names of its contributors
	23	* may be used to endorse or promote products derived from this software
	24	* without specific prior written permission.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	27	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	29	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	32	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	33	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	34	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	35	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	36	*
	37	******************************************************************************
	38	*/
	39	/* Includes ------------------------------------------------------------------*/
	40	#include "main.h"
	41	#include "stm32f0xx_hal.h"
	42
	43	/* USER CODE BEGIN Includes */
	44	#include "Globaldef.h"
	45	#include "debug.h"
	46	#include "Functions.h"
	47	#include "KMachine.h"
	48	#include "PLCfunctions.h"
	49	//#include "KBus.h"
	50	#include "KLink.h"
	51	#include "string.h"
	52	#include "BSP.h"
	53	#include "ModbusRTU.h"
	54	#if (BOARD_TYPE == 13)
	55	#include "w5500_port.h"
	56	#include "../src/Ethernet/socket.h"
	57	#include "../src/Ethernet/loopback.h"
	58	#elif (BOARD_TYPE == 14)
	59	#include "FP0.h"
	60	#elif (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	61	#include "KWireless.h"
	62	//#include "user.h"
	63	//#include "../src/radio/inc/sx126x-board.h"
	64	#endif
	65
	66	/* USER CODE END Includes */
	67
	68	/* Private variables ---------------------------------------------------------*/
	69
	70	/* USER CODE BEGIN PV */
	71	/* Private variables ---------------------------------------------------------*/
	72
	73	#define RX2BUFSIZE 64
	74	#define TX2BUFSIZE 64
	75
	76	unsigned char Uart1RxBuf[128];
	77	unsigned char Uart1TxBuf[260];
	78
	79	unsigned char Uart2RxBuf[RX2BUFSIZE];
	80	unsigned char Uart2TxBuf[TX2BUFSIZE];
	81
	82	unsigned char SlowFlicker=0;
	83	unsigned char FastFlicker=0;
	84
	85	unsigned int Uart1IdelTimer = 0;
	86
	87	uint32_t us1,us2,us3,us4,us5,us6;
	88
842bb6	89
Q	90	stKBusDef KBus1; //
	91
	92	extern stDeviceInfo MyDeviceInfo;
5dd1b7	93	/* USER CODE END PV */
Q	94
	95	/* Private function prototypes -----------------------------------------------*/
	96
	97
	98	/* USER CODE BEGIN PFP */
	99	/* Private function prototypes -----------------------------------------------*/
	100
	101	const unsigned char LEDSEGTAB[]={
	102	0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71, //0-F
	103	0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef,0xf7,0xfc,0xb9,0xde,0xf9,0xf1, //0.-F.
	104	0x00,0x40, // ,-,_,~,o,n,N,<,>,J,r,
	105	};
	106
	107	/* USER CODE END PFP */
	108
	109	/* USER CODE BEGIN 0 */
	110
	111	int HexToInt(char ch)
	112	{
	113	if (ch>='0' && ch <='9') return ch-'0';
	114	if (ch>='A' && ch <='F') return ch-'A'+10;
	115	if (ch>='a' && ch <='f') return ch-'a'+10;
	116	return 0;
	117	}
	118
	119	void HAL_SYSTICK_Callback(void)
	120	{
	121	static int Count=0;
	122	CurTickuS += 100;
	123	nCurTick++;
842bb6	124	KBus1.nSlaveTick++;
5dd1b7	125	Count++;
Q	126	if (Count>=10000)
	127	{
	128	Count=0;
	129	KMem.CurTimeSec++;
	130	KMem.ThisRunTime++; KMem.TotalRunTime++;
	131	if (KMRunStat.bLEDFlick) KMRunStat.bLEDFlick--;
	132	if (KMRunStat.bLEDFlick >120) KMRunStat.bLEDFlick=120;
	133	}
	134
	135	return;
	136	}
	137
842bb6	138	void PendSvCallBack()
Q	139	{
	140	#if (BOARD_TYPE == 14)
	141	///*
	142	if (bSPI1RecvDone)
	143	{
	144	bSPI1RecvDone=0;
	145	FPxParsePkt(SPI1RecvBuf,nSPI1RecvLenInBuf);
	146	}
	147	//*/
	148	#endif
	149	if (Uart2Stat.bPacketRecved)
	150	{
	151	KBusParsePacket(&KBus1, (pKBPacket)Uart2RecvBuf1, Uart2RecvBuf1DataLen);
	152	Uart2RecvBuf1DataLen=0;
	153	Uart2Stat.bPacketRecved=0;
	154	Uart2RecvDMA(Uart2RecvBuf1,sizeof(Uart2RecvBuf1));
	155	KMem.WDT[2]++;
	156	}
	157	}
	158
	159	/*
	160	KBus通讯回调函数，当通讯状态改变或数据更新时被调用。
	161	或者系统请求时。
	162	*/
	163	void * KBusEvCallBackFunc(void* pParam, int nEvent, void *pBuf, int nLen1)
5dd1b7	164	{
Q	165	switch (nEvent){
	166
	167	case KBusEvNone:
	168	break;
	169	case KBusEvCreate:
	170	break;
	171	case KBusEvConnected:
	172	break;
	173	case KBusEvDisConnected:
	174	break;
	175	case KBusEvClosed:
	176	break;
	177	case KBusEvStateChange:
	178	break;
	179	case KBusEvTimeSync:
	180	break;
	181	case KBusEvDataUpdate:
842bb6	182	if (KBus1.bMaster) {
Q	183	KMem.WLX[0]=KBusMem.WLX[0]; //KPLC with KBus Master
	184	KBusMem.WLY[0]=KMem.WLY[0];
	185	} else if (KBus1.bSlave) {
	186	KMem.WLX[0]=KBusMem.WLY[0]; //KPLC with KBus Slave
	187	KBusMem.WLX[0]=KMem.WLY[0];
	188	}
5dd1b7	189	break;
Q	190	case KBusEvCmdResponse:
	191	break;
	192
	193	default:
	194	break;
	195	}
	196	return 0;
	197	}
842bb6	198
5dd1b7	199
Q	200	/* USER CODE END 0 */
	201
	202	/**
	203	* @brief The application entry point.
	204	*
	205	* @retval None
	206	*/
	207	int main(void)
	208	{
	209	/* USER CODE BEGIN 1 */
	210	KMRunStat.bLEDFlick = 1;
	211
	212	InitUartstat(&Uart1Stat,Uart1RxBuf,sizeof(Uart1RxBuf),Uart1TxBuf,sizeof(Uart1TxBuf));
	213	InitUartstat(&Uart2Stat,Uart2RxBuf,sizeof(Uart2RxBuf),Uart2TxBuf,sizeof(Uart2TxBuf));
	214	/* USER CODE END 1 */
	215
	216	/* MCU Configuration----------------------------------------------------------*/
	217
	218	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	219	HAL_Init();
	220
	221	/* USER CODE BEGIN Init */
	222
	223
	224	KMem.LastScanTime=0;
	225	KMem.ScanTimeuS=0;
	226	KMem.MinScanTimeuS=99999;
	227	KMem.MaxScanTimeuS=0;
	228
	229	// KMem.SDD[14]=(unsigned int)&KMStoreSysCfg;
	230	// KMem.SDD[15]=(unsigned int)&KMStoreSysCfg1;
	231	KMem.SDD[12]=((uint32_t *)UID_BASE)[0];
	232	// KMem.SDD[13]=((uint32_t *)UID_BASE)[1];
	233	// KMem.SDD[14]=((uint32_t *)UID_BASE)[2];
	234	KMem.SDD[13]=PendSvCount;
	235	KMem.SDD[14]=RCC->CSR;
	236	// KMem.SDD[15]=(uint32_t )FLASHSIZE_BASE;
	237	// KMem.SDD[16]=(unsigned int)&KMSysCfg;
	238
	239	/* USER CODE END Init */
	240
	241	/* Configure the system clock */
	242	SystemClock_Config();
	243
	244	/* USER CODE BEGIN SysInit */
	245	TickFreq=10000; //Tick频率
	246	InituS(TickFreq);
	247	// HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/TickFreq); //重新定义SysTick的频率
	248
	249	/* USER CODE END SysInit */
	250
	251	/* Initialize all configured peripherals */
	252	MX_GPIO_Init();
	253	MX_DMA_Init();
	254
	255	KMachineInit();
	256	ReadSysCfgFromFlash(&storedKMSysCfg);
	257
	258	KMRunStat.bLEDFlick = 1;
	259
842bb6	260
Q	261	KLinkInit(1);
	262	unsigned char bKBusMaster, bKBusSlave, bKBusRepeater;
	263	int nKBusStationID;
	264	int nKBusChilds;
5dd1b7	265	KMem.CurJumperSW=ReadJumperSW();
Q	266	KMem.EffJumperSW=KMem.CurJumperSW;
	267	// Uart2Baud = AlterUart2Baud;
842bb6	268	nKBusStationID = KMem.EffJumperSW&0x0f;
Q	269	nKBusChilds = nKBusStationID;
5dd1b7	270
Q	271	#if (BOARD_TYPE == 14)
	272	KMem.EffJumperSW\|=0x10;
	273	nStationID=KMem.EffJumperSW&0x0f;
	274	if ((KMem.EffJumperSW&0x10)!=0) {bKBusMaster=1;bKBusSlave=0;}
	275	else{bKBusMaster=0;bKBusSlave=1;}
	276	nChilds=nStationID;
842bb6	277	FP0_Init(nChilds);
5dd1b7	278
Q	279	#elif (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	280	nStationID=1 ;//KMem.EffJumperSW&0x0f;
	281	// if (KMem.EffJumperSW == 0x1f) {bKBusRepeater=1;bKBusMaster=1;bKBusSlave=0;}
	282	// else if ((KMem.EffJumperSW&0x10)!=0) {bKBusMaster=1;bKBusSlave=0;}
	283	// else
	284	{bKBusMaster=0;bKBusSlave=1;}
	285	#else
842bb6	286	nKBusStationID=KMem.EffJumperSW&0x0f;
5dd1b7	287	if (KMem.EffJumperSW == 0x1f) {bKBusRepeater=1;bKBusMaster=1;bKBusSlave=0;}
842bb6	288	else if ((KMem.EffJumperSW&0x10)!=0) {
Q	289	bKBusMaster=1;bKBusSlave=0;
	290	}
	291	else{
	292	bKBusMaster=0;bKBusSlave=1;
	293	}
5dd1b7	294	#endif
Q	295
842bb6	296	if (bKBusMaster) {
Q	297	KBusInitMaster(&KBus1, (KBusSendPktFuncDef)PutStr2, nKBusChilds);
	298	} else if (bKBusSlave) {
	299	KBusInitSlave(&KBus1, (KBusSendPktFuncDef)PutStr2, nKBusStationID,&MyDeviceInfo);
	300	}
	301	KBusSetEvCallBackFunc(&KBus1, &KBusEvCallBackFunc),
	302
	303	UNUSED(bKBusRepeater);
5dd1b7	304
Q	305	//if (KMem.EffJumperSW == 0x00)
	306	Uart1Baud = DefaultUart1Baud;
	307	MX_USART1_UART_Init();
	308	MX_USART2_UART_Init();
	309
	310	MX_SPI1_Init();
	311	LL_SPI_EnableIT_RXNE(SPI1);
	312
	313	#if (BOARD_TYPE == 14)
	314	// MX_SPI2_Init();
	315	// MX_ADC_Init();
	316	#else
	317	MX_SPI2_Init();
	318	MX_ADC_Init();
	319	#endif
	320
	321	MX_IWDG_Init();
	322
	323	MX_TIM6_Init();
	324	LL_TIM_EnableCounter(TIM6);
	325
	326	/* USER CODE BEGIN 2 */
	327	LL_USART_EnableIT_RXNE(USART1);
	328	LL_USART_EnableIT_IDLE(USART1);
	329	LL_USART_EnableIT_TC(USART1);
	330
	331	// LL_USART_EnableIT_RXNE(USART2);
	332	Uart2RecvDMA(Uart2RecvBuf1,sizeof(Uart2RecvBuf1));
	333	LL_USART_EnableIT_IDLE(USART2);
	334	LL_USART_EnableIT_TC(USART2);
	335	#if (BOARD_TYPE == 13)
	336	int res;
	337	res = w5500_init();
	338	KMem.SDD[28]=res;
	339
	340	// res=socket(0,Sn_MR_TCP,5000,0);
	341	KMem.SDD[29]=res;
	342
	343	// res = listen(0);
	344	#endif
	345	// if (bKBusSlave)
	346	{
	347	// LL_USART_EnableAutoBaudRate(USART1);
	348	// LL_USART_SetAutoBaudRateMode(USART1, LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE);
	349	// LL_USART_EnableAutoBaudRate(USART2);
	350	// LL_USART_SetAutoBaudRateMode(USART2, LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE);
	351	}
	352	//LL_USART_EnableIT_TXE(USART1);
	353	/* USER CODE END 2 */
	354
	355
	356	/* Infinite loop */
	357	/* USER CODE BEGIN WHILE */
	358
	359	HAL_Delay(10);
	360	SetRunLed(1); //Turn On Run Led
	361	SetErrLed(0); //Turn Off Err Led
	362
	363	#if (BOARD_TYPE == 14)
	364	// PutOutput (0); //Clear all Output
	365	// Enable595(1); //Enable 595 Output
	366	#else
	367	PutOutput (0); //Clear all Output
	368	Enable595(1); //Enable 595 Output
	369	#endif
	370
	371	if (GetBoardType() == 7 \|\| GetBoardType() ==8
	372	\|\| GetBoardType() == 9 \|\| GetBoardType() ==10 \|\|GetBoardType() ==13 \|\|GetBoardType() ==15 \|\| BOARD_TYPE == 16)
	373	{
	374	displayInput(0xffff); //
	375	EnableDisIn(1); //Input Diaplay Enable 595
	376	}
	377	SetOutStat(0); //OK Good, signal
	378	ShowInitInfo();
	379	KMem.LastScanTime = GetuS();
	380
	381	KMRunStat.WorkMode = storedKMSysCfg.theKMSysCfg.workmode;
	382
	383	KMRunStat.WorkMode = 1;
	384	//KMRunStat.WorkMode2 = 0;
	385
	386	if (KMRunStat.WorkMode == 1){
	387	InitPLC();
	388	KMRunStat.WorkMode2 = KMem.CurJumperSW&0x20 ;
	389	if (KMRunStat.WorkMode2) {
	390	StartPLC(); }
	391	}
	392	KMem.WX[7]=0x5a;
	393
	394	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	395	KWireLessInit(KMem.EffJumperSW&0x20,KMem.EffJumperSW&0x0f);
	396	KWireLessStart();
	397	#endif
	398
	399	while (1)
	400	{
	401	//int MyKeyStat1,MyKeyStat2;
	402	//MyKeyStat1=GetInput();
	403
	404	//((unsigned int )&(PLCMem.SDT[10]))=nRunCount;
	405	// KMem.nRunCount=nRunCount;
	406	SlowFlicker=0;
	407	FastFlicker=1;
	408	us1=GetuS();
	409	int haltick=HAL_GetTick();
	410
	411	int thisJumperSW=ReadJumperSW();
	412
	413	if (KMRunStat.WorkMode&1){
	414	if (thisJumperSW&0x20 && !(KMem.CurJumperSW&0x20)) // Run 开关正跳变。
	415	{StartPLC();}
	416	if (!(thisJumperSW&0x20) && (KMem.CurJumperSW&0x20)) // Run 开关负跳变。
	417	{StopPLC();}
	418	}
	419
	420	KMem.CurJumperSW=thisJumperSW;
	421	KMem.haltick=haltick;
	422	// KMem.TotalRunTime=TotalRunTime;
	423	// KMem.ThisRunTime=ThisRunTime;
	424
	425	// ((unsigned int )&(PLCMem.SDT[2]))=nChilds;
	426	// KMem.SDD[13]=PendSvCount;
	427	// KMem.SDD[14]=RCC->CSR;
	428
842bb6	429	KMem.WDB[0] = KBus1.MyStat;
Q	430	KMem.WDB[1] = KBus1.bMaster;
	431	KMem.WDB[2] = KBus1.bMasterSent;
	432	KMem.WDB[3] = KBus1.bMasterRecved;
	433	KMem.WDB[4] = KBus1.bMasterRecvOK;
	434	KMem.WDB[5] = KBus1.bSlaveRecved;
	435
	436	KMem.WDB[8] = KBus1.RunStat;
	437	KMem.WDB[9] = KBus1.ErrStat;
	438
5dd1b7	439	int a;
Q	440	a = LL_GPIO_ReadInputPort(GPIOA);
	441	KMem.WDT[120]=a;
	442	a = LL_GPIO_ReadInputPort(GPIOB);
	443	KMem.WDT[121]=a;
	444	a = LL_GPIO_ReadInputPort(GPIOC);
	445	KMem.WDT[122]=a;
	446	a = LL_GPIO_ReadInputPort(GPIOD);
	447	KMem.WDT[123]=a;
	448
	449	#if (BOARD_TYPE == 14)
	450	// KMem.WX[0]= GetInput();
	451	FP0_Proc();
	452	#else
	453	KMem.WX[0]= GetInput();
	454	#endif
	455
	456	if (GetBoardType() == 7 \|\| GetBoardType() ==8
	457	\|\| GetBoardType() == 9 \|\| GetBoardType() ==10 \|\| GetBoardType() ==15 \|\| GetBoardType() ==16)
	458	{
	459	displayInput(KMem.WX[0]);
	460	}
	461	us2=GetuS();
	462	if (PowerDownEvent) { KMem.WX[0]=0;}
	463	///*
	464	if ((KMem.nRunCount &0x1f) == 0x02)
	465	{
	466	ADCProcess();
	467	if (PowerDownEvent)
	468	{
	469	KMem.WX[0]=0;
	470	if (!OldPowerDownEvent)
	471	{
	472	OldPowerDownEvent = PowerDownEvent;
	473	OldPowerDownEventTime = nCurTick;
	474	PowerDownProcess();
	475	}
	476	}else
	477	{
	478	if (OldPowerDownEvent)
	479	{
	480	OldPowerDownEvent=PowerDownEvent;
	481	PowerRecoverProcess();
	482
	483	}
	484	}
	485	}
	486	//*/
	487
	488	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	489	Radio.IrqProcess( ); // Process Radio IRQ
	490	KWL_Process(1);
	491
	492	#endif
	493
842bb6	494	// pProgs = (stBinInstrcn1 *) STORE_PRG_BASE;
5dd1b7	495
Q	496	if ( KMRunStat.WorkMode==1 ) //&& bKBusMaster)
	497	{
842bb6	498	stStoredBinProgs * pStoredBinProgs;
Q	499
	500	if (storedKMSysCfg.theKMSysCfg.nProgBank == 0){
	501	pStoredBinProgs=((stStoredBinProgs *)STORE_PRG_BASE);
5dd1b7	502	}else {
842bb6	503	pStoredBinProgs=((stStoredBinProgs *)ALT_PRG_BASE); ;
5dd1b7	504	}
842bb6	505	int nSizeProg1=pStoredBinProgs->StoredHdr.nSize ;
Q	506	// pProgs=(stBinInstrcn1 *)prog1;
5dd1b7	507
842bb6	508	ProcessPLCBinProg(pStoredBinProgs->BinInstrcns, nSizeProg1);
5dd1b7	509	}
Q	510
	511	KMem.ScanTimeuS=us2-KMem.LastScanTime;
	512	KMem.LastScanTime = us2;
	513	if (KMem.ScanTimeuS < KMem.MinScanTimeuS) {KMem.MinScanTimeuS = KMem.ScanTimeuS;}
	514	if (KMem.ScanTimeuS > KMem.MaxScanTimeuS) {KMem.MaxScanTimeuS = KMem.ScanTimeuS;}
	515
	516	// if (bKBusRepeater) { KBusRepeaterFunc(); }
	517
	518	us3=GetuS();
	519
	520	if (bKBusMaster)
	521	{
	522
	523	KBusMem.WLY[0]=KMem.WLY[0];
	524
842bb6	525	if (nKBusChilds>0) { KBusMasterFunc(&KBus1); }
5dd1b7	526
Q	527	KMem.WLX[0]=KBusMem.WLX[0];
	528
	529	}
	530	if (haltick&0x00002000) SlowFlicker=1;
	531	else SlowFlicker=0;
	532	if (haltick&0x00000800) FastFlicker=1;
	533	else FastFlicker=0;
	534
	535	if (bKBusSlave)
	536	{
	537	// BufferOut[0]=KMem.WX[0];
	538	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	539	// KBusSlaveFunc(2);
	540	// if (! KMem.RunStat) {BufferIn[0]=0;}
	541	// KMem.WY[0]=BufferIn[0];
	542	#else
842bb6	543	KBusSlaveFunc(&KBus1);
5dd1b7	544	if (! KMem.RunStat) {KMem.WLY[0]=0;}
Q	545	// KMem.WLY[0]=BufferIn[0];
	546	#endif
842bb6	547	if (KBus1.nSlaveTick&0x00002000) SlowFlicker=1;
5dd1b7	548	else SlowFlicker=0;
842bb6	549	if (KBus1.nSlaveTick&0x00000800) FastFlicker=1;
5dd1b7	550	else FastFlicker=0;
Q	551
	552	}
	553
	554	// KMem.WY[0]=nCount2>>5;
842bb6	555	if (KBus1.RunStat) {KBus1.RunStat--;}
Q	556	if (KBus1.ErrStat) {KBus1.ErrStat--;}
5dd1b7	557
Q	558	if (KMRunStat.bLEDFlick)
	559	{
	560	SetRunLed(FastFlicker);
	561	SetErrLed(FastFlicker);
	562	SetErr2Led(FastFlicker);
	563	SetOutStat(!FastFlicker);
	564	//KMRunStat.bLEDFlick-- ;
	565	}
	566	else
	567	{
	568	if (KMRunStat.WorkMode==1 ) {
	569	if (PLCMem.bPLCRunning){SetRunLed(SlowFlicker);}
	570	else {SetRunLed(0);}
	571	}
	572	else {
	573	if (!KMem.RunStat) SetRunLed(SlowFlicker);
	574	else SetRunLed(FastFlicker);
	575	}
842bb6	576	KMem.ErrStat = 0 + KBus1.ErrStat;
5dd1b7	577	if (!KMem.ErrStat)
Q	578	{
	579	SetErrLed(0);
	580	SetErr2Led(0);
	581	SetOutStat(1);
	582	}
	583	else
	584	{
	585	SetErrLed(FastFlicker);
	586	SetErr2Led(FastFlicker);
	587	SetOutStat(0);
	588
	589	}
	590	}
	591
	592	// SetRunLed(RunStat);
	593	// SetErrLed(ErrStat);
	594
	595	us4=GetuS();
	596	// EffJumperSW = GetInput(20)&0xff;
	597
	598	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	599
	600	if ((KMem.EffJumperSW&0x10)==0x10) {
	601	KMem.WFY[1]=KMem.WLY[0];
	602	KMem.WLX[0]=KMem.WFX[1];
	603	}else
	604	{
	605	KMem.WFY[1]=KMem.WX[0];
	606	KMem.WY[0]=KMem.WFX[1];
	607	}
	608	// KMem.WY[0]=KMem.WLY[0];
	609	#else
	610	// KMem.WLX[0]=KMem.WX[0];
	611	// KMem.WY[0]=KMem.WLY[0];
	612	#endif
	613
	614	us5=GetuS();
	615
	616	#if (BOARD_TYPE == 14)
	617	// PutOutput (KMem.WY[0]);
	618	#else
	619	PutOutput (KMem.WY[0]);
	620	#endif
	621	//PutOutput (KMem.nRunCount>>8);
	622	//PutOutput(0x0f70);
	623
	624	// if (bKBusMaster) ShowInfo();
	625	// if (bKBusSlave) ShowInfo();
	626	us6=GetuS();
	627	add1(10,10);
	628	for (int i=0;i<64;i++)
	629	{
	630	// ProcessTimer(i);
	631	}
	632	KMem.nRunCount++;
	633	// int nSize=sizeof(stKBusChnStat);
	634	// memcpy(&KMem.SDT[64],&KBusChnStats[1],nSize);
	635	// memcpy(&KMem.SDT[64+nSize/2],&KBusChnStats[2],nSize);
	636	// for (int i=0;i<128;i++) { SDT[i]=i; }
	637	// SDT[48]=55;
	638	if (Uart1RecvBuf1DataLen >0 && Uart1Stat.bPacketRecved)
	639	{
	640	int res1 = -1;
	641	res1 = ModBusSlaveParsePkg(1, Uart1RecvBuf1, Uart1RecvBuf1DataLen);
	642	if (res1 !=0)
	643	{
	644	KLParsePacket(1, Uart1RecvBuf1, Uart1RecvBuf1DataLen);
	645	}
	646	Uart1RecvBuf1DataLen=0;
	647	Uart1Stat.bPacketRecved=0;
	648	Uart1IdelTimer = 0;
	649	}else {
	650	if (Uart1IdelTimer>600000) { // 超过60秒没有数据传输，重新进入自适应波特率状态
	651	LL_USART_EnableAutoBaudRate(USART1);
	652	LL_USART_SetAutoBaudRateMode(USART1, LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE);
	653	}else {
	654	Uart1IdelTimer++;
	655	}
	656	}
	657	if (bKBusSlave) HAL_Delay(0);
	658	/*
	659	if (!IsEmpty(&Uart1Stat.QRx))
	660	{
	661	unsigned char k=PopOne(&Uart1Stat.QRx);
	662	if (k=='L')
	663	{
	664	clearscreen();
	665	}
	666	}
	667	*/
	668
	669	#if (BOARD_TYPE == 14)
	670	const unsigned int pins[6]= { LL_GPIO_PIN_10,LL_GPIO_PIN_11,LL_GPIO_PIN_12,LL_GPIO_PIN_13,LL_GPIO_PIN_14,LL_GPIO_PIN_15};
	671	//process 6 output
	672	{
	673	// mapping bits.
	674	for (int i=0;i<6;i++)
	675	{
	676	USHORT bitaddr = storedKMSysCfg.theKMSysCfg.OutMappings[i];
	677	UCHAR type = (bitaddr&0xf000) >>12;
	678	USHORT byteaddr = (bitaddr&0x0ff0) >>4;
	679	UCHAR bitpos = bitaddr &0x0f;
	680	UCHAR bitvalue = 0 ;
	681	if (byteaddr>0) {
	682	if (type == 0) bitvalue = KMem.WXB[byteaddr-1] & ( 1 << bitpos );
	683	else if (type == 1 ) bitvalue = KMem.WYB[byteaddr-1] & ( 1 << bitpos );
	684	}
	685	if (bitvalue){ LL_GPIO_SetOutputPin(GPIOB,pins[i]);}
	686	else {LL_GPIO_ResetOutputPin(GPIOB,pins[i]);}
	687	}
	688	}
	689	#endif
	690
	691	/*
	692	{
	693	unsigned char pos,seg;
	694	unsigned short val;
	695	pos=((KMem.nRunCount)&0x3);
	696	//val=(KMem.nRunCount)&0xfff;
	697	val=KMem.ErrStat;
	698	char buf5[20];
	699	sprintf(buf5,"%4d",val);
	700	val=buf5[3-pos];
	701	if (val <'0' \|\| val >'9') {seg=0;}
	702	else {seg=LEDSEGTAB[val-'0'];}
	703
	704	pos=1<<pos;
	705	//pos=1;
	706	//seg=2;
	707	seg=~seg;
	708	// PutOutputSPI1(pos\|(seg<<8));
	709	}
	710	*/
	711
	712	#if (BOARD_TYPE == 13)
	713	w5500_network_info_show();
	714	// loopback_tcps(0,str1,5000);
	715	#endif
	716
	717	LL_IWDG_ReloadCounter(IWDG);
	718
	719	} //while (1) ;
	720	/* USER CODE END WHILE */
	721
	722	/* USER CODE BEGIN 3 */
	723
	724	/* USER CODE END 3 */
	725
	726	}
	727
	728
	729	/* USER CODE BEGIN 4 */
	730
	731	/* USER CODE END 4 */
	732
	733	/**
	734	* @brief This function is executed in case of error occurrence.
	735	* @param file: The file name as string.
	736	* @param line: The line in file as a number.
	737	* @retval None
	738	*/
	739	void _Error_Handler(char *file, int line)
	740	{
	741	/* USER CODE BEGIN Error_Handler_Debug */
	742	/* User can add his own implementation to report the HAL error return state */
	743	while(1)
	744	{
	745	}
	746	/* USER CODE END Error_Handler_Debug */
	747	}
	748
	749	#ifdef USE_FULL_ASSERT
	750	/**
	751	* @brief Reports the name of the source file and the source line number
	752	* where the assert_param error has occurred.
	753	* @param file: pointer to the source file name
	754	* @param line: assert_param error line source number
	755	* @retval None
	756	*/
	757	void assert_failed(uint8_t* file, uint32_t line)
	758	{
	759	/* USER CODE BEGIN 6 */
	760	/* User can add his own implementation to report the file name and line number,
	761	tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
	762	/* USER CODE END 6 */
	763	}
	764	#endif /* USE_FULL_ASSERT */
	765
	766	/**
	767	* @}
	768	*/
	769
	770	/**
	771	* @}
	772	*/
	773
	774	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/