lowlevel.c

freescale crc模块驱动 经调试

	sATD1Dat = sATDDat+8;

	/* ATD0相关寄存器的初始化 */
	ATD0CTL2 = 0x00;                                       // ATD0控制寄存器2
	ATD0CTL3 = 0x00;                                       // ATD0控制寄存器3
	ATD0CTL2_ADPU = 1;                                     // 正常ATD功能
	ATD0CTL3 |= 0x00;                                      // 转换序列的长度为8
	ATD0CTL4 = 0x00;                                       // ATD0控制寄存器4
	ATD0CTL5 = 0x00;                                       // ATD0控制寄存器5
	ATD0CTL4 |= 0x60;                                      // 1.10位A/D转换
	                                                       // 2.采样时间为16*A/D转换时钟周期
	ATD0CTL4 |= 0x07;                                      // ATD时钟16分频
	ATD0CTL5_DJM = 1;                                      // A/D转换结果右对齐
	ATD0CTL5_MULT = 1;                                     // 采样多路通道
	ATD0CTL5 |= 0x00;                                      // 模拟输入通道选择码为000
	ATD0STAT0 = 0x00;                                      // ATD0状态寄存器0
	ATD0STAT1 = 0x00;                                      // ATD0状态寄存器1
	ATD0DIEN = 0xFF;                                       // ATD0输入使能寄存器

	/* ATD1相关寄存器的初始化 */
	ATD1CTL2 = 0x00;                                       // ATD1控制寄存器2
	ATD1CTL3 = 0x00;                                       // ATD1控制寄存器3
	ATD1CTL2_ADPU = 1;                                     // 正常ATD功能
	ATD1CTL3 |= 0x00;                                      // 转换序列的长度为8
	ATD1CTL4 = 0x00;                                       // ATD1控制寄存器4
	ATD1CTL5 = 0x00;                                       // ATD1控制寄存器5
	ATD1CTL4 |= 0x60;                                      // 1.10位A/D转换
	                                                       // 2.采样时间为16*A/D转换时钟周期
	ATD1CTL4 |= 0x07;                                      // ATD时钟16分频
	ATD1CTL5_DJM = 1;                                      // A/D转换结果右对齐
	ATD1CTL5_MULT = 1;                                     // 采样多路通道
	ATD1CTL5 |= 0x00;                                      // 模拟输入通道选择码为000
	ATD1STAT0 = 0x00;                                      // ATD1状态寄存器0
	ATD1STAT1 = 0x00;                                      // ATD1状态寄存器1
	ATD1DIEN = 0xFF;                                       // ATD1输入使能寄存器
}

/* ATD0中断服务子程序 */
interrupt 22 void ATD0_ISF (void)
{
	static unsigned short dat[8];
	static signed   char  samp = -1;
	ATD0CTL2_ASCIE = 0;                                    // 禁止进入此处的中断
	if(cATDDatAvail & 0x01)                                // 如果16次A/D转换结束
		return;                                            // 返回
	samp ++;
	if(samp == 0)
	{
		ATD0CTL2_ADPU = 1;
		dat[0] = dat[1] = dat[2] = dat[3] = 0;
		dat[4] = dat[5] = dat[6] = dat[7] = 0;
		return;
	}

	/* 连续读取16次A/D转换结果(滤波) */
	dat[0] += ATD0DR0;
	dat[1] += ATD0DR1;
	dat[2] += ATD0DR2;
	dat[3] += ATD0DR3;
	dat[4] += ATD0DR4;
	dat[5] += ATD0DR5;
	dat[6] += ATD0DR6;
	dat[7] += ATD0DR7;

	/* 16次读取完毕,取平均值 */
	if(samp < 16)
		return;
	sATD0Dat[0] = dat[0] >> 4;
	sATD0Dat[1] = dat[1] >> 4;
	sATD0Dat[2] = dat[2] >> 4;
	sATD0Dat[3] = dat[3] >> 4;
	sATD0Dat[4] = dat[4] >> 4;
	sATD0Dat[5] = dat[5] >> 4;
	sATD0Dat[6] = dat[6] >> 4;
	sATD0Dat[7] = dat[7] >> 4;

	/* 变量初始化 */
	samp = -1;
	cATDDatAvail |= 0x01;
}

/* ATD1中断服务子程序 */
interrupt 23 void ATD1_ISF (void)
{
	static unsigned short dat[8];
	static signed   char  samp = -1;
	ATD1CTL2_ASCIE = 0;                                    // 禁止进入ATD中断服务子程序
	if(cATDDatAvail & 0x02)                                // 如果16次A/D转换结束
		return;                                            // 返回
	samp ++;
	if(samp == 0)
	{
		ATD1CTL2_ADPU = 1;
		dat[0] = dat[1] = dat[2] = dat[3] = 0;
		dat[4] = dat[5] = dat[6] = dat[7] = 0;
		return;
	}

	/* 连续读取16次A/D转换结果(滤波) */
	dat[0] += ATD1DR0;
	dat[1] += ATD1DR1;
	dat[2] += ATD1DR2;
	dat[3] += ATD1DR3;
	dat[4] += ATD1DR4;
	dat[5] += ATD1DR5;
	dat[6] += ATD1DR6;
	dat[7] += ATD1DR7;

	/* 16次读取完毕,取平均值 */
	if(samp < 16)
		return;
	sATD1Dat[0] = dat[0] >> 4;
	sATD1Dat[1] = dat[1] >> 4;
	sATD1Dat[2] = dat[2] >> 4;
	sATD1Dat[3] = dat[3] >> 4;
	sATD1Dat[4] = dat[4] >> 4;
	sATD1Dat[5] = dat[5] >> 4;
	sATD1Dat[6] = dat[6] >> 4;
	sATD1Dat[7] = dat[7] >> 4;

	/* 变量初始化 */
	samp = -1;
	cATDDatAvail |= 0x02;
}

/******************************************************************************
 * 函数原型: void ATDSamplStart(void);                                        *
 * 功能: 启动A/D转换                                                          *
 * 说明: 无                                                                   *
 ******************************************************************************/
void ATDSamplStart (void)
{
	unsigned char t;
	cATDDatAvail = 0x00;                                   // 启动A/D转换
	ATD0CTL2_ASCIE = 1;                                    // 允许进入ATD0中断服务子程序

	/* 1.清除中断标志SCF; 2.启动新的A/D转换序列 */
	t = ATD0CTL5;
	ATD0CTL5 = t;

	ATD1CTL2_ASCIE = 1;                                    // 允许进入ATD1中断服务子程序
	t = ATD1CTL5;
	ATD1CTL5 = t;
}

/******************************************************************************
 * 函数原型: void InitSoftUART2(void);                                        *
 * 功能: 模拟串口相关变量的初始化                                             *
 * 说明: 使用PB.0和PB.1模拟串口,PB.0模拟RxD,PB.1模拟TxD                       *
 ******************************************************************************/
void InitSoftUART2 (void)
{
	c_uart2IFlag = 0x00;
	b_uart2IFull = 0;
	c_uart2OFlag = 0x00;
	b_uart2OEmpt = 1;
	c_uart2OBitCyc = 0;
	c_uart2ODatCyc = 0;
	cUART2TxHead = 0;
	cUART2TxEnd  = 0;
	cUART2RxHead = 0;
	cUART2RxEnd  = 0;
}

/******************************************************************************
 * 函数原型: void uart2recvchrontick(void);                                   *
 * 功能: 模拟串口部分单个字节逐位接收模块                                     *
 * 说明: 1.接收字节的格式为,1个起始位,8个数据位,1个停止位                     *
 *       2.RS232通信规则为,起始位0,停止位1,电平采集方式"3取2"                 *
 ******************************************************************************/
void uart2recvchrontick (void)
{
	if(!b_uart2IWork)                                      // 如果接收过程未在进行
	{
		if(p_uart2IRx)                                     // 如果接收管脚保持逻辑1电平
			return;                                        // 没有数据传过来,返回
		c_uart2IDatCyc = 0;
		c_uart2IBitCyc = 0;
		b_uart2IWork = 1;                                  // 接收进程启动
		return;
	}
	c_uart2IBitCyc ++;
	if(c_uart2IBitCyc == UART2BitCycM)
		c_uart2IBitCyc = 0;
# if UART2BitCycM >= 8
	if(c_uart2IBitCyc == 1)
		c_uart2IBitBuf = 0;
	// 在位于中间的时标处采样3次
	if(c_uart2IBitCyc == (UART2BitCycM/2-1) ||             // c_uart2IBitCyc == 3
       c_uart2IBitCyc == (UART2BitCycM/2)   ||             // c_uart2IBitCyc == 4
	   c_uart2IBitCyc == (UART2BitCycM/2+1))               // c_uart2IBitCyc == 5
        if(p_uart2IRx)                                     // 如果读到逻辑电平1
			c_uart2IBitBuf ++;
	if(c_uart2IBitCyc != (UART2BitCycM/2+1))               // 读完3次有效数据,向下处理
		return;
# else
	if(c_uart2IBitCyc != (UART2BitCycM/2))
		return;
# endif
	c_uart2IDatCyc ++;
	switch(c_uart2IDatCyc)
	{
	case 1:
# if UART2BitCycM >= 8
		if(c_uart2IBitBuf < 2)                             // 如果起始位是0,继续接收
			break;
# else
		if(!p_uart2IRx)
			break;
# endif
		b_uart2IWork = 0;                                  // 如果起始位不是0,停止接收
		break;
	case 2:                                                // 接收当前字节的第0位
	case 3:                                                // 接收当前字节的第1位
	case 4:                                                // 接收当前字节的第2位
	case 5:                                                // 接收当前字节的第3位
	case 6:                                                // 接收当前字节的第4位
	case 7:                                                // 接收当前字节的第5位
	case 8:                                                // 接收当前字节的第6位
	case 9:                                                // 接收当前字节的第7位
		c_uart2IShtBuf >>= 1;                              // 输入移位寄存器右移1位
# if UART2BitCycM >= 8
		b_uart2IHBit = c_uart2IBitBuf>1;                   // c_uart2IBitBuf为2或3
# else
		b_uart2IHBit = p_uart2IRx;
# endif
		break;
	case 10:
# if UART2BitCycM >= 8
		if(c_uart2IBitBuf > 1)
		{
# else
		if(p_uart2IRx)
		{
# endif
			if(b_uart2IFull)                               // 如果c_uart2IDatBuf中的数未被取走
				b_uart2IErrOV = 1;
			c_uart2IDatBuf = c_uart2IShtBuf;
			b_uart2IFull = 1;
		}
		else
			b_uart2IErrFr = 1;
		b_uart2IWork = 0;
		break;
	default:
		b_uart2IError = 1;
		b_uart2IWork = 0;
		break;
	}
}

/******************************************************************************
 * 函数原型: char uart2recvchr(void);                                         *
 * 功能: 模拟串口部分单个字节接收模块                                         *
 * 说明: 无                                                                   *
 ******************************************************************************/
char uart2recvchr (void)
{
	b_uart2IFull = 0;
	return c_uart2IDatBuf;
}

/******************************************************************************
 * 函数原型: void uart2sendchrontick(void);                                   *
 * 功能: 模拟串口部分单个字节逐位发送模块                                     *
 * 说明: 无                                                                   *
 ******************************************************************************/
void uart2sendchrontick (void)
{
	if(!b_uart2OWork)
		return;
	c_uart2OBitCyc ++;
	if(c_uart2OBitCyc < UART2BitCycM)
		return;
	c_uart2OBitCyc = 0;
	c_uart2ODatCyc ++;
	switch(c_uart2ODatCyc)
	{
	case 1:
		p_uart2OTx = 0;                                    // 起始位
		break;
	case 2:
	case 3:
	case 4:
	case 5:
	case 6:
	case 7:
	case 8:
	case 9:
		p_uart2OTx = b_uart2OLBit;                         // 从第0位开始发送
		c_uart2OShtBuf >>= 1;                              // 输出移位寄存器右移1位
		break;
	case 10:
		p_uart2OTx = 1;                                    // 停止位
		b_uart2OWork = 0;
		b_uart2OEmpt = 1;
		c_uart2ODatCyc = 0;
		break;
	default:
		p_uart2OTx = 1;
		b_uart2OWork = 0;
		b_uart2OError = 1;
		c_uart2OBitCyc = 0;
		c_uart2ODatCyc = 0;
		break;
	}
}

/******************************************************************************
 * 函数原型: void uart2sendchr(char chr);                                     *
 * 功能: 模拟串口部分单个字节发送模块                                         *
 * 说明: chr为要发送的字节                                                    *
 ******************************************************************************/
void uart2sendchr (char chr)
{
	c_uart2OShtBuf = chr;
	b_uart2OEmpt = 0;
	b_uart2OWork = 1;
}

/******************************************************************************
 * 函数原型: void uart2OnTick(void);                                          *
 * 功能: UART2中断服务子程序                                                  *
 * 说明: 无                                                                   *
 ******************************************************************************/
void uart2OnTick (void)
{
	if(b_uart2IFull)
	{
		cUART2RxBuf[cUART2RxEnd] = uart2recvchr();
		cUART2RxEnd ++;
		if(cUART2RxEnd >= CMUART2RxBufLenMax)
			cUART2RxEnd = 0;
		if(cUART2RxEnd == cUART2RxHead)
			cUART2RxHead ++;
		if(cUART2RxHead >= CMUART2RxBufLenMax)
			cUART2RxHead = 0;
	}
	if(b_uart2OEmpt)
	{
		if(cUART2TxHead == cUART2TxEnd)
			goto tx2_ret;
		uart2sendchr(cUART2TxBuf[cUART2TxHead]);
		cUART2TxHead ++;
		if(cUART2TxHead >= CMUART2TxBufLenMax)
			cUART2TxHead = 0;
	}
tx2_ret:
	;
}

/******************************************************************************
 * 函数原型: void UART0Send(void *buf, int len);                              *
 * 功能: 将buf中的头len个字节放到UART0的发送缓冲区中                          *
 * 说明: buf为要发送的数组,len为要发送的字节数                                *
 ******************************************************************************/
void UART0Send (void *buf, int len)
{
	int i;
	if(len < 1)
		return;
	for(i = 0; i < len; i++)
	{
		cUART0TxBuf[cUART0TxEnd] = ((char *)buf)[i];
		cUART0TxEnd ++;
		if(cUART0TxEnd >= CMUART0TxBufLenMax)
			cUART0TxEnd = 0;
		if(cUART0TxEnd == cUART0TxHead)
			cUART0TxHead ++;
		if(cUART0TxHead >= CMUART0TxBufLenMax)
			cUART0TxHead = 0;
	}
	/*
# if !Test_Comm485OnlyRecv
	if(!is_UART0RS485Send)
		portOUT_UART0RS485Send;
# endif
	*/
	SCI0CR2_SCTIE = 1;                                     // 使能发送数据寄存器空中断