F030C8T6_Kbus_MIX.git

QuakeGod

2024-11-25 9aed5d7e7b3c7bf09da712e9c272ece401a7acc9

提交 \| 用户 \| 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"
9aed5d	54	#include "spiflash.h"
Q	55
5dd1b7	56	#if (BOARD_TYPE == 13)
Q	57	#include "w5500_port.h"
	58	#include "../src/Ethernet/socket.h"
	59	#include "../src/Ethernet/loopback.h"
	60	#elif (BOARD_TYPE == 14)
	61	#include "FP0.h"
	62	#elif (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	63	#include "KWireless.h"
	64	//#include "user.h"
	65	//#include "../src/radio/inc/sx126x-board.h"
	66	#endif
	67
	68	/* USER CODE END Includes */
	69
	70	/* Private variables ---------------------------------------------------------*/
	71
	72	/* USER CODE BEGIN PV */
	73	/* Private variables ---------------------------------------------------------*/
	74
	75	#define RX2BUFSIZE 64
	76	#define TX2BUFSIZE 64
	77
	78	unsigned char Uart1RxBuf[128];
	79	unsigned char Uart1TxBuf[260];
	80
	81	unsigned char Uart2RxBuf[RX2BUFSIZE];
	82	unsigned char Uart2TxBuf[TX2BUFSIZE];
	83
005755	84	unsigned char Uart1RxBuf1[Uart1RxBufSize];
Q	85	unsigned char Uart1TxBuf1[260];
	86
	87	unsigned char Uart2RxBuf1[RX2BUFSIZE];
	88	unsigned char Uart2TxBuf1[TX2BUFSIZE];
	89
	90	unsigned short Uart1RxBuf1DataLen = 0;
	91	unsigned short Uart2RxBuf1DataLen = 0;
	92
	93	unsigned char Uart1Mode = 1; //Uart1工作模式， 0 : 普通， 1 : 透传模式
	94
	95	unsigned int Uart1Baud = DefaultUart1Baud;
	96	unsigned int Uart2Baud = DefaultUart2Baud;
	97
	98	//unsigned char Uart1RecvBuf1[Uart1RecvBufSize];
	99	//unsigned short Uart1RecvBuf1DataLen=0;
	100
	101	//unsigned char Uart2RecvBuf1[128];
	102	//unsigned short Uart2RecvBuf1DataLen=0;
	103
	104	volatile char Uart1BaudGot=0;
	105	volatile char Uart1BaudFirstGot=0;
	106	volatile char Uart1DmaInts=0;
	107
	108
5dd1b7	109	unsigned char SlowFlicker=0;
Q	110	unsigned char FastFlicker=0;
	111
	112	unsigned int Uart1IdelTimer = 0;
	113
	114	uint32_t us1,us2,us3,us4,us5,us6;
	115
842bb6	116
Q	117	stKBusDef KBus1; //
	118
	119	extern stDeviceInfo MyDeviceInfo;
5dd1b7	120	/* USER CODE END PV */
Q	121
	122	/* Private function prototypes -----------------------------------------------*/
	123
	124
	125	/* USER CODE BEGIN PFP */
	126	/* Private function prototypes -----------------------------------------------*/
	127
	128	const unsigned char LEDSEGTAB[]={
	129	0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71, //0-F
	130	0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef,0xf7,0xfc,0xb9,0xde,0xf9,0xf1, //0.-F.
	131	0x00,0x40, // ,-,_,~,o,n,N,<,>,J,r,
	132	};
	133
	134	/* USER CODE END PFP */
	135
	136	/* USER CODE BEGIN 0 */
005755	137	#define SET_SCL LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_6)
Q	138	#define CLR_SCL LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_6)
	139	#define GET_SCL LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_6)
	140	#define SET_SDA LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_7)
	141	#define CLR_SDA LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_7)
	142	#define GET_SDA LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_7)
	143
	144
	145	void soft_i2c_start()
	146	{
	147	SET_SDA;
	148	SET_SCL;
	149	Delay100nS(1);
	150	CLR_SDA;
	151	Delay100nS(1);
	152	CLR_SCL;
	153	Delay100nS(1);
	154	}
	155	void soft_i2c_stop()
	156	{
	157	CLR_SDA;
	158	Delay100nS(1);
	159	SET_SCL;
	160	Delay100nS(1);
	161	SET_SDA;
	162	Delay100nS(1);
	163	}
	164	void soft_i2c_send8(int nData)
	165	{
	166	int mask;
	167	mask = 0x80;
	168	for (int j=0;j<8;j++)
	169	{
	170	if (nData & mask) {SET_SDA;}
	171	else {CLR_SDA;}
	172	Delay100nS(1);
	173	SET_SCL;
	174	mask>>=1;
	175	Delay100nS(1);
	176	CLR_SCL;
	177	}
	178	return;
	179	}
	180
	181	uint8_t soft_i2c_recv8()
	182	{
	183	unsigned char nData=0;
	184	for (int j=0;j<8;j++)
	185	{
	186	nData <<=1;
	187	Delay100nS(1);
	188	SET_SCL;
	189	nData \|= GET_SDA;
	190	Delay100nS(1);
	191	CLR_SCL;
	192	}
	193	return nData;
	194	}
	195
	196	void soft_i2c_send_ack()
	197	{
	198	CLR_SDA;
	199	Delay100nS(2);
	200	SET_SCL;
	201	Delay100nS(2);
	202	CLR_SCL;
	203	SET_SDA;
	204	Delay100nS(2);
	205
	206	}
	207
	208	void soft_i2c_send_nack()
	209	{
	210	SET_SDA;
	211	Delay100nS(1);
	212	SET_SCL;
	213	Delay100nS(1);
	214	CLR_SCL;
	215	Delay100nS(1);
	216	SET_SDA;
	217	}
	218	uint8_t soft_i2c_wait_ack(int nTime)
	219	{
	220	SET_SDA; // Open Drain;
	221	Delay100nS(1);
	222	SET_SCL;
	223	for (int j=0;j<nTime;j++){
	224	Delay100nS(1);
	225	if (GET_SDA == 0) break;
	226	if (j==nTime-1) return 0;
	227	}
	228	CLR_SCL;
	229	return 1;
	230	}
	231	uint8_t soft_i2c_check_addr(uint8_t Addr)
	232	{
	233	uint8_t res=0;
	234	soft_i2c_start();
	235	// Send Device Addr 7bit;
	236	soft_i2c_send8(Addr);
	237	if (soft_i2c_wait_ack(10)) {res=1;}
	238	//Stop
	239	soft_i2c_stop();
	240	// */
	241	return res;
	242
	243	}
	244	uint8_t soft_i2c_read_len( uint8_t Addr , uint8_t Reg, uint8_t len,uint8_t *buf)
	245	{
	246	int res=0;
	247	//Start
	248	soft_i2c_start();
	249	// Send Device Addr 7bit;
	250	soft_i2c_send8(Addr &0xfe);
	251	// wait Ack;
	252	if (!soft_i2c_wait_ack(1000)) {soft_i2c_stop();return 1;}
	253	CLR_SCL;
	254	// Send Reg Addr 8bit;
	255	soft_i2c_send8(Reg);
	256	if (!soft_i2c_wait_ack(1000)) {soft_i2c_stop();return 2;}
	257	//Start
	258	soft_i2c_start();
	259	// Send Device Addr 7bit;
	260	soft_i2c_send8(Addr \| 1);
	261	if (!soft_i2c_wait_ack(1000)) {soft_i2c_stop();return 3;}
	262
	263	// /*
	264	// Recv Data(s) n * 8bit;
	265	SET_SDA; // Open Drain;
	266	for (int i=0;i<len;i++)
	267	{
	268	// recv 1 data 8bit;
	269	unsigned char nData = 0;
	270	nData = soft_i2c_recv8();
	271	buf[i]=nData;
	272	// Send ACK / NACK;
	273	if (i != len -1) { //ACK
	274	soft_i2c_send_ack();
	275	} else { // NACK
	276	soft_i2c_send_nack();
	277	}
	278	}
	279
	280	//Stop
	281	soft_i2c_stop();
	282	// */
	283	return res;
	284	}
	285
	286	uint8_t soft_i2c_write_len(uint8_t Addr , uint8_t Reg, uint8_t len, uint8_t *buf)
	287	{
	288	int res=0;
	289	//Start
	290	soft_i2c_start();
	291	// Send Device Addr 7bit;
	292	soft_i2c_send8(Addr &0xfe);
	293	// wait Ack;
	294	if (!soft_i2c_wait_ack(1000)) return 1;
	295	CLR_SCL;
	296	// Send Reg Addr 8bit;
	297	soft_i2c_send8(Reg);
	298	if (!soft_i2c_wait_ack(1000)) return 2;
	299	for (int i=0;i<len;i++)
	300	{
	301	// send 1 data 8bit;
	302	unsigned char nData = buf[i];
	303	soft_i2c_send8(nData);
	304	// wait Ack;
	305	if (!soft_i2c_wait_ack(1000)) {res = 5; break;}
	306	}
	307	//Stop
	308	soft_i2c_stop();
	309	return res;
	310
	311	}
	312
	313
5dd1b7	314
Q	315	int HexToInt(char ch)
	316	{
	317	if (ch>='0' && ch <='9') return ch-'0';
	318	if (ch>='A' && ch <='F') return ch-'A'+10;
	319	if (ch>='a' && ch <='f') return ch-'a'+10;
	320	return 0;
	321	}
	322
	323	void HAL_SYSTICK_Callback(void)
	324	{
	325	static int Count=0;
	326	CurTickuS += 100;
	327	nCurTick++;
842bb6	328	KBus1.nSlaveTick++;
5dd1b7	329	Count++;
Q	330	if (Count>=10000)
	331	{
	332	Count=0;
	333	KMem.CurTimeSec++;
	334	KMem.ThisRunTime++; KMem.TotalRunTime++;
	335	if (KMRunStat.bLEDFlick) KMRunStat.bLEDFlick--;
	336	if (KMRunStat.bLEDFlick >120) KMRunStat.bLEDFlick=120;
	337	}
	338
	339	return;
	340	}
	341
842bb6	342	void PendSvCallBack()
Q	343	{
	344	#if (BOARD_TYPE == 14)
	345	///*
	346	if (bSPI1RecvDone)
	347	{
	348	bSPI1RecvDone=0;
	349	FPxParsePkt(SPI1RecvBuf,nSPI1RecvLenInBuf);
	350	}
	351	//*/
	352	#endif
	353	if (Uart2Stat.bPacketRecved)
	354	{
005755	355	KBusParsePacket(&KBus1, (pKBPacket)Uart2RxBuf1, Uart2RxBuf1DataLen);
Q	356	Uart2RxBuf1DataLen=0;
842bb6	357	Uart2Stat.bPacketRecved=0;
005755	358	Uart2RecvDMA(Uart2RxBuf1,sizeof(Uart2RxBuf1));
842bb6	359	KMem.WDT[2]++;
Q	360	}
	361	}
	362
	363	/*
	364	KBus通讯回调函数，当通讯状态改变或数据更新时被调用。
	365	或者系统请求时。
	366	*/
	367	void * KBusEvCallBackFunc(void* pParam, int nEvent, void *pBuf, int nLen1)
5dd1b7	368	{
Q	369	switch (nEvent){
	370
	371	case KBusEvNone:
	372	break;
	373	case KBusEvCreate:
	374	break;
	375	case KBusEvConnected:
	376	break;
	377	case KBusEvDisConnected:
	378	break;
	379	case KBusEvClosed:
	380	break;
	381	case KBusEvStateChange:
	382	break;
	383	case KBusEvTimeSync:
	384	break;
	385	case KBusEvDataUpdate:
842bb6	386	if (KBus1.bMaster) {
005755	387	for (int i=0;i<16;i++)
Q	388	{
	389	KMem.WLX[i]=KBusMem.WLX[i]; //KPLC with KBus Master
	390	KBusMem.WLY[i]=KMem.WLY[i];
	391	}
842bb6	392	} else if (KBus1.bSlave) {
Q	393	KMem.WLX[0]=KBusMem.WLY[0]; //KPLC with KBus Slave
	394	KBusMem.WLX[0]=KMem.WLY[0];
005755	395	KMem.WLX[1]=KBusMem.WLY[1]; //KPLC with KBus Slave
Q	396	KBusMem.WLX[1]=KMem.WLY[1];
	397	KMem.WLX[2]=KBusMem.WLY[2]; //KPLC with KBus Slave
	398	KBusMem.WLX[2]=KMem.WLY[2];
	399	KMem.WLX[3]=KBusMem.WLY[3]; //KPLC with KBus Slave
	400	KBusMem.WLX[3]=KMem.WLY[3];
842bb6	401	}
005755	402
5dd1b7	403	break;
Q	404	case KBusEvCmdResponse:
	405	break;
	406
	407	default:
	408	break;
	409	}
	410	return 0;
	411	}
842bb6	412
5dd1b7	413
Q	414	/* USER CODE END 0 */
9aed5d	415	/**
Q	416	* @brief This function handles EXTI line 0 and 1 interrupts.
	417	*/
	418	void EXTI0_1_IRQHandler(void)
	419	{
	420	/* USER CODE BEGIN EXTI0_1_IRQn 0 */
	421
	422	/* USER CODE END EXTI0_1_IRQn 0 */
	423	if (LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_0) != RESET)
	424	{
	425	LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_0);
	426	/* USER CODE BEGIN LL_EXTI_LINE_1 */
	427
	428	unsigned char PowerVolt = LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_0);
	429	// KMem.WDT[79]++;// KMem.WDT[79]++;
	430	/*
	431	if (PowerVolt == 0)
	432	{
	433	PowerDownFlag=1;
	434	}else
	435	{
	436	PowerDownFlag=0;
	437	}
	438	// */
	439	/* USER CODE END LL_EXTI_LINE_1 */
	440	}
	441	/* USER CODE BEGIN EXTI0_1_IRQn 1 */
	442
	443	/* USER CODE END EXTI0_1_IRQn 1 */
	444	}
	445
	446	void EXIT_Init()
	447	{
	448	LL_EXTI_InitTypeDef EXTI_InitStruct = {0};
	449
	450	/* GPIO Ports Clock Enable */
	451	LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);
	452
	453	/**/
	454	LL_SYSCFG_SetEXTISource(LL_SYSCFG_EXTI_PORTA, LL_SYSCFG_EXTI_LINE0);
	455
	456	/**/
	457	LL_GPIO_SetPinPull(GPIOA, LL_GPIO_PIN_0, LL_GPIO_PULL_NO);
	458
	459	/**/
	460	LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_0, LL_GPIO_MODE_INPUT);
	461
	462	/**/
	463	EXTI_InitStruct.Line_0_31 = LL_EXTI_LINE_0;
	464	EXTI_InitStruct.LineCommand = ENABLE;
	465	EXTI_InitStruct.Mode = LL_EXTI_MODE_IT;
	466	EXTI_InitStruct.Trigger = LL_EXTI_TRIGGER_RISING_FALLING;
	467	LL_EXTI_Init(&EXTI_InitStruct);
	468
	469	/* EXTI interrupt init*/
	470	NVIC_SetPriority(EXTI0_1_IRQn, 0);
	471	NVIC_EnableIRQ(EXTI0_1_IRQn);
	472
	473	}
5dd1b7	474
Q	475	/**
	476	* @brief The application entry point.
	477	*
	478	* @retval None
	479	*/
	480	int main(void)
	481	{
	482	/* USER CODE BEGIN 1 */
	483	KMRunStat.bLEDFlick = 1;
	484
	485	InitUartstat(&Uart1Stat,Uart1RxBuf,sizeof(Uart1RxBuf),Uart1TxBuf,sizeof(Uart1TxBuf));
	486	InitUartstat(&Uart2Stat,Uart2RxBuf,sizeof(Uart2RxBuf),Uart2TxBuf,sizeof(Uart2TxBuf));
	487	/* USER CODE END 1 */
	488
	489	/* MCU Configuration----------------------------------------------------------*/
	490
	491	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	492	HAL_Init();
	493
	494	/* USER CODE BEGIN Init */
	495
	496
	497	KMem.LastScanTime=0;
	498	KMem.ScanTimeuS=0;
	499	KMem.MinScanTimeuS=99999;
	500	KMem.MaxScanTimeuS=0;
	501
	502	// KMem.SDD[14]=(unsigned int)&KMStoreSysCfg;
	503	// KMem.SDD[15]=(unsigned int)&KMStoreSysCfg1;
	504	KMem.SDD[12]=((uint32_t *)UID_BASE)[0];
	505	// KMem.SDD[13]=((uint32_t *)UID_BASE)[1];
	506	// KMem.SDD[14]=((uint32_t *)UID_BASE)[2];
	507	KMem.SDD[13]=PendSvCount;
	508	KMem.SDD[14]=RCC->CSR;
	509	// KMem.SDD[15]=(uint32_t )FLASHSIZE_BASE;
	510	// KMem.SDD[16]=(unsigned int)&KMSysCfg;
	511
	512	/* USER CODE END Init */
	513
	514	/* Configure the system clock */
	515	SystemClock_Config();
	516
	517	/* USER CODE BEGIN SysInit */
	518	TickFreq=10000; //Tick频率
	519	InituS(TickFreq);
	520	// HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/TickFreq); //重新定义SysTick的频率
	521
	522	/* USER CODE END SysInit */
	523
	524	/* Initialize all configured peripherals */
	525	MX_GPIO_Init();
	526	MX_DMA_Init();
9aed5d	527	// EXIT_Init();
5dd1b7	528	KMachineInit();
Q	529	ReadSysCfgFromFlash(&storedKMSysCfg);
	530
	531	KMRunStat.bLEDFlick = 1;
	532
842bb6	533
Q	534	KLinkInit(1);
	535	unsigned char bKBusMaster, bKBusSlave, bKBusRepeater;
	536	int nKBusStationID;
	537	int nKBusChilds;
5dd1b7	538	KMem.CurJumperSW=ReadJumperSW();
Q	539	KMem.EffJumperSW=KMem.CurJumperSW;
	540	// Uart2Baud = AlterUart2Baud;
842bb6	541	nKBusStationID = KMem.EffJumperSW&0x0f;
Q	542	nKBusChilds = nKBusStationID;
5dd1b7	543
Q	544	#if (BOARD_TYPE == 14)
	545	KMem.EffJumperSW\|=0x10;
	546	nStationID=KMem.EffJumperSW&0x0f;
	547	if ((KMem.EffJumperSW&0x10)!=0) {bKBusMaster=1;bKBusSlave=0;}
	548	else{bKBusMaster=0;bKBusSlave=1;}
	549	nChilds=nStationID;
842bb6	550	FP0_Init(nChilds);
5dd1b7	551
Q	552	#elif (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	553	nStationID=1 ;//KMem.EffJumperSW&0x0f;
	554	// if (KMem.EffJumperSW == 0x1f) {bKBusRepeater=1;bKBusMaster=1;bKBusSlave=0;}
	555	// else if ((KMem.EffJumperSW&0x10)!=0) {bKBusMaster=1;bKBusSlave=0;}
	556	// else
	557	{bKBusMaster=0;bKBusSlave=1;}
	558	#else
842bb6	559	nKBusStationID=KMem.EffJumperSW&0x0f;
5dd1b7	560	if (KMem.EffJumperSW == 0x1f) {bKBusRepeater=1;bKBusMaster=1;bKBusSlave=0;}
842bb6	561	else if ((KMem.EffJumperSW&0x10)!=0) {
Q	562	bKBusMaster=1;bKBusSlave=0;
	563	}
	564	else{
	565	bKBusMaster=0;bKBusSlave=1;
	566	}
5dd1b7	567	#endif
Q	568
842bb6	569	if (bKBusMaster) {
Q	570	KBusInitMaster(&KBus1, (KBusSendPktFuncDef)PutStr2, nKBusChilds);
	571	} else if (bKBusSlave) {
	572	KBusInitSlave(&KBus1, (KBusSendPktFuncDef)PutStr2, nKBusStationID,&MyDeviceInfo);
	573	}
	574	KBusSetEvCallBackFunc(&KBus1, &KBusEvCallBackFunc),
	575
	576	UNUSED(bKBusRepeater);
5dd1b7	577
Q	578	//if (KMem.EffJumperSW == 0x00)
	579	Uart1Baud = DefaultUart1Baud;
	580	MX_USART1_UART_Init();
	581	MX_USART2_UART_Init();
	582	MX_SPI1_Init();
9aed5d	583
Q	584
005755	585	/*
Q	586	// MX_I2C1_Init();
	587	Soft_I2C1_Init();
5dd1b7	588
005755	589	unsigned char buf1[10] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa};
Q	590	unsigned char buf2[10];
	591	// KMem.WDB[80] = soft_i2c_read_len(0xa0,0x00,8,buf2);
	592	// for (int i=0;i<8;i++){
	593	// buf2[i]+=1;
	594	// }
	595	// soft_i2c_write_len (0xa0,0x00,8,buf2);
	596	// DelayUs(500);
	597	// KMem.WDB[80] = soft_i2c_read_len(0xa0,0x00,8,&KMem.WDB[81]);
	598	// DelayUs(500);
	599	// KMem.WDB[90] = soft_i2c_read_len(0xa0,0x00,8,&KMem.WDB[91]);
	600
	601	int nPos = 80;
	602	int nCount =0;
	603	for (int i=0;i<256;i++)
	604	{
	605	if (soft_i2c_check_addr(i)){
	606	KMem.WDB[nPos + 1 + nCount ] = i;
	607	nCount+=1;
	608	}
	609	DelayUs(10);
	610	}
	611	KMem.WDB[nPos] = nCount;
	612	*/
5dd1b7	613	#if (BOARD_TYPE == 14)
Q	614	// MX_SPI2_Init();
	615	// MX_ADC_Init();
	616	#else
	617	MX_SPI2_Init();
	618	MX_ADC_Init();
	619	#endif
005755	620
5dd1b7	621	MX_IWDG_Init();
Q	622
	623	MX_TIM6_Init();
	624	LL_TIM_EnableCounter(TIM6);
	625
	626	/* USER CODE BEGIN 2 */
	627	LL_USART_EnableIT_RXNE(USART1);
	628	LL_USART_EnableIT_IDLE(USART1);
	629	LL_USART_EnableIT_TC(USART1);
	630
	631	// LL_USART_EnableIT_RXNE(USART2);
005755	632	Uart2RecvDMA(Uart2RxBuf1,sizeof(Uart2RxBuf1));
5dd1b7	633	LL_USART_EnableIT_IDLE(USART2);
Q	634	LL_USART_EnableIT_TC(USART2);
	635	#if (BOARD_TYPE == 13)
	636	int res;
	637	res = w5500_init();
	638	KMem.SDD[28]=res;
	639
	640	// res=socket(0,Sn_MR_TCP,5000,0);
	641	KMem.SDD[29]=res;
	642
	643	// res = listen(0);
	644	#endif
	645	// if (bKBusSlave)
	646	{
	647	// LL_USART_EnableAutoBaudRate(USART1);
	648	// LL_USART_SetAutoBaudRateMode(USART1, LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE);
	649	// LL_USART_EnableAutoBaudRate(USART2);
	650	// LL_USART_SetAutoBaudRateMode(USART2, LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE);
	651	}
	652	//LL_USART_EnableIT_TXE(USART1);
005755	653
Q	654	// KMem.WDT[50] = SPI_Flash_ReadID();
	655
5dd1b7	656	/* USER CODE END 2 */
Q	657
	658
	659	/* Infinite loop */
	660	/* USER CODE BEGIN WHILE */
	661
	662	HAL_Delay(10);
	663	SetRunLed(1); //Turn On Run Led
	664	SetErrLed(0); //Turn Off Err Led
	665
	666	#if (BOARD_TYPE == 14)
	667	// PutOutput (0); //Clear all Output
	668	// Enable595(1); //Enable 595 Output
	669	#else
	670	PutOutput (0); //Clear all Output
	671	Enable595(1); //Enable 595 Output
	672	#endif
	673
	674	if (GetBoardType() == 7 \|\| GetBoardType() ==8
	675	\|\| GetBoardType() == 9 \|\| GetBoardType() ==10 \|\|GetBoardType() ==13 \|\|GetBoardType() ==15 \|\| BOARD_TYPE == 16)
	676	{
	677	displayInput(0xffff); //
	678	EnableDisIn(1); //Input Diaplay Enable 595
	679	}
	680	SetOutStat(0); //OK Good, signal
	681	ShowInitInfo();
	682	KMem.LastScanTime = GetuS();
	683
	684	KMRunStat.WorkMode = storedKMSysCfg.theKMSysCfg.workmode;
	685
	686	KMRunStat.WorkMode = 1;
	687	//KMRunStat.WorkMode2 = 0;
9aed5d	688	W25QXX_Read((uchar )(&KMem.DT[100]),256,282);
Q	689
5dd1b7	690	if (KMRunStat.WorkMode == 1){
Q	691	InitPLC();
	692	KMRunStat.WorkMode2 = KMem.CurJumperSW&0x20 ;
	693	if (KMRunStat.WorkMode2) {
	694	StartPLC(); }
	695	}
	696	KMem.WX[7]=0x5a;
	697
	698	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	699	KWireLessInit(KMem.EffJumperSW&0x20,KMem.EffJumperSW&0x0f);
	700	KWireLessStart();
	701	#endif
	702
9aed5d	703	LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_15);
Q	704	KMem.WDT[82]=0;
	705
	706	W25QXX_Read(&KMem.WDB[160],0,64);
	707	KMem.WDT[82]++;
	708	KMem.WDT[81]++;
	709	W25QXX_Erase_Sector(0);
	710	int time1=GetuS();
	711	// W25QXX_Write_Page(&KMem.WDB[160],0,64);
	712	// SPI_Flash_Wait_Busy();
	713	int time2=GetuS();
	714	KMem.WDD[38] =time2-time1;
	715	// W25QXX_Erase_Sector(0);
	716
	717	KMem.SDT[64] = SPI_Flash_ReadID();
5dd1b7	718	while (1)
Q	719	{
	720	//int MyKeyStat1,MyKeyStat2;
	721	//MyKeyStat1=GetInput();
	722
	723	//((unsigned int )&(PLCMem.SDT[10]))=nRunCount;
	724	// KMem.nRunCount=nRunCount;
9aed5d	725	// LL_GPIO_TogglePin(GPIOB,LL_GPIO_PIN_5);
Q	726	// KMem.SDT[64] = SPI_Flash_ReadID();
	727	// SPI_FLASH_Write_Enable();
	728	// KMem.SDT[65] = SPI1_Flash_ReadSR();
	729
	730
5dd1b7	731	SlowFlicker=0;
Q	732	FastFlicker=1;
	733	us1=GetuS();
	734	int haltick=HAL_GetTick();
	735
	736	int thisJumperSW=ReadJumperSW();
	737
	738	if (KMRunStat.WorkMode&1){
	739	if (thisJumperSW&0x20 && !(KMem.CurJumperSW&0x20)) // Run 开关正跳变。
	740	{StartPLC();}
	741	if (!(thisJumperSW&0x20) && (KMem.CurJumperSW&0x20)) // Run 开关负跳变。
	742	{StopPLC();}
	743	}
	744
	745	KMem.CurJumperSW=thisJumperSW;
	746	KMem.haltick=haltick;
	747	// KMem.TotalRunTime=TotalRunTime;
	748	// KMem.ThisRunTime=ThisRunTime;
	749
	750	// ((unsigned int )&(PLCMem.SDT[2]))=nChilds;
	751	// KMem.SDD[13]=PendSvCount;
	752	// KMem.SDD[14]=RCC->CSR;
	753
842bb6	754	KMem.WDB[0] = KBus1.MyStat;
Q	755	KMem.WDB[1] = KBus1.bMaster;
	756	KMem.WDB[2] = KBus1.bMasterSent;
	757	KMem.WDB[3] = KBus1.bMasterRecved;
	758	KMem.WDB[4] = KBus1.bMasterRecvOK;
	759	KMem.WDB[5] = KBus1.bSlaveRecved;
	760
	761	KMem.WDB[8] = KBus1.RunStat;
	762	KMem.WDB[9] = KBus1.ErrStat;
	763
5dd1b7	764	int a;
Q	765	a = LL_GPIO_ReadInputPort(GPIOA);
	766	KMem.WDT[120]=a;
	767	a = LL_GPIO_ReadInputPort(GPIOB);
	768	KMem.WDT[121]=a;
	769	a = LL_GPIO_ReadInputPort(GPIOC);
	770	KMem.WDT[122]=a;
	771	a = LL_GPIO_ReadInputPort(GPIOD);
	772	KMem.WDT[123]=a;
	773
	774	#if (BOARD_TYPE == 14)
	775	// KMem.WX[0]= GetInput();
	776	FP0_Proc();
	777	#else
	778	KMem.WX[0]= GetInput();
	779	#endif
	780
	781	if (GetBoardType() == 7 \|\| GetBoardType() ==8
	782	\|\| GetBoardType() == 9 \|\| GetBoardType() ==10 \|\| GetBoardType() ==15 \|\| GetBoardType() ==16)
	783	{
	784	displayInput(KMem.WX[0]);
	785	}
	786	us2=GetuS();
9aed5d	787	if (PowerDownFlag) {KMem.WX[0]=0;}
5dd1b7	788	///*
9aed5d	789	if ((KMem.nRunCount &0xf) == 0x02)
5dd1b7	790	{
Q	791	ADCProcess();
9aed5d	792	if (PowerDownFlag)
5dd1b7	793	{
Q	794	KMem.WX[0]=0;
9aed5d	795	if (!OldPowerDownFlag)
5dd1b7	796	{
9aed5d	797	OldPowerDownFlag = PowerDownFlag;
5dd1b7	798	OldPowerDownEventTime = nCurTick;
9aed5d	799
Q	800	KMem.WDT[80]++;
	801	KMem.WDT[81]++;
	802	CLR_SDA;
	803	W25QXX_Erase_Sector(0);
	804	W25QXX_Write_Page((uchar )(&KMem.DT[100]),256,282);
	805	W25QXX_Write_Page(&KMem.WDB[160],0,64);
	806	SET_SDA;
5dd1b7	807	PowerDownProcess();
Q	808	}
	809	}else
	810	{
9aed5d	811	if (OldPowerDownFlag)
5dd1b7	812	{
9aed5d	813	OldPowerDownFlag=PowerDownFlag;
5dd1b7	814	PowerRecoverProcess();
Q	815
	816	}
	817	}
	818	}
	819	//*/
	820
	821	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	822	Radio.IrqProcess( ); // Process Radio IRQ
	823	KWL_Process(1);
	824
	825	#endif
	826
842bb6	827	// pProgs = (stBinInstrcn1 *) STORE_PRG_BASE;
5dd1b7	828
Q	829	if ( KMRunStat.WorkMode==1 ) //&& bKBusMaster)
	830	{
842bb6	831	stStoredBinProgs * pStoredBinProgs;
Q	832
	833	if (storedKMSysCfg.theKMSysCfg.nProgBank == 0){
	834	pStoredBinProgs=((stStoredBinProgs *)STORE_PRG_BASE);
5dd1b7	835	}else {
842bb6	836	pStoredBinProgs=((stStoredBinProgs *)ALT_PRG_BASE); ;
5dd1b7	837	}
842bb6	838	int nSizeProg1=pStoredBinProgs->StoredHdr.nSize ;
Q	839	// pProgs=(stBinInstrcn1 *)prog1;
5dd1b7	840
842bb6	841	ProcessPLCBinProg(pStoredBinProgs->BinInstrcns, nSizeProg1);
5dd1b7	842	}
Q	843
	844	KMem.ScanTimeuS=us2-KMem.LastScanTime;
	845	KMem.LastScanTime = us2;
	846	if (KMem.ScanTimeuS < KMem.MinScanTimeuS) {KMem.MinScanTimeuS = KMem.ScanTimeuS;}
	847	if (KMem.ScanTimeuS > KMem.MaxScanTimeuS) {KMem.MaxScanTimeuS = KMem.ScanTimeuS;}
	848
	849	// if (bKBusRepeater) { KBusRepeaterFunc(); }
	850
	851	us3=GetuS();
	852
	853	if (bKBusMaster)
	854	{
	855
	856	KBusMem.WLY[0]=KMem.WLY[0];
	857
842bb6	858	if (nKBusChilds>0) { KBusMasterFunc(&KBus1); }
5dd1b7	859
Q	860	KMem.WLX[0]=KBusMem.WLX[0];
	861
	862	}
	863	if (haltick&0x00002000) SlowFlicker=1;
	864	else SlowFlicker=0;
	865	if (haltick&0x00000800) FastFlicker=1;
	866	else FastFlicker=0;
	867
	868	if (bKBusSlave)
	869	{
	870	// BufferOut[0]=KMem.WX[0];
	871	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	872	// KBusSlaveFunc(2);
	873	// if (! KMem.RunStat) {BufferIn[0]=0;}
	874	// KMem.WY[0]=BufferIn[0];
	875	#else
842bb6	876	KBusSlaveFunc(&KBus1);
5dd1b7	877	if (! KMem.RunStat) {KMem.WLY[0]=0;}
Q	878	// KMem.WLY[0]=BufferIn[0];
	879	#endif
842bb6	880	if (KBus1.nSlaveTick&0x00002000) SlowFlicker=1;
5dd1b7	881	else SlowFlicker=0;
842bb6	882	if (KBus1.nSlaveTick&0x00000800) FastFlicker=1;
5dd1b7	883	else FastFlicker=0;
Q	884
	885	}
	886
	887	// KMem.WY[0]=nCount2>>5;
842bb6	888	if (KBus1.RunStat) {KBus1.RunStat--;}
Q	889	if (KBus1.ErrStat) {KBus1.ErrStat--;}
5dd1b7	890
Q	891	if (KMRunStat.bLEDFlick)
	892	{
	893	SetRunLed(FastFlicker);
	894	SetErrLed(FastFlicker);
	895	SetErr2Led(FastFlicker);
	896	SetOutStat(!FastFlicker);
	897	//KMRunStat.bLEDFlick-- ;
	898	}
	899	else
	900	{
	901	if (KMRunStat.WorkMode==1 ) {
	902	if (PLCMem.bPLCRunning){SetRunLed(SlowFlicker);}
	903	else {SetRunLed(0);}
	904	}
	905	else {
	906	if (!KMem.RunStat) SetRunLed(SlowFlicker);
	907	else SetRunLed(FastFlicker);
	908	}
842bb6	909	KMem.ErrStat = 0 + KBus1.ErrStat;
5dd1b7	910	if (!KMem.ErrStat)
Q	911	{
	912	SetErrLed(0);
	913	SetErr2Led(0);
	914	SetOutStat(1);
	915	}
	916	else
	917	{
	918	SetErrLed(FastFlicker);
	919	SetErr2Led(FastFlicker);
	920	SetOutStat(0);
	921
	922	}
	923	}
	924
	925	// SetRunLed(RunStat);
	926	// SetErrLed(ErrStat);
	927
	928	us4=GetuS();
	929	// EffJumperSW = GetInput(20)&0xff;
	930
	931	#if (BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	932
	933	if ((KMem.EffJumperSW&0x10)==0x10) {
	934	KMem.WFY[1]=KMem.WLY[0];
	935	KMem.WLX[0]=KMem.WFX[1];
	936	}else
	937	{
	938	KMem.WFY[1]=KMem.WX[0];
	939	KMem.WY[0]=KMem.WFX[1];
	940	}
	941	// KMem.WY[0]=KMem.WLY[0];
	942	#else
	943	// KMem.WLX[0]=KMem.WX[0];
	944	// KMem.WY[0]=KMem.WLY[0];
	945	#endif
	946
	947	us5=GetuS();
	948
	949	#if (BOARD_TYPE == 14)
	950	// PutOutput (KMem.WY[0]);
	951	#else
	952	PutOutput (KMem.WY[0]);
	953	#endif
	954	//PutOutput (KMem.nRunCount>>8);
	955	//PutOutput(0x0f70);
	956
	957	// if (bKBusMaster) ShowInfo();
	958	// if (bKBusSlave) ShowInfo();
	959	us6=GetuS();
	960	add1(10,10);
	961	for (int i=0;i<64;i++)
	962	{
	963	// ProcessTimer(i);
	964	}
	965	KMem.nRunCount++;
	966	// int nSize=sizeof(stKBusChnStat);
	967	// memcpy(&KMem.SDT[64],&KBusChnStats[1],nSize);
	968	// memcpy(&KMem.SDT[64+nSize/2],&KBusChnStats[2],nSize);
	969	// for (int i=0;i<128;i++) { SDT[i]=i; }
	970	// SDT[48]=55;
005755	971	if (Uart1RxBuf1DataLen >0 && Uart1Stat.bPacketRecved)
5dd1b7	972	{
Q	973	int res1 = -1;
005755	974	res1 = ModBusSlaveParsePkg(1, Uart1RxBuf1, Uart1RxBuf1DataLen);
5dd1b7	975	if (res1 !=0)
Q	976	{
005755	977	KLParsePacket(1, Uart1RxBuf1, Uart1RxBuf1DataLen);
5dd1b7	978	}
005755	979	Uart1RxBuf1DataLen=0;
5dd1b7	980	Uart1Stat.bPacketRecved=0;
Q	981	Uart1IdelTimer = 0;
	982	}else {
	983	if (Uart1IdelTimer>600000) { // 超过60秒没有数据传输，重新进入自适应波特率状态
	984	LL_USART_EnableAutoBaudRate(USART1);
	985	LL_USART_SetAutoBaudRateMode(USART1, LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE);
	986	}else {
	987	Uart1IdelTimer++;
	988	}
	989	}
	990	if (bKBusSlave) HAL_Delay(0);
	991	/*
	992	if (!IsEmpty(&Uart1Stat.QRx))
	993	{
	994	unsigned char k=PopOne(&Uart1Stat.QRx);
	995	if (k=='L')
	996	{
	997	clearscreen();
	998	}
	999	}
	1000	*/
	1001
	1002	#if (BOARD_TYPE == 14)
	1003	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};
	1004	//process 6 output
	1005	{
	1006	// mapping bits.
	1007	for (int i=0;i<6;i++)
	1008	{
	1009	USHORT bitaddr = storedKMSysCfg.theKMSysCfg.OutMappings[i];
	1010	UCHAR type = (bitaddr&0xf000) >>12;
	1011	USHORT byteaddr = (bitaddr&0x0ff0) >>4;
	1012	UCHAR bitpos = bitaddr &0x0f;
	1013	UCHAR bitvalue = 0 ;
	1014	if (byteaddr>0) {
	1015	if (type == 0) bitvalue = KMem.WXB[byteaddr-1] & ( 1 << bitpos );
	1016	else if (type == 1 ) bitvalue = KMem.WYB[byteaddr-1] & ( 1 << bitpos );
	1017	}
	1018	if (bitvalue){ LL_GPIO_SetOutputPin(GPIOB,pins[i]);}
	1019	else {LL_GPIO_ResetOutputPin(GPIOB,pins[i]);}
	1020	}
	1021	}
	1022	#endif
	1023
	1024	/*
	1025	{
	1026	unsigned char pos,seg;
	1027	unsigned short val;
	1028	pos=((KMem.nRunCount)&0x3);
	1029	//val=(KMem.nRunCount)&0xfff;
	1030	val=KMem.ErrStat;
	1031	char buf5[20];
	1032	sprintf(buf5,"%4d",val);
	1033	val=buf5[3-pos];
	1034	if (val <'0' \|\| val >'9') {seg=0;}
	1035	else {seg=LEDSEGTAB[val-'0'];}
	1036
	1037	pos=1<<pos;
	1038	//pos=1;
	1039	//seg=2;
	1040	seg=~seg;
	1041	// PutOutputSPI1(pos\|(seg<<8));
	1042	}
	1043	*/
	1044
	1045	#if (BOARD_TYPE == 13)
	1046	w5500_network_info_show();
	1047	// loopback_tcps(0,str1,5000);
	1048	#endif
	1049
	1050	LL_IWDG_ReloadCounter(IWDG);
	1051
	1052	} //while (1) ;
	1053	/* USER CODE END WHILE */
	1054
	1055	/* USER CODE BEGIN 3 */
	1056
	1057	/* USER CODE END 3 */
	1058
	1059	}
	1060
	1061
	1062	/* USER CODE BEGIN 4 */
	1063
	1064	/* USER CODE END 4 */
	1065
	1066	/**
	1067	* @brief This function is executed in case of error occurrence.
	1068	* @param file: The file name as string.
	1069	* @param line: The line in file as a number.
	1070	* @retval None
	1071	*/
	1072	void _Error_Handler(char *file, int line)
	1073	{
	1074	/* USER CODE BEGIN Error_Handler_Debug */
	1075	/* User can add his own implementation to report the HAL error return state */
	1076	while(1)
	1077	{
	1078	}
	1079	/* USER CODE END Error_Handler_Debug */
	1080	}
	1081
	1082	#ifdef USE_FULL_ASSERT
	1083	/**
	1084	* @brief Reports the name of the source file and the source line number
	1085	* where the assert_param error has occurred.
	1086	* @param file: pointer to the source file name
	1087	* @param line: assert_param error line source number
	1088	* @retval None
	1089	*/
	1090	void assert_failed(uint8_t* file, uint32_t line)
	1091	{
	1092	/* USER CODE BEGIN 6 */
	1093	/* User can add his own implementation to report the file name and line number,
	1094	tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
	1095	/* USER CODE END 6 */
	1096	}
	1097	#endif /* USE_FULL_ASSERT */
	1098
	1099	/**
	1100	* @}
	1101	*/
	1102
	1103	/**
	1104	* @}
	1105	*/
	1106
	1107	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/