lcd_library.c

一个很不错的GPS接收机源程序

*   Function: LCD_PutBigstr(char* Str, unsigned char y,unsigned char x)
*   Input Variables: char* Str, unsigned char y,unsigned char x
*   Return Variables: void
*   Usage：显示4倍大的字符串
**********************************************/
void LCD_PutBigstr(char* Str, unsigned char y,unsigned char x)
{
		unsigned char i = 0; 
		while(*Str)
		{
				LCD_PutBigchar(*Str++,y,x+11*i);
				i++;
		}
}


/**********************************************
*   Function: LCD_PlotLine(unsigned int NewPoint)
*   Input Variables: unsigned int NewPoint
*   Return Variables: void
*   Usage：在LCD上绘制连续的直线
**********************************************/
void LCD_PlotLine(unsigned int NewPoint)
{
		static short pPlot = 0;
		static unsigned char PLOT_LAST_SHIFT = 0;
		static char PLOT_BUFFER[LCD_PLOT_HEIGHT];
		unsigned char j;
		int diff;
		char PlotShift;
		unsigned long int Plot_Value,WRT_Value;
		/*
		for(i=LCD_PLOT_MAX_POINTS-1;i>0;i--)
		{
				for(j=0;j<LCD_PLOT_HEIGHT;j++)
					{
							PLOT_BUFFER[j][i] = PLOT_BUFFER[j][i-1];
					}
		}
		*/
		if(NewPoint>=LCD_PLOT_MAX_VALUE) PlotShift = LCD_PLOT_HEIGHT*8-1 ;
		else
		PlotShift = (char)((double)NewPoint*(LCD_PLOT_HEIGHT*8-1)/LCD_PLOT_MAX_VALUE);
		// Attention! if LCD_PLOT_MAX_VALUE > 0xff for instance 0xffff, the multiplication might be overflow
		// a double force convert is necessary
		//Plot_Value = ((long int)0x01<<(LCD_PLOT_HEIGHT*8-1))>>PlotShift;
		Plot_Value = 0x80000000>>(4-LCD_PLOT_HEIGHT)*8>>PlotShift;
		WRT_Value = Plot_Value; 
		diff = PlotShift - PLOT_LAST_SHIFT;
	
				if(diff>=2)
				{
						for(j=0;j<diff-1;j++)
						{
								WRT_Value = WRT_Value<<1;
								WRT_Value += Plot_Value;
						}
				}
				else if(diff<=-2)
				{
						for(j=0;j<1-diff;j++)
						{
								WRT_Value = WRT_Value>>1;
								WRT_Value += Plot_Value;
						}
				}
				
				for(j=0;j<LCD_PLOT_HEIGHT;j++)
					{
							PLOT_BUFFER[j] = (char)((WRT_Value>>(j*8))&0xff);
					}
					
		for(j=0;j<LCD_PLOT_HEIGHT;j++)
		{
				LCD_Cursor2yx(j,pPlot+LCD_DISPLAY_OFFSET);
				LCD_WRT_DAT(PLOT_BUFFER[j]);
				LCD_WRT_DAT(0xff);
				LCD_WRT_DAT(0xff);
		}	
		
		if((++pPlot) == LCD_PLOT_MAX_POINTS )pPlot = 0;
		PLOT_LAST_SHIFT = PlotShift;
}





/**********************************************
*   Function: LCD_RollingDisplay(char* pStr)
*   Input Variables: char* pStr
*   Return Variables: void
*   Usage：在LCD滚动显示信息
**********************************************/
void LCD_RollingDisplay(char* pStr)
{
		static unsigned char i=7,j=0;
		LCD_Cursor2yx(i,5);
		LCD_Putstr("                     ");
		LCD_Cursor2yx(i,5);
		_LCD_SET_DISPLINE(j);
		LCD_Putstr(pStr);
		if(++i>7)i=0;
		j+=8;
		if(j > 56) j =0;
}

U8 LCD_mini_printf(U8 *format, ...)
{
    va_list arg_ptr;
    U8      *p,*sval;
    U8      u8_temp, n_sign, data_idx, min_size;
    U8      data_buf[DATA_BUF_LEN];
    S8      long_flag, alt_p_c;
    S8      s8_val;
    S16     s16_val;
    S32     s32_val;
    U16     u16_val;
    U32     u32_val;

    long_flag = TRUE;
    alt_p_c = FALSE;
    min_size = DATA_BUF_LEN-1;

    va_start(arg_ptr, format);   // make arg_ptr point to the first unnamed arg
    for (p = format; *p; p++)
    {
        if ((*p == '%') || (alt_p_c == TRUE))
        {
            p++;
        }
        else
        {
            LCD_Putchar(*p);
            alt_p_c = FALSE;
            long_flag = FALSE;
            continue;   // "switch (*p)" section skipped
        }
        switch (*p)
        {
            case 'c':
                if (long_flag == TRUE)      // ERROR: 'l' before any 'c'
                {
                    LCD_Putchar('l');
                    LCD_Putchar('c');
                }
                else
                {
                    s8_val = (S8)(va_arg(arg_ptr, int));    // s8_val = (S8)(va_arg(arg_ptr, S16));
                    LCD_Putchar((U8)(s8_val));
                }
                // Clean up
                min_size = DATA_BUF_LEN-1;
                alt_p_c = FALSE;
                long_flag = FALSE;
                break; // case 'c'
                
            case 's':
                if (long_flag == TRUE)      // ERROR: 'l' before any 's'
                {
                    LCD_Putchar('l');
                    LCD_Putchar('s');
                }
                else
                {
                    for (sval = va_arg(arg_ptr, U8 *); *sval; sval++)
                    {
                        LCD_Putchar(*sval);
                    }
                }
                // Clean up
                min_size = DATA_BUF_LEN-1;
                alt_p_c = FALSE;
                long_flag = FALSE;
                break;  // case 's'
                
            case 'l':  // It is not the number "ONE" but the lower case of "L" character
                if (long_flag == TRUE)      // ERROR: two consecutive 'l'
                {
                    LCD_Putchar('l');
                    alt_p_c = FALSE;
                    long_flag = FALSE;
                }
                else
                {
                    alt_p_c = TRUE;
                    long_flag = TRUE;
                }
                p--;
                break;  // case 'l'
                
            case 'd':
                n_sign  = FALSE;               
                for(data_idx = 0; data_idx < (DATA_BUF_LEN-1); data_idx++)
                {
                    data_buf[data_idx] = '0';
                }
                data_buf[DATA_BUF_LEN-1] = 0;
                data_idx = DATA_BUF_LEN - 2;
                if (long_flag)  // 32-bit
                {
                    s32_val = va_arg(arg_ptr, S32);
                    if (s32_val < 0)
                    {
                        n_sign = TRUE;
                        s32_val  = -s32_val;
                    }
                    while (s32_val)
                    {
                        data_buf[data_idx] = s32_val % 10 + '0';
                        s32_val /= 10;
                         data_idx--;
                   }
                }
                else  // 16-bit
                {
                    s16_val = (S16)(va_arg(arg_ptr, int)); // s16_val = va_arg(arg_ptr, S16);
                    if (s16_val < 0)
                    {
                        n_sign = TRUE;
                        s16_val  = -s16_val;
                    }
                    while (s16_val)
                    {
                        data_buf[data_idx] = s16_val % 10 + '0';
                        s16_val /= 10;
                        data_idx--;
                    }
                }
                if (n_sign) { LCD_Putchar('-'); }
                data_idx++;
                if (min_size < data_idx)
                {
                    data_idx = min_size;
                }
                LCD_Putstr (data_buf + data_idx);
                // Clean up
                min_size = DATA_BUF_LEN-1;
                alt_p_c = FALSE;
                long_flag = FALSE;
                break;  // case 'd'
                
            case 'u':
                for(data_idx = 0; data_idx < (DATA_BUF_LEN-1); data_idx++)
                {
                    data_buf[data_idx] = '0';
                }
                data_buf[DATA_BUF_LEN-1] = 0;
                data_idx = DATA_BUF_LEN - 2;
                if (long_flag)  // 32-bit
                {
                    u32_val = va_arg(arg_ptr, U32);
                    while (u32_val)
                    {
                        data_buf[data_idx] = u32_val % 10 + '0';
                        u32_val /= 10;
                        data_idx--;
                    }
                }
                else  // 16-bit
                {
                    u16_val = (U16)(va_arg(arg_ptr, int)); // u16_val = va_arg(arg_ptr, U16);
                    while (u16_val)
                    {
                        data_buf[data_idx] = u16_val % 10 + '0';
                        data_idx--;
                        u16_val /= 10;
                    }
                }
                data_idx++;
                if (min_size < data_idx)
                {
                    data_idx = min_size;
                }
                LCD_Putstr (data_buf + data_idx);
                // Clean up
                min_size = DATA_BUF_LEN-1;
                alt_p_c = FALSE;
                long_flag = FALSE;
                break;  // case 'u':
                
            case 'x':
            case 'X':
                for(data_idx = 0; data_idx < (DATA_BUF_LEN-1); data_idx++)
                {
                    data_buf[data_idx] = '0';
                }
                data_buf[DATA_BUF_LEN-1] = 0;
                data_idx = DATA_BUF_LEN - 2;
                if (long_flag)  // 32-bit
                { 
                    u32_val = va_arg(arg_ptr, U32);
                    while (u32_val)
                    {
                        u8_temp = (U8)(u32_val & 0x0F);
                        data_buf[data_idx] = (u8_temp < 10)? u8_temp+'0':u8_temp-10+(*p=='x'?'a':'A');
                        u32_val >>= 4;
                        data_idx--;
                    }
                }
                else  // 16-bit
                {
                    u16_val = (U16)(va_arg(arg_ptr, int)); // u16_val = va_arg(arg_ptr, U16);
                    while (u16_val)
                    {
                        u8_temp = (U8)(u16_val & 0x0F);
                        data_buf[data_idx] = (u8_temp < 10)? u8_temp+'0':u8_temp-10+(*p=='x'?'a':'A');
                        u16_val >>= 4;
                        data_idx--;
                    }
                }
                data_idx++;
                if (min_size < data_idx)
                {
                    data_idx = min_size;
                }
                LCD_Putstr (data_buf + data_idx);
                // Clean up
                min_size = DATA_BUF_LEN-1;
                alt_p_c = FALSE;
                long_flag = FALSE;
                break;  // case 'x' & 'X'
                
            case '0':   // Max allowed "min_size" 2 decimal digit, truncated to DATA_BUF_LEN-1.
                min_size = DATA_BUF_LEN-1;
                if (long_flag == TRUE)      // ERROR: 'l' before '0'
                {
                    LCD_Putchar('l');
                    LCD_Putchar('0');
                    // Clean up
                    alt_p_c = FALSE;
                    long_flag = FALSE;
                    break;
                }
                u8_temp = *++p;
                if ((u8_temp >='0') && (u8_temp <='9'))
                {
                    min_size = u8_temp & 0x0F;
                    u8_temp = *++p;
                    if ((u8_temp >='0') && (u8_temp <='9'))
                    {
                        min_size <<= 4;
                        min_size |= (u8_temp & 0x0F);
                        p++;
                    }
                    min_size = ((min_size & 0x0F) + ((min_size >> 4) *10));  // Decimal to hexa
                    if (min_size > (DATA_BUF_LEN-1))
                    {
                        min_size = (DATA_BUF_LEN-1);
                    }  // Truncation
                    min_size = DATA_BUF_LEN-1 - min_size;  // "min_size" formatted as "data_ix"
                }
                else      // ERROR: any "char" after '0'
                {
                    LCD_Putchar('0');
                    LCD_Putchar(*p);
                    // Clean up
                    alt_p_c = FALSE;
                    long_flag = FALSE;
                    break;
                }
                p-=2;
                alt_p_c = TRUE;
                // Clean up
                long_flag = FALSE;
                break;  // case '0'  
            default:
                if (long_flag == TRUE)
                {
                    LCD_Putchar('l');
                }
                LCD_Putchar(*p);
                // Clean up
                min_size = DATA_BUF_LEN-1;
                alt_p_c = FALSE;
                long_flag = FALSE;
                break;  // default
                
        }   // switch (*p ...
        
    }   // for (p = ...
    
    va_end(arg_ptr);
    return 0;
}