DokuWiki

Key Pad 를 이용해 image file 을 읽어 화면에 출력 하거나 그림을 그리고 글자를 출력한다. 한글을 사용하기 위해서는 UTF-8로 작성되어야 한다.

TODO : Touch screen

Source Code

/*	Application Action
Key		: Test Action
F1		: make Blue Screen
F2		: Display VI_logo.bmp
F3		: Display String..
F4		: Clear Screen
ENTER	: Exit App
*/

#include	<stdio.h>
#include	<stdint.h>
#include	<string.h>		/* for memset */
#include	<unistd.h>		/* for open/close .. */
#include	<fcntl.h>		/* for O_RDWR */
#include	<sys/ioctl.h>	/* for ioctl */
#include	<sys/mman.h>	/* for mmap */
#include	<linux/fb.h>	/* for fb_var_screeninfo, FBIOGET_VSCREENINFO */
#include	<linux/input.h>
#include	<poll.h>
#include	"SDL.h"
#include	"SDL_ttf.h"

#define	DEV_LCD_BACKLIGHT			"/sys/class/backlight/backlight/brightness"

#define	TEST_IMAGE_FILE_1			"VI_logo_320_240_R90.jpg"
#define	TEST_IMAGE_FILE_2			"VI_logo_320_240_R270.jpg"
#define	TEST_FONT_FILE				"D2Coding.ttf"
#define	TEST_DISPLAY_STRING			"밸류이노베이션"
//#define	TEST_DISPLAY_STRING			"VI"

/*
#define	DEBUG_LOW_LEVEL_KEY_INPUT_INFO
*/
int	sdl_copy_surface( SDL_Surface *pDestination, int X, int Y, SDL_Surface *pSource )
{
	int			Result;
	SDL_Rect	Offset;	/* Make a temporary rectangle to hold the offsets */

	Result = -1;
	if ( ( pDestination != (SDL_Surface *)0 )
	 &&	( pSource != (SDL_Surface *)0 ) )
	{
		/* Give the offsets to the rectangle */
		Offset.x = X;
		Offset.y = Y;
		/* Blit the surface */
		Result = SDL_BlitSurface( pSource, NULL, pDestination, &Offset );
	}
	return	Result;
}

int	sdl_clear_surface( SDL_Surface *pDestination )
{
	if ( pDestination != (SDL_Surface *)0 )
	{
		if ( SDL_FillRect(pDestination, NULL, SDL_MapRGB(pDestination->format, 0, 0, 0)) < 0)
		{
			printf("clear surface fail! : %s\n", SDL_GetError());
		}
		else
		{
			printf("clear surface OK\n");
			SDL_Flip( pDestination );
		}
	}
}

int	bright_set(const uint8_t Brightness)
{
	FILE *	pDeviceFile;
	char	pString[10] = {0};
	int		StringLength;

	pDeviceFile = fopen(DEV_LCD_BACKLIGHT, "w+");
	if ( pDeviceFile == (FILE *)0 )
	{
		printf("failed to open back light device : %s\n", DEV_LCD_BACKLIGHT);
		return	-1;
	}

	sprintf(pString, "%d", Brightness);
	StringLength = (int)strlen(pString);

	if ( fwrite(pString, StringLength, 1, pDeviceFile) < 0 )
	{
		return	-1;
	}

	fclose(pDeviceFile);

	return	0;
}

int bright_get(uint8_t *pBrightness)
{
	FILE *	pDeviceFile;
	char	pCommand[128] = {0};
	char	pString[10] = {0};

	char buf[10] = {0};
	int level = 0;

	if ( pBrightness == (uint8_t *)0 )
	{
		printf("bright_get : Input Parameter error\n");
		return	-1;
	}

	sprintf(pCommand, "cat %s", DEV_LCD_BACKLIGHT);
	pDeviceFile = popen(pCommand, "r");
	if ( pDeviceFile == (FILE *)0 )
	{
		return	-1;
	}

	while( fgets(pString, 10, pDeviceFile) );
	*pBrightness = (uint8_t)strtoul(pString, NULL, 10);

	fclose(pDeviceFile);

	return	0;
}


int	main()
{
	SDL_Surface *	pScreen;
	SDL_Event		Event;
	char *			pGetENV;

#if	1
	pGetENV = SDL_getenv("SDL_VIDEODRIVER");
	if( pGetENV == (char *)0 )
	{
		printf("No ENV!\n");
		SDL_putenv("SDL_VIDEODRIVER=directfb");
	}
//	else
//	{
		printf("SDL_VIDEODRIVER=%s\n",SDL_getenv("SDL_VIDEODRIVER"));
//	}

#endif

	if ( SDL_Init(SDL_INIT_VIDEO) < 0)
	{
		printf("SDL initialized Fail! : %s\n", SDL_GetError());
		return	-1;
	}
	else
	{
		printf("SDL initialized OK!\n");
	}

	pScreen = SDL_SetVideoMode(240, 320, 32, SDL_SWSURFACE);
	if( pScreen == (SDL_Surface *)0 )
	{
		printf("Fail to SetVideoMode !\n");
	}
	else
	{
		SDL_KeyboardEvent *	pKeyEvent;
		int					IsInLoop;
		uint8_t				Brightness;

		printf("Screen SDL SetVideoMode OK\n");

		printf("SDL Surface Address = 0x%X(%d)\n", (uint32_t)pScreen, (uint32_t)pScreen);
		printf("  flags          : 0x%08X\n", pScreen->flags);
//		SDL_PixelFormat *format;		/**< Read-only */
		printf("  w              : %d\n", pScreen->w);
		printf("  h              : %d\n", pScreen->h);
		printf("  pitch          : %d\n", pScreen->pitch);
		printf("  *pixels        : 0x%X(%d)\n", (uint32_t)pScreen->pixels, (uint32_t)pScreen->pixels);
		printf("  offset         : 0x%X(%d)\n", (uint32_t)pScreen->offset, (uint32_t)pScreen->offset);
//		struct private_hwdata *hwdata;		/** Hardware-specific surface info */
		/** clipping information */
//		SDL_Rect clip_rect;			/**< Read-only */
		/** Allow recursive locks */
		printf("  locked         : 0x%X(%d)\n", (uint32_t)pScreen->locked, (uint32_t)pScreen->locked);
		Uint32 locked;				/**< Private */
		/** info for fast blit mapping to other surfaces */
//		struct SDL_BlitMap *map;		/**< Private */
		/** format version, bumped at every change to invalidate blit maps */
		printf("  format_version : 0x%X(%d)\n", (uint32_t)pScreen->format_version, (uint32_t)pScreen->format_version);
		/** Reference count -- used when freeing surface */
		printf("  refcount       : 0x%X(%d)\n", (uint32_t)pScreen->refcount, (uint32_t)pScreen->refcount);

		SDL_ShowCursor(SDL_DISABLE/* SDL_ENABLE or SDL_DISABLE */);
		/* Must be clear action before doing other actions.. */
		sdl_clear_surface( pScreen );
//		SDL_Delay(1000/*ms*/);
//		sdl_clear_surface( pScreen );

		IsInLoop = 1;
		/* Start event loop */  
		while (IsInLoop)
		{
			if ( SDL_PollEvent( &Event ) == 0)	/* While there's an event to handle */
			{
				continue;
			}

			if ( ( Event.type == SDL_KEYDOWN ) || ( Event.type == SDL_KEYUP ) )
			{	/* Keys pressed or reased */
				pKeyEvent = (SDL_KeyboardEvent *)&Event;
				switch ( pKeyEvent->keysym.sym )
				{
				case	SDLK_BACKSPACE:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - BACKSPACE\n");
					}
					else
					{
						printf("SDL Event Keys release! - BACKSPACE\n");
					}
					break;
				case	SDLK_RETURN:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - RETURN\n");
					}
					else
					{
						printf("SDL Event Keys release! - RETURN\n");
						IsInLoop = 0;
					}
					break;
				case	SDLK_0:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 0\n");
					}
					else
					{
						printf("SDL Event Keys release! - 0\n");
					}
					break;
				case	SDLK_1:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 1\n");
					}
					else
					{
						printf("SDL Event Keys release! - 1\n");
					}
					break;
				case	SDLK_2:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 2\n");
					}
					else
					{
						printf("SDL Event Keys release! - 2\n");
					}
					break;
				case	SDLK_3:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 3\n");
					}
					else
					{
						printf("SDL Event Keys release! - 3\n");
					}
					break;
				case	SDLK_4:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 4\n");
					}
					else
					{
						printf("SDL Event Keys release! - 4\n");
					}
					break;
				case	SDLK_5:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 5\n");
					}
					else
					{
						printf("SDL Event Keys release! - 5\n");
					}
					break;
				case	SDLK_6:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 6\n");
					}
					else
					{
						printf("SDL Event Keys release! - 6\n");
					}
					break;
				case	SDLK_7:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 7\n");
					}
					else
					{
						printf("SDL Event Keys release! - 7\n");
					}
					break;
				case	SDLK_8:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 8\n");
					}
					else
					{
						printf("SDL Event Keys release! - 8\n");
					}
					break;
				case	SDLK_9:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - 9\n");
					}
					else
					{
						printf("SDL Event Keys release! - 9\n");
					}
					break;
				case	SDLK_F1:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F1\n");
					}
					else
					{
						printf("SDL Event Keys release! - F1\n");
						if ( SDL_FillRect(pScreen, NULL, SDL_MapRGB(pScreen->format, 255/*B*/, 0/*G*/, 0/*R*/)) < 0)
						{
							printf("SDL_FillRect Fail! : %s\n", SDL_GetError());
						}
						else
						{
							printf("SDL_FillRect OK\n");
							SDL_Flip( pScreen );
						}
					}
					break;
				case	SDLK_F2:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F2\n");
					}
					else
					{
						SDL_Surface *	pBMP;
						printf("SDL Event Keys release! - F2\n");

						pBMP = SDL_LoadBMP("logo.bmp");
						if( pBMP == (SDL_Surface *)0 )
						{
							printf("Fail to SDL_LoadBMP !\n");
						}
						else
						{
							printf("BMP SDL LoadBMP OK\n");

							printf("BMP Surface Address = 0x%X(%d)\n", (uint32_t)pBMP, (uint32_t)pBMP);
							printf("  flags          : 0x%08X\n", pBMP->flags);
						//	SDL_PixelFormat *format;		/**< Read-only */
							printf("  w              : %d\n", pBMP->w);
							printf("  h              : %d\n", pBMP->h);
							printf("  pitch          : %d\n", pBMP->pitch);
							printf("  *pixels        : 0x%X(%d)\n", (uint32_t)pBMP->pixels, (uint32_t)pBMP->pixels);
							printf("  offset         : 0x%X(%d)\n", (uint32_t)pBMP->offset, (uint32_t)pBMP->offset);
						//	struct private_hwdata *hwdata;		/** Hardware-specific surface info */
							/** clipping information */
						//	SDL_Rect clip_rect;			/**< Read-only */
							/** Allow recursive locks */
							printf("  locked         : 0x%X(%d)\n", (uint32_t)pBMP->locked, (uint32_t)pBMP->locked);
							Uint32 locked;				/**< Private */
							/** info for fast blit mapping to other surfaces */
						//	struct SDL_BlitMap *map;		/**< Private */
							/** format version, bumped at every change to invalidate blit maps */
							printf("  format_version : 0x%X(%d)\n", (uint32_t)pBMP->format_version, (uint32_t)pBMP->format_version);
							/** Reference count -- used when freeing surface */
							printf("  refcount       : 0x%X(%d)\n", (uint32_t)pBMP->refcount, (uint32_t)pBMP->refcount);

						//	SDL_BlitSurface( pBMP, NULL, pScreen, NULL );
							sdl_copy_surface( pScreen, 0/*X*/, 0/*Y*/, pBMP );

						    // 화면을 갱신
							SDL_Flip( pScreen );
							SDL_FreeSurface( pBMP );
						}
					}
					break;
				case	SDLK_F3:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F3\n");
					}
					else
					{
						SDL_Surface *	pText;
						TTF_Font *		pFont;
						SDL_Color		pTextColor = { 255, 255, 255 };	/* The color of the font */

						printf("SDL Event Keys release! - F3\n");

						if( TTF_Init() < 0 )
						{
							printf("Fail to TTF_Init !\n");
						}
						else
						{
							printf("OK to TTF_Init !\n");
							/* Open the font */
							pFont = TTF_OpenFont( TEST_FONT_FILE, 28 );
						    /* If there was an error in loading the font */
						    if( pFont == (TTF_Font *)0 )
						    {
								printf("Fail to TTF_OpenFont !\n");
						    }
							else
							{
								printf("OK to TTF_OpenFont !\n");

								/* 한글 출력을 위해 TTF_RenderUTF8_Solid 사용 */
								/* For display HanGul using TTF_RenderUTF8_Solid */
								pText = TTF_RenderUTF8_Solid( pFont, TEST_DISPLAY_STRING, pTextColor );	/* Render the text */
/*
TTF_RenderText_Solid	  	Draw LATIN1 text in solid mode
TTF_RenderUTF8_Solid	  	Draw UTF8 text in solid mode
TTF_RenderUNICODE_Solid	  	Draw UNICODE text in solid mode
TTF_RenderGlyph_Solid	  	Draw a UNICODE glyph in solid mode
*/
								/* If there was an error in rendering the text */
								if( pText == (SDL_Surface *)0 )
								{
									printf("Fail to TTF_RenderText_Solid !\n");
								}
								else
								{
									printf("OK to TTF_RenderText_Solid !\n");

									/* Apply the images to the screen */
									sdl_copy_surface( pScreen, 0/*X*/, 150/*Y*/, pText );
								    /* Update the screen */
									SDL_Flip( pScreen );

									/* Free the text surface */
									SDL_FreeSurface( pText );
								}
								/* Close the font that was used */
								TTF_CloseFont( pFont );
							}
							/* Quit SDL_ttf */
							TTF_Quit();
						}
					}
					break;
				case	SDLK_F4:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F4\n");
					}
					else
					{
						printf("SDL Event Keys release! - F4\n");
						if ( sdl_clear_surface( pScreen ) != 0 )
						{
							printf("clar scrren fail\n");
						}
						else
						{
							printf("clar scrren OK\n");
						}
					}
					break;
				case	SDLK_F5:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F5\n");
					}
					else
					{
						printf("SDL Event Keys release! - F5\n");
					}
					break;
				case	SDLK_F6:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F6\n");
					}
					else
					{
						printf("SDL Event Keys release! - F6\n");
						if( Brightness != 7 )
						{
							Brightness ++;
							if( bright_set(Brightness) != 0 )
							{
								printf("Fail to bright_set\n");
							}
							printf("bright -\n");
						}
					}
					break;
				case	SDLK_F7:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - F7\n");
					}
					else
					{
						printf("SDL Event Keys release! - F7\n");
						if( Brightness != 0 )
						{
							Brightness --;
							if( bright_set(Brightness) != 0 )
							{
								printf("Fail to bright_set\n");
							}
							printf("bright +\n");
						}
					}
					break;
				default:
					if ( Event.type == SDL_KEYDOWN )
					{
						printf("SDL Event Keys pressed! - ??\n");
					}
					else
					{
						printf("SDL Event Keys release! - ??\n");
					}
					break;
				}
#ifdef	DEBUG_LOW_LEVEL_KEY_INPUT_INFO
				printf(" The keyboard device index = %d\n", pKeyEvent->which);
				printf(" The SDL_PRESSED or SDL_RELEASED = %d\n", pKeyEvent->state);
				printf(" hardware specific scancode = %d\n", pKeyEvent->keysym.scancode);
				printf(" SDL virtual keysym = %d\n", pKeyEvent->keysym.sym);
				printf(" current key modifiers = %d\n", pKeyEvent->keysym.mod);
				printf(" translated character = %d\n", pKeyEvent->keysym.unicode);
#endif
			}
			else
			{
				switch (Event.type)
				{
				case	SDL_ACTIVEEVENT:	/**< Application loses/gains visibility */
					printf("SDL Event Application loses/gains visibility!\n");
					break;
				case	SDL_KEYDOWN:		/**< Keys pressed */
					printf("SDL Event Keys pressed!\n");
					break;
				case	SDL_KEYUP:			/**< Keys released */
					printf("SDL Event Keys released!\n");
					break;
				case	SDL_MOUSEMOTION:	/**< Mouse moved */
					printf("SDL Event Mouse moved!\n");
					break;
				case	SDL_MOUSEBUTTONDOWN:/**< Mouse button pressed */
					printf("SDL Event Mouse button pressed!\n");
					break;
				case	SDL_MOUSEBUTTONUP:	/**< Mouse button released */
					printf("SDL Event Mouse button released!\n");
					break;
				case	SDL_JOYAXISMOTION:	/**< Joystick axis motion */
					printf("SDL Event Joystick axis motion!\n");
					break;
				case	SDL_JOYBALLMOTION:	/**< Joystick trackball motion */
					printf("SDL Event Joystick trackball motion!\n");
					break;
				case	SDL_JOYHATMOTION:	/**< Joystick hat position change */
					printf("SDL Event Joystick hat position change!\n");
					break;
				case	SDL_JOYBUTTONDOWN:	/**< Joystick button pressed */
					printf("SDL Event Joystick button pressed!\n");
					break;
				case	SDL_JOYBUTTONUP:	/**< Joystick button released */
					printf("SDL Event Joystick button released!\n");
					break;
				case	SDL_QUIT:			/**< User-requested quit */
					printf("SDL Event User-requested quit!\n");
					break;
				case	SDL_SYSWMEVENT:		/**< System specific event */
					printf("SDL Event System specific!\n");
					break;
				case	SDL_EVENT_RESERVEDA:/**< Reserved for future use.. */
					printf("SDL Event reserved!\n");
					break;
				case	SDL_EVENT_RESERVEDB:/**< Reserved for future use.. */
					printf("SDL Event reserved!\n");
					break;
				case	SDL_VIDEORESIZE:	/**< User resized video mode */
					printf("SDL Event User resized video mode!\n");
					break;
				case	SDL_VIDEOEXPOSE:	/**< Screen needs to be redrawn */
					printf("SDL Event Screen needs to be redrawn!\n");
					break;
				case	SDL_EVENT_RESERVED2:/**< Reserved for future use.. */
				case	SDL_EVENT_RESERVED3:/**< Reserved for future use.. */
				case	SDL_EVENT_RESERVED4:/**< Reserved for future use.. */
				case	SDL_EVENT_RESERVED5:/**< Reserved for future use.. */
				case	SDL_EVENT_RESERVED6:/**< Reserved for future use.. */
				case	SDL_EVENT_RESERVED7:/**< Reserved for future use.. */
					printf("SDL Event reserved!\n");
					break;
				case	SDL_USEREVENT:
					printf("SDL Event user!\n");
					break;
				default:
					printf("SDL Event unknown!\n");
					break;
				}
			}
		}

		SDL_FreeSurface( pScreen );
	}

	SDL_Quit();
	return	0;
}

make