avrpro.c

信号滤波

//*******************************************************************************//
//Program by Dale.
//07/23/08 21:15 USART1-0 marker bit [0xFFFF] ---- Success
//08/20/08 20:00 10-Data average filtration   ---- Success
//*******************************************************************************//
#include <stdint.h>
#include <stdio.h>
#include <avr/io.h>
#include <avr/pgmspace.h>

#define PRINTF(format, ...) printf_P(PSTR(format), ## __VA_ARGS__)
#define USART0_BAUD         19200ul
#define USART1_BAUD         19200ul
#define USART0_UBBR_VALUE   ((F_CPU/(USART0_BAUD<<4))-1)
#define USART1_UBBR_VALUE   ((F_CPU/(USART1_BAUD<<4))-1)
#define Def_A 30	//滤波取点数值
#define Def_B 30	//阈值取点数量
#define Def_C 150	//阈值幅度

//*******************************************************************************//
void USART0_vInit(void)
{
    UBRR0H = (uint8_t)(USART0_UBBR_VALUE>>8);
    UBRR0L = (uint8_t)USART0_UBBR_VALUE;
    UCSR0C = (0<<USBS)|(1<<UCSZ1)|(1<<UCSZ0);
    UCSR0B = (1<<RXEN)|(1<<TXEN);   
}

void USART1_vInit(void)
{
    UBRR1H = (uint8_t)(USART1_UBBR_VALUE>>8);
    UBRR1L = (uint8_t)USART1_UBBR_VALUE;
    UCSR1C = (0<<UMSEL)|(0<<USBS)|(0<<UCSZ2)|(1<<UCSZ1)|(1<<UCSZ0);
    UCSR1B = (1<<RXEN)|(1<<TXEN);   
}

int USART0_iPutChar(char cData, FILE* pxStream)
{
    if(cData == '\n')
    {
        USART0_iPutChar('\r',pxStream);
    }
    while((UCSR0A&(1<<UDRE0)) == 0)
    {
        ;
    }
    UDR0 = cData;

    return 0;
}

unsigned char USART1_iGetChar(void)
{
	while ( !(UCSR1A & (1<<RXC1)) )
	;
	return UDR1;
}

FILE PRINTF_xStream = FDEV_SETUP_STREAM(USART0_iPutChar, NULL, _FDEV_SETUP_WRITE);
//*******************************************************************************//
void TMR_vInit(void)
{
    TCCR1A =  (0<<COM1A1)|(0<<COM1A0)|(0<<COM1B1)|(0<<COM1B0)
             |(0<<COM1C1)|(0<<COM1C0)|(0<<WGM11) |(0<<WGM10);
    TCCR1B =  (0<<ICNC1) |(0<<ICES1) |(0<<WGM13) |(0<<WGM12)
             |(1<<CS12)  |(0<<CS11)  |(1<<CS10);
}

void TMR_vDelay(uint16_t u16DelayMs)
{
    TCNT1  = (uint16_t) (0x10000 - ((F_CPU/1024)*u16DelayMs)/1000);
    TIFR = (1<<TOV1);
    while((TIFR&(1<<TOV1)) == 0)
    {
        ;
    }
}
//*******************************************************************************//
int main(void)
{

	unsigned int TEMP_A[Def_A][3],TEMP_B[Def_B][3];
	unsigned int Res[3],Ress_A[3],Ress_B[3];
	unsigned long int Res_A,Res_B;
	unsigned char a,i,n=0,m=0;

    USART0_vInit();
	USART1_vInit();
    stdout = &PRINTF_xStream;
    TMR_vInit();

	DDRA |= (1<<1);	

    for(;;)
    {
		if ((USART1_iGetChar()) == 0xFF)
		{
			if ((USART1_iGetChar()) == 0xFF)
			{
				for(i = 0;i < 3;i++)	//串口1取值
					{
						TEMP_A[n][i] = (((unsigned int)(USART1_iGetChar()))<<8) + ((USART1_iGetChar()) & 0xF0);
						TEMP_A[n][i] = TEMP_A[n][i]>>4;
					}
				for(i = 0;i < 3;i++)	
					{
						//滤波
						Res_A = 0;
						for(a = 0;a < Def_A;a++)
						{
							Res_A = Res_A + TEMP_A[a][i];	
						}
						Ress_A[i] = Res_A / Def_A;
						if(n > Def_A){n = 0;}
						else {n++;}
						
						//阈值判断
						TEMP_B[m][i] = Ress_A[i];
						Res_B = 0;
						for(a = 0;a < Def_B;a++)
						{
							Res_B = Res_B + TEMP_B[a][i];	
						}
						Ress_B[i] = Res_B / Def_B;

						if (TEMP_B[m][i] > (Ress_B[i] + Def_C))
							{
								Res[i] = 0xEEF;
							}
						else if (TEMP_B[m][i] < (Ress_B[i] - Def_C))
							{
								Res[i] = 0x11F;
							}
						else
							{
								Res[i] = 0x77F;
							}
						if(m > Def_B){m = 0;}
						else {m++;}


						
					}
/*					PRINTF("%4x",TEMP_A[n][0]);
					PRINTF("%4x",Ress_A[0]);
					PRINTF("%4x",Res[0]);
*/

				for(i = 0;i < 3;i++)	//打印串口0
					{
						PRINTF("%4x",Res[i]);
					}

				PRINTF("\n");
				PORTA |= (1<<1);
				TMR_vDelay(1);
				PORTA &= ~(1<<1);
			}
		}

    }
}