Esempio n. 1
0
void u8g_DrawEllipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t xr, u8g_uint_t yr)
{
	u8g_DrawPixel(u8g, x0, y0+yr);
	u8g_DrawPixel(u8g, x0, y0-yr);
	u8g_DrawPixel(u8g, x0+xr, y0);
	u8g_DrawPixel(u8g, x0-xr, y0);
}
Esempio n. 2
0
static void u8g_draw_ellipse_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option)
{
    /* upper right */
    if ( option & U8G_DRAW_UPPER_RIGHT )
    {
      u8g_DrawPixel(u8g, x0 + x, y0 - y);
    }
    
    /* upper left */
    if ( option & U8G_DRAW_UPPER_LEFT )
    {
      u8g_DrawPixel(u8g, x0 - x, y0 - y);
    }
    
    /* lower right */
    if ( option & U8G_DRAW_LOWER_RIGHT )
    {
      u8g_DrawPixel(u8g, x0 + x, y0 + y);
    }
    
    /* lower left */
    if ( option & U8G_DRAW_LOWER_LEFT )
    {
      u8g_DrawPixel(u8g, x0 - x, y0 + y);
    }
}
Esempio n. 3
0
void glyph(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, uint8_t encoding)
{
  char s[2] = ".";
  u8g_GetGlyph(u8g, encoding);
  s[0] = encoding;
  u8g_DrawStr(u8g, x, y, "öÄ");
  u8g_DrawPixel(u8g, x, y);
  u8g_DrawPixel(u8g, x-1, y);
  //u8g_DrawPixel(u8g, x, y-u8g->glyph_y);
}
Esempio n. 4
0
int main(void)
{
  u8g_t u8g;
  
  u8g_Init(&u8g, &u8g_dev_sdl_1bit_h);
  u8g_FirstPage(&u8g);
  do
  {
    u8g_SetColorIndex(&u8g, 1);
    u8g_DrawPixel(&u8g,0,0);
    u8g_DrawPixel(&u8g,0,1);
    u8g_SetFont(&u8g, u8g_font_unifont);
    //u8g_SetFont(&u8g, u8g_font_10x20);
    //u8g_SetFont(&u8g, u8g_font_gdb17);
    u8g_SetFontRefHeightText(&u8g);
    //u8g_SetRefHeightAll(&u8g);
    
    //u8g_SetFontPosBaseline(&u8g);
    //u8g_SetFontPosCenter(&u8g);
    
    u8g_SetFontPosTop(&u8g);
    glyph(&u8g, 5,25, 'g');

    u8g_SetFontPosCenter(&u8g);
    glyph(&u8g, 5+25,25, 'g');
    
    u8g_SetFontPosBaseline(&u8g);
    glyph(&u8g, 5+2*25,25, 'g');

    u8g_SetFontPosBottom(&u8g);
    glyph(&u8g, 5+3*25,25, 'g');
    
  }while( u8g_NextPage(&u8g) );
  
  while( u8g_sdl_get_key() < 0 )
    ;
  
  return 0;
}
Esempio n. 5
0
void draw_color_box3(void)
{
    u8g_uint_t r, g, b;
    /* assumes 128x128 display */
    for( b = 0; b < 4; b++ )
    {
      for( g = 0; g < 32; g++ )
      {
	for( r = 0; r < 32; r++ )
	{
	  u8g_SetRGB(&u8g, r<<3, g<<3, b<<4 );
	  u8g_DrawPixel(&u8g, g + b*32, r);
	  u8g_SetRGB(&u8g, r<<3, g<<3, (b<<4)+64 );
	  u8g_DrawPixel(&u8g, g + b*32, r+32);
	  u8g_SetRGB(&u8g, r<<3, g<<3, (b<<4)+128 );
	  u8g_DrawPixel(&u8g, g + b*32, r+32+32);
	  u8g_SetRGB(&u8g, r<<3, g<<3, (b<<4)+128+64 );
	  u8g_DrawPixel(&u8g, g + b*32, r+32+32+32);
	}
      }
    }
}
Esempio n. 6
0
// Lua: u8g.drawPixel( self, x, y )
static int lu8g_drawPixel( lua_State *L )
{
    lu8g_userdata_t *lud;

    if ((lud = get_lud( L )) == NULL)
        return 0;

    u8g_uint_t args[2];
    lu8g_get_int_args( L, 2, 2, args );

    u8g_DrawPixel( LU8G, args[0], args[1] );

    return 0;
}
Esempio n. 7
0
void draw(void) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g_SetFont(&u8g, u8g_font_helvR08);
  u8g_SetFontPosTop(&u8g);
  
  u8g_DrawStr( &u8g, 0, 0, "Hello World!");

  // Try with/ without below lines

  u8g_SetFont(&u8g, u8g_font_profont11);
  u8g_SetFontPosTop(&u8g);
  u8g_DrawStr( &u8g, 32, 25, "see yah!");
  u8g_DrawPixel(&u8g, 32, 25);
}
Esempio n. 8
0
void u8g_DrawEllipseRect(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t x1, u8g_uint_t y1)
{
	int a = abs(x1 - x0);
	int b = abs(y1 - y0);	//get diameters
	int b1 = b&1;
	long dx = 4*(1-a)*b*b;
	long dy = 4*(b1+1)*a*a;
	long err = dx+dy+b1*a*a;
	long e2;
	
	if (x0 > x1) { x0 = x1; x1 += a; }
	if (y0 > y1) { y0 = y1; } 
	y0 += (b+1)/2;
	y1 = y0-b1;
	a *= 8*a;
	b1 = 8*b*b;
	
	do {
		u8g_DrawPixel(u8g, x1, y0);
		u8g_DrawPixel(u8g, x0, y0);
		u8g_DrawPixel(u8g, x0, y1);
		u8g_DrawPixel(u8g, x1, y1);
		e2 = 2*err;
		if (e2 >= dx) {
			x0++;
			x1--;
			err += dx += b1;
		}
		if (e2 <= dy) {
			y0++;
			y1--;
			err += dy += a;
		}
	} while (x0 <= x1);
	
	while (y0-y1 < b) {
		u8g_DrawPixel(u8g, x0-1, y0);
		u8g_DrawPixel(u8g, x1+1, y0++);
		u8g_DrawPixel(u8g, x0-1, y1);
		u8g_DrawPixel(u8g, x1+1, y1--);
	}
}
Esempio n. 9
0
static void u8g_DrawHXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const uint8_t *bitmap)
{
  uint8_t d;
  x+=7;
  while( w >= 8 )
  {
    u8g_Draw8Pixel(u8g, x, y, 2, *bitmap);
    bitmap++;
    w-= 8;
    x+=8;
  }
  if ( w > 0 )
  {
    d = *bitmap;
    x -= 7;
    do
    {
      if ( d & 1 )
        u8g_DrawPixel(u8g, x, y);
      x++;
      w--;
      d >>= 1;      
    } while ( w > 0 );
  }
Esempio n. 10
0
void dog_ClrPixel(uint8_t x, uint8_t y)
{
  y = dog_height_minus_one - y;
  u8g_SetColorIndex(&u8g_dogm128_obj, 0);
  u8g_DrawPixel(&u8g_dogm128_obj, x, y);  
}
Esempio n. 11
0
void u8g_DrawEmpCirc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
{
  if ( u8g_IsBBXIntersection(u8g, x0-rad-1, y0-rad-1, 2*rad+1, 2*rad+1) == 0)
    return;

  int f = 1 - rad;
  int ddF_x = 1;
  int ddF_y = -2*rad;
  uint8_t x = 0;
  uint8_t y = rad;

  void ( *circ_util )(u8g_t *, u8g_uint_t, u8g_uint_t, u8g_uint_t, u8g_uint_t);
  
  switch (option)
  {
	case U8G_CIRC_UPPER_RIGHT:
		u8g_DrawPixel(u8g, x0, y0 - rad);
		u8g_DrawPixel(u8g, x0 + rad, y0);
		circ_util = circ_upperRight;
		break;
	case U8G_CIRC_UPPER_LEFT:
		u8g_DrawPixel(u8g, x0, y0 - rad);
		u8g_DrawPixel(u8g, x0 - rad, y0);
		circ_util = circ_upperLeft;
		break;
	case U8G_CIRC_LOWER_RIGHT:
		u8g_DrawPixel(u8g, x0, y0 + rad);
		u8g_DrawPixel(u8g, x0 + rad, y0);
		circ_util = circ_lowerRight;
		break;
	case U8G_CIRC_LOWER_LEFT:
		u8g_DrawPixel(u8g, x0, y0 + rad);
		u8g_DrawPixel(u8g, x0 - rad, y0);
		circ_util = circ_lowerLeft;
		break;
        default:
	case U8G_CIRC_ALL:
		u8g_DrawPixel(u8g, x0, y0 + rad);
		u8g_DrawPixel(u8g, x0, y0 - rad);
		u8g_DrawPixel(u8g, x0 + rad, y0);
		u8g_DrawPixel(u8g, x0 - rad, y0);
		circ_util = circ_all;
		break;
  }
  
  while( x < y )
  {
    if(f >= 0) 
    {
      y--;
      ddF_y += 2;
      f += ddF_y;
    }
    x++;
    ddF_x += 2;
    f += ddF_x;
    
    circ_util(u8g, x, y, x0, y0);
  }
}
Esempio n. 12
0
void circ_lowerLeft(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
  u8g_DrawPixel(u8g, x0 - x, y0 + y);
  u8g_DrawPixel(u8g, x0 - y, y0 + x);
}
Esempio n. 13
0
void circ_lowerRight(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
  u8g_DrawPixel(u8g, x0 + x, y0 + y);
  u8g_DrawPixel(u8g, x0 + y, y0 + x);
}
Esempio n. 14
0
void circ_upperLeft(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
  u8g_DrawPixel(u8g, x0 - x, y0 - y);
  u8g_DrawPixel(u8g, x0 - y, y0 - x);
}
Esempio n. 15
0
void circ_upperRight(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
  u8g_DrawPixel(u8g, x0 + x, y0 - y);
  u8g_DrawPixel(u8g, x0 + y, y0 - x);
}
Esempio n. 16
0
void u8g_DrawInfo(void) //Malen der Batterie, Anzeige in %
{
    ///////Infos////  X  /////////
    //  Karte   //Pfeil// Frei  //
    //  akt.    //     // hier: //
    //  Raum    /////////       //
    //          //Info //       //
    //          //Karte//       //
    //////////////////////////////

    u8g_DrawHLine(&u8g, 0, 6, 128); //Horizontale Abgrenzungslinie

    u8g_SetFont(&u8g, u8g_font_4x6); //Schriftart

    //////Batterie////////////
    u8g_DrawFrame(&u8g, 0, 0, 10, 5); //Batteriekörper
    u8g_DrawPixel(&u8g, 10, 2);
    int8_t batt_volumeVar = batt_percent/11; //Berechnung Füllung
    if(batt_volumeVar > 8)
        batt_volumeVar = 8;
    if(batt_volumeVar < 0)
        batt_volumeVar = 0;
    u8g_DrawBox(&u8g, 1, 1, batt_volumeVar, 3); //Füllung

    //Anzeige daneben
    u8g_DrawLong(15,	5, batt_percent);
    u8g_DrawStr(&u8g, 25, 	5, "%");

    //Fehleranzeige daneben:
    if(timer_disp_msg == 0)
    {
        disp_msg_i ++;
        if(disp_msg_i == DISP_MSG_I_TOP)
        {
            disp_msg_i = 0;
            if(!(is_msg & (1<<1)))
            {
                which_msg = 0;
            }
            else
            {
                is_msg &= ~ (1<<1);
            }
        }
        is_msg &= ~ (1<<0);
    }

    switch(disp_msg_i)
    {
    case 0:
        if(batt_percent < 20)
        {
            set_msg();
        }
        break;
    case 1:
        if((check_srf & (1<<0)) ||
                (check_srf & (1<<1)) ||
                (check_srf & (1<<2)) ||
                (check_srf & (1<<3)))
        {
            set_msg();
        }
        break;
    case 2:
        if((check_srf & (1<<4)) ||
                (check_srf & (1<<5)) ||
                (check_srf & (1<<6)) ||
                (check_srf & (1<<7)))
        {
            set_msg();
        }
        break;
    case 3:
        if((check_srf & (1<<8)) ||
                (check_srf & (1<<9)) ||
                (check_srf & (1<<10)) ||
                (check_srf & (1<<11)))
        {
            set_msg();
        }
        break;
    case 4:
        if((check_srf & (1<<12)) ||
                (check_srf & (1<<13)) ||
                (check_srf & (1<<14)) ||
                (check_srf & (1<<15)))
        {
            set_msg();
        }
        break;
    case 5:
        if(check_mlx & (1<<0))
        {
            set_msg();
        }
        break;
    case 6:
        if(check_mlx & (1<<1))
        {
            set_msg();
        }
        break;
    case 7:
        if((check_um6 & (1<<0)) ||
                (check_um6 & (1<<1)))
        {
            set_msg();
        }
        break;
    case 8:
        if(motor_off)
        {
            set_msg();
        }
        break;
    case 9:
        if(timer_bt_is_busy > 0)
        {
            set_msg();
        }
        break;
    case 10:
        if(setup)
        {
            set_msg();
        }
        break;
    case 11:
        if(check_um6 & (1<<2))
        {
            set_msg();
        }
    case 12:
        if(!use_map)
        {
            set_msg();
        }
        break;
    }
    u8g_DrawStr(&u8g, 35, 	5, disp_msg[which_msg]);
}