5_uart_sst.c

C51 用PCA 模拟串口

							UART0_TX_STATE = 0; // 复位TX状态
							UART0_RX_STATE = 0; // 复位RX状态变量
							UART0_TX = 1; // UART0_TX应保持高电平
							CCAPM0 = NEG_CAP_INT; // 发送完一个字节,便立即回到接收的状态
							UART0_RX_FLAG = 1;	//发送完一个字节,便立即回到接收的状态
							break;
						}
					}
		}

	//===========UART1通道的数据接收和发送的处理=============================
	if (CCF1)
	{
		CCF1 = 0; // 清除中断标志
		if (UART1_RX_FLAG)
		{
			switch (UART1_RX_STATE)
				{
					case 0:
						if (~UART1_RX)
							{ 										//检查接收允许和起始位是否正确
								PCA_TEMP = (CCAP1H * 0x100)+CCAP1L+TIME_COUNT*3/2; // 将模块0内容读到
								CCAP1L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
								CCAP1H = (PCA_TEMP/ 0x100);
								CCAPM1 = TIME_INIT ; // 将模块0切换到软件定时器方式
													// 允许中断
								UART1_RX_STATE++; // 更新RX状态变量
							}
							break;
					case 1:
					case 2:
					case 3:
					case 4:
					case 5:
					case 6:
					case 7:
					case 8:
						UART1_RX_SHIFT = UART1_RX_SHIFT >> 1; // 右移一位
						if (UART1_RX) // If UART1_RX=1
							UART1_RX_SHIFT |= 0x80; // 将'1'移入UART1_RX_SHIFT的msb
						PCA_TEMP = ( CCAP1H* 0x100)+CCAP1L+TIME_COUNT;// 将模块0内容读到PCA_TEMP
						CCAP1L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
						CCAP1H = (PCA_TEMP / 0x100);
						UART1_RX_STATE++; // 更新RX状态变量
						break;
					case 9:
						UART1_SBUF = UART1_RX_SHIFT; // 将接收到的数据传送到接收寄存器
						UART1_RI = 1; // 置1接收完成标志
						CCAPM1 = NEG_CAP_INT;		//置为下降沿捕捉中断方式0x11; // 切换模块0到负沿捕捉方式
						UART1_RX_STATE = 0; // 复位RX状态变量
						break;
					}
				}
	//======================UART1发送===================================
				else 		//否则,UART1_RX_FLAG=0,为发送状态
				{
						switch (UART1_TX_STATE)
						{
							case 0:
								UART1_TX = 0; // 使TX引脚变低作为起始位
								PCA_TEMP = (CH* 0x100)+CL+TIME_COUNT; // 将PCA计数器的值读到PCA_TEMP
								CCAP1L = PCA_TEMP; // 将更新后的匹配值存到
								CCAP1H = (PCA_TEMP/ 0x100);// 模块1捕捉比较寄存器
								CCAPM1 = TIME_INIT;	//0x48; // 允许模块1软件定时器
								UART1_TX_STATE++; // 更新TX状态变量
								break;
							case 1:
							case 2:
							case 3:
							case 4:
							case 5:
							case 6:
							case 7:
							case 8:
							case 9:
								UART1_TX = (UART1_SBUF & 0x01); // 将UART1_SBUF的LSB输出到UART1_TX引脚
								UART1_SBUF >>= 1; // UART1_SBUF右移一位
								UART1_SBUF |= 0x80; // 将一个'1'移入UART1_SBUF的MSB
								PCA_TEMP = (CCAP1H * 0x100)+CCAP1L+TIME_COUNT;// 将模块1内容读到PCA_TEMP
								CCAP1L = PCA_TEMP; // 用新值恢复CCAP1L
								CCAP1H = (PCA_TEMP / 0x100);// 和CCAP1H
								UART1_TX_STATE++; // 更新TX状态变量
								break;
						case 10:
							UART1_TI = 1; // 表示发送完成
							UART1_TX_STATE = 0; // 复位TX状态
							UART1_RX_STATE = 0; // 复位RX状态变量
							UART1_TX = 1; // UART1_TX应保持高电平
							CCAPM1 = NEG_CAP_INT; // 发送完一个字节,便立即回到接收的状态
							UART1_RX_FLAG = 1;	//发送完一个字节,便立即回到接收的状态
							break;
						}
					}
		}

	//===========UART2通道的数据接收和发送的处理=============================
	if (CCF2)
	{
		CCF2 = 0; // 清除中断标志
		if (UART2_RX_FLAG)
		{
			switch (UART2_RX_STATE)
				{
					case 0:
						if (~UART2_RX)
							{ 										//检查接收允许和起始位是否正确
								PCA_TEMP = (CCAP2H * 0x100)+CCAP2L+TIME_COUNT*3/2; // 将模块0内容读到
								CCAP2L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
								CCAP2H = (PCA_TEMP/ 0x100);
								CCAPM2 = TIME_INIT ; // 将模块0切换到软件定时器方式
													// 允许中断
								UART2_RX_STATE++; // 更新RX状态变量
							}
							break;
					case 1:
					case 2:
					case 3:
					case 4:
					case 5:
					case 6:
					case 7:
					case 8:
						UART2_RX_SHIFT = UART2_RX_SHIFT >> 1; // 右移一位
						if (UART2_RX) // If UART2_RX=1
							UART2_RX_SHIFT |= 0x80; // 将'1'移入UART2_RX_SHIFT的msb
						PCA_TEMP = ( CCAP2H* 0x100)+CCAP2L+TIME_COUNT;// 将模块0内容读到PCA_TEMP
						CCAP2L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
						CCAP2H = (PCA_TEMP / 0x100);
						UART2_RX_STATE++; // 更新RX状态变量
						break;
					case 9:
						UART2_SBUF = UART2_RX_SHIFT; // 将接收到的数据传送到接收寄存器
						UART2_RI = 1; // 置1接收完成标志
						CCAPM2 = NEG_CAP_INT;		//置为下降沿捕捉中断方式0x11; // 切换模块0到负沿捕捉方式
						UART2_RX_STATE = 0; // 复位RX状态变量
						break;
					}
				}
	//======================UART2发送===================================
				else 		//否则,UART2_RX_FLAG=0,为发送状态
				{
						switch (UART2_TX_STATE)
						{
							case 0:
								UART2_TX = 0; // 使TX引脚变低作为起始位
								PCA_TEMP = (CH* 0x100)+CL+TIME_COUNT; // 将PCA计数器的值读到PCA_TEMP
								CCAP2L = PCA_TEMP; // 将更新后的匹配值存到
								CCAP2H = (PCA_TEMP/ 0x100);// 模块1捕捉比较寄存器
								CCAPM2 = TIME_INIT;	//0x48; // 允许模块1软件定时器
								UART2_TX_STATE++; // 更新TX状态变量
								break;
							case 1:
							case 2:
							case 3:
							case 4:
							case 5:
							case 6:
							case 7:
							case 8:
							case 9:
								UART2_TX = (UART2_SBUF & 0x01); // 将UART2_SBUF的LSB输出到UART2_TX引脚
								UART2_SBUF >>= 1; // UART2_SBUF右移一位
								UART2_SBUF |= 0x80; // 将一个'1'移入UART2_SBUF的MSB
								PCA_TEMP = (CCAP2H * 0x100)+CCAP2L+TIME_COUNT;// 将模块1内容读到PCA_TEMP
								CCAP2L = PCA_TEMP; // 用新值恢复CCAP1L
								CCAP2H = (PCA_TEMP / 0x100);// 和CCAP1H
								UART2_TX_STATE++; // 更新TX状态变量
								break;
						case 10:
							UART2_TI = 1; // 表示发送完成
							UART2_TX_STATE = 0; // 复位TX状态
							UART2_RX_STATE = 0; // 复位RX状态变量
							UART2_TX = 1; // UART2_TX应保持高电平
							CCAPM2 = NEG_CAP_INT; // 发送完一个字节,便立即回到接收的状态
							UART2_RX_FLAG = 1;	//发送完一个字节,便立即回到接收的状态
							break;
						}
					}
		}
	//===========UART3通道的数据接收和发送的处理=============================
	if (CCF3)
	{
		CCF3 = 0; // 清除中断标志
		if (UART3_RX_FLAG)
		{
			switch (UART3_RX_STATE)
				{
					case 0:
						if (~UART3_RX)
							{ 										//检查接收允许和起始位是否正确
								PCA_TEMP = (CCAP3H * 0x100)+CCAP3L+TIME_COUNT*3/2; // 将模块0内容读到
								CCAP3L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
								CCAP3H = (PCA_TEMP/ 0x100);
								CCAPM3 = TIME_INIT ; // 将模块0切换到软件定时器方式
													// 允许中断
								UART3_RX_STATE++; // 更新RX状态变量
							}
							break;
					case 1:
					case 2:
					case 3:
					case 4:
					case 5:
					case 6:
					case 7:
					case 8:
						UART3_RX_SHIFT = UART3_RX_SHIFT >> 1; // 右移一位
						if (UART3_RX) // If UART3_RX=1
							UART3_RX_SHIFT |= 0x80; // 将'1'移入UART3_RX_SHIFT的msb
						PCA_TEMP = ( CCAP3H* 0x100)+CCAP3L+TIME_COUNT;// 将模块0内容读到PCA_TEMP
						CCAP3L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
						CCAP3H = (PCA_TEMP / 0x100);
						UART3_RX_STATE++; // 更新RX状态变量
						break;
					case 9:
						UART3_SBUF = UART3_RX_SHIFT; // 将接收到的数据传送到接收寄存器
						UART3_RI = 1; // 置1接收完成标志
						CCAPM3 = NEG_CAP_INT;		//置为下降沿捕捉中断方式0x11; // 切换模块0到负沿捕捉方式
						UART3_RX_STATE = 0; // 复位RX状态变量
						break;
					}
				}
	//======================UART3发送===================================
				else 		//否则,UART3_RX_FLAG=0,为发送状态
				{
						switch (UART3_TX_STATE)
						{
							case 0:
								UART3_TX = 0; // 使TX引脚变低作为起始位
								PCA_TEMP = (CH* 0x100)+CL+TIME_COUNT; // 将PCA计数器的值读到PCA_TEMP
								CCAP3L = PCA_TEMP; // 将更新后的匹配值存到
								CCAP3H = (PCA_TEMP/ 0x100);// 模块1捕捉比较寄存器
								CCAPM3 = TIME_INIT;	//0x48; // 允许模块1软件定时器
								UART3_TX_STATE++; // 更新TX状态变量
								break;
							case 1:
							case 2:
							case 3:
							case 4:
							case 5:
							case 6:
							case 7:
							case 8:
							case 9:
								UART3_TX = (UART3_SBUF & 0x01); // 将UART3_SBUF的LSB输出到UART3_TX引脚
								UART3_SBUF >>= 1; // UART3_SBUF右移一位
								UART3_SBUF |= 0x80; // 将一个'1'移入UART3_SBUF的MSB
								PCA_TEMP = (CCAP3H * 0x100)+CCAP3L+TIME_COUNT;// 将模块1内容读到PCA_TEMP
								CCAP3L = PCA_TEMP; // 用新值恢复CCAP1L
								CCAP3H = (PCA_TEMP / 0x100);// 和CCAP1H
								UART3_TX_STATE++; // 更新TX状态变量
								break;
						case 10:
							UART3_TI = 1; // 表示发送完成
							UART3_TX_STATE = 0; // 复位TX状态
							UART3_RX_STATE = 0; // 复位RX状态变量
							UART3_TX = 1; // UART3_TX应保持高电平
							CCAPM3 = NEG_CAP_INT; // 发送完一个字节,便立即回到接收的状态
							UART3_RX_FLAG = 1;	//发送完一个字节,便立即回到接收的状态
							break;
						}
					}
		}
	//===========UART4通道的数据接收和发送的处理=============================
	if (CCF4)
	{
		CCF4 = 0; // 清除中断标志
		if (UART4_RX_FLAG)
		{
			switch (UART4_RX_STATE)
				{
					case 0:
						if (~UART4_RX)
							{ 										//检查接收允许和起始位是否正确
								PCA_TEMP = (CCAP4H * 0x100)+CCAP4L+TIME_COUNT*3/2; // 将模块0内容读到
								CCAP4L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
								CCAP4H = (PCA_TEMP/ 0x100);
								CCAPM4 = TIME_INIT ; // 将模块0切换到软件定时器方式
													// 允许中断
								UART4_RX_STATE++; // 更新RX状态变量
							}
							break;
					case 1:
					case 2:
					case 3:
					case 4:
					case 5:
					case 6:
					case 7:
					case 8:
						UART4_RX_SHIFT = UART4_RX_SHIFT >> 1; // 右移一位
						if (UART4_RX) // If UART4_RX=1
							UART4_RX_SHIFT |= 0x80; // 将'1'移入UART4_RX_SHIFT的msb
						PCA_TEMP = ( CCAP4H* 0x100)+CCAP4L+TIME_COUNT;// 将模块0内容读到PCA_TEMP
						CCAP4L = PCA_TEMP; // 用新值恢复CCAP0L和CCAP0H
						CCAP4H = (PCA_TEMP / 0x100);
						UART4_RX_STATE++; // 更新RX状态变量
						break;
					case 9:
						UART4_SBUF = UART4_RX_SHIFT; // 将接收到的数据传送到接收寄存器
						UART4_RI = 1; // 置1接收完成标志
						CCAPM4 = NEG_CAP_INT;		//置为下降沿捕捉中断方式0x11; // 切换模块0到负沿捕捉方式
						UART4_RX_STATE = 0; // 复位RX状态变量
						break;
					}
				}
	//======================UART4发送===================================
				else 		//否则,UART4_RX_FLAG=0,为发送状态
				{
						switch (UART4_TX_STATE)
						{
							case 0:
								UART4_TX = 0; // 使TX引脚变低作为起始位