C++ display_init函数代码示例

static int wmt_display_main (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
	int tmp;

	switch (argc) {
		case 0:
		case 1:	
			printf ("Usage:\n%s\n", cmdtp->usage);
		return 0;
		default:
			if (strncmp(argv[1], "init", 2) == 0) {
				if (argc == 3) {
					if (strcmp(argv[2], "force") == 0) {
						display_init(1, 1);
						return 0;
					}
				}
				display_init(1, 0);
				return 0;
			}
			if (strncmp(argv[1], "clear", 2) == 0) {
				display_clear();
				return 0;
			}
			if (strncmp(argv[1], "show", 2) == 0) {
                if (4 == argc) {
			        g_logo_x = simple_strtoul(argv[2], NULL, 10);
			        g_logo_y = simple_strtoul(argv[3], NULL, 10);
                    printf("(%d, %d) ", g_logo_x, g_logo_y);
                } else {
                    g_logo_x = -1;
                    g_logo_y = -1;
                }
                display_show(0);
				return 0;
			}
			if (strncmp(argv[1], "setpwm", 2) == 0) {
				if (argc == 3) {
					if (argv[2] != NULL) {
						display_set_pwm(argv[2], 1);
						return 0;
					}
				} else if (argc == 4) {
					tmp = simple_strtoul(argv[2], NULL, 10);
					if (argv[3] != NULL) {
						display_set_pwm(argv[3], tmp);
						return 0;
					}
				}
			}
			printf ("Usage:\n%s\n", cmdtp->usage);
			return 0;
	}
	return 0;
}

int main(void) {
  sei(); // enable interrupts
  leds_init();
  pwm_init();
  bot_init();
  i2c_init();

  if (display_init()!=0) {
    leds_set_displaylight(50);
    if (display_type==2) {
      gfx_init();
    }
  }
  
  gfx_fill(0x00);
  gfx_move(15, 0);
  gfx_set_proportional(1);
  gfx_print_text("nibo");
  gfx_set_proportional(0);

  uint8_t pos=0;
  uint8_t state=0;

  gfx_term_print("Move 0\n");
  nds3_move(0);
  while (nds3_get_busy()) {
    delay(1);
  }
  
  while (1) {
    gfx_draw_mode(GFX_DM_JAM2);

    check_voltage();

   
    //gfx_term_print("Measure 90, 15\n");
      delay(1);
    nds3_measure(180, 1);
    while (nds3_get_busy()) {
      delay(1);
    }

      delay(1);
    //gfx_term_print("Read -90, 15\n");
    do_plot();

      delay(1);
    nds3_measure(0, 1);
    while (nds3_get_busy()) {
      delay(1);
    }

      delay(1);
    //gfx_term_print("Read 90, 15\n");
    nds3_read(0, 15);
    do_plot();
    
    
  }
}

//**************************************************************
// main()
//**************************************************************
int main(){
#define Adresse 0x9E			// evtl 9F für schreiben?
#define	Read	1
#define Write	0
	unsigned char ucTemp1,ucTemp2;			// Deklaration der Variablen

	display_init();							// Initialisiere Display

	int i;
	while(1) {
		signed int avg = 0;
		for(i = 0; i < 64; i++) {
			// Setzen der Startbedingung und warten bis slave antwortet mit ACK0
			while(i2c_start(Adresse+Read));
			ucTemp1 = i2c_rbyte(0);					// Erstes Byte einlesen
			ucTemp2 = i2c_rbyte(1);					// Zweites Byte einlesen
			i2c_stop();								// I2C wieder freigeben

			// Ausgabe der gelesenen Werte

			display_set_cursor(0, 0);
			print_temp(tempwert(ucTemp1, ucTemp2));
			avg += tempwert(ucTemp1, ucTemp2);
			delay5ms(100);							// Verzögerung 100 ms
		}
		display_set_cursor(0, 1);
		print_temp(avg >> 6);
	}
	while(1);								// Endlosschleife
}

/* main */ 
int main(void)
{
    /* initialise kernel */ 
    si_kernel_init(); 
    
    /* initialise UI channel */ 
    si_ui_init(); 

    /* initialise display */
    display_init();

    /* initialise variables */         
    clock_init(); 

    /* create tasks */ 

    si_task_create(clock_task, &Clock_Stack[STACK_SIZE-1], 20); 

    si_task_create(alarm_task, &Alarm_Stack[STACK_SIZE-1],17);

    si_task_create(set_task, &Set_Stack[STACK_SIZE-1], 15);
 

    /* start the kernel */ 
    si_kernel_start(); 

    /* will never be here! */ 
    return 0; 
}

int main(int argc, char *argv[])
{
	printf("Initializing game\n");
	clock_t start, end;
	int remaining_time;
	
	display_init();
    gamepad_init();
    grid_init(grid);
    players_init(grid, players);
    
    display_fill_screen(0);
    g_running = 1;
    
    while(g_running) {
        start = clock();
        
        update_pos(grid, players);
        
        end = clock();
        
        remaining_time = TIME_PER_LOOP - (((end - start)/CLOCKS_PER_SEC)*1000);
        
        if(remaining_time > 0) {
            usleep(remaining_time*1000);
        }
        
        continue;
    }
	exit(EXIT_SUCCESS);
}

int main(int argc, char* argv[]) {

    glutInit(&argc, argv);

    display_init();

    comm_initialize();

   /* Call backs */
    glutDisplayFunc( display);
    glutReshapeFunc( reshape);
    glutKeyboardFunc( keyboard);
    glutIdleFunc( comm_read);

    satellite = add_element("Satellite");
    satellite_camera = new Camera();
    current_camera = satellite_camera;

    planet = add_element("Ball");
    for (int ii=0; ii<3 ; ii++) { planet->pos[ii] = 0.0; }

    glutMainLoop();

    return 0;

}

int main(void)
{
  uart_init();
  shift_init();
  timer_init();
  display_init();
  keypad_init();
  serial_init();
  edit_init();
  clock_init();
  watchdog_init(WDTO_15MS, &oops);

  sei();  // enable interrupts

  printf("\r\n*** BOOTED ***\r\nSpaceTime, yay!\r\n");

  timer_beep(10);

  while(1)
  {
    display_update();

    serial_update();

    edit_update();

    clock_update();
  }
}

ty340word
ty340_reset(void *dptr)
{
    struct type340 *u = UNIT(0);
#ifndef TY340_NODISPLAY
    if (!u->initialized) {
        display_init(DIS_TYPE340, 1, dptr); /* XXX check return? */
        u->initialized = 1;
    }
#endif
    u->xpos = u->ypos = 0;
    u->mode = 0;
    u->status = 0;
    u->scale = 1;
#if TYPE342
    u->shift = 0;
    u->width = 6;
    u->height = 9;
#endif
#if TYPE347
    u->SAVE_FF = 0;
#endif
    ty340_rfd();                /* ready for data */
    return u->status;
}

// Inits the tic-tac-toe display, draws the lines that form the board.
void ticTacToeDisplay_init(){
	display_init();  // Must init all of the software and underlying hardware for LCD.
	display_fillScreen(DISPLAY_BLACK);  // Blank the screen.
	display_setRotation(true);
	buttons_init();
	ticTacToeDisplay_drawBoardLines();

/*
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_2);
*/
	/*
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_2);*/




}

int
ng_init(void *dev, int debug)
{
  ng_dptr = dev;
  ng_dbit = debug;
  return display_init(DIS_NG, ng_scale, ng_dptr);
}

int main() {
	bool newreadings;
	bool buttonschanged;

	load_init();
	initsystem();
	watchdog_init();
	initserial();
	timer_init();
	display_init();
	initfan();
	adc_init();

	buttons_init();

	enableInterrupts();

	protocol_onbooted();

	while (1) {
		watchdog_kick();
		newreadings = adc_updatereadings();
		if (newreadings) {
			checkstate();
		}
		buttonschanged = buttons_check();
		if (newreadings || buttonschanged) {
			protocol_sendstate();
			display_update();
		}

		protocol_checkcommand();
	}
}

int		main(int ac, char **av)
{
  t_args	option;

  if (ac < 5)
    return (usage(av[0]));
  signal(SIGINT, &signal_handler);
  signal(SIGPIPE, SIG_IGN);
  srand(time(NULL) + getpid());
  init_args(&option);
  if (check_args(ac, av, &option) == false
      || check_all_args(&option) == false)
    return (usage(av[0]));
  display_init(&option);
  g_s.global_time = 0;
  g_s.id_egg = 1;
  g_s.other_size = 0;
  if ((g_s.sock = init_server(option.port)) == -1)
    return (display_error("Error : Could not init the server.\n"));
  printf("**** Initialization done\n");
  init_map(&g_s, option.width, option.height);
  init_team(&g_s, option.nb_client, option.team_name);
  init_stone(&g_s, option.width * option.height);
  g_s.option = &option;
  server_loop(&g_s);
  xclose(g_s.sock);
  return (0);
}

void board_init(void)
{
	/* Configure the memory interface */
	calypso_mem_cfg(CALYPSO_nCS0, 3, CALYPSO_MEM_16bit, 1);
	calypso_mem_cfg(CALYPSO_nCS1, 3, CALYPSO_MEM_16bit, 1);
	calypso_mem_cfg(CALYPSO_nCS2, 5, CALYPSO_MEM_16bit, 1);
	calypso_mem_cfg(CALYPSO_nCS3, 5, CALYPSO_MEM_16bit, 1);
	calypso_mem_cfg(CALYPSO_CS4, 0, CALYPSO_MEM_8bit, 1);
	calypso_mem_cfg(CALYPSO_nCS6, 0, CALYPSO_MEM_32bit, 1);
	calypso_mem_cfg(CALYPSO_nCS7, 0, CALYPSO_MEM_32bit, 0);

	/* Set VTCXO_DIV2 = 1, configure PLL for 104 MHz and give ARM half of that */
	calypso_clock_set(2, CALYPSO_PLL13_104_MHZ, ARM_MCLK_DIV_2);

	/* Configure the RHEA bridge with some sane default values */
	calypso_rhea_cfg(0, 0, 0xff, 0, 1, 0, 0);

	/* Initialize board-specific GPIO */
	board_io_init();

	/* Enable bootrom mapping to route exception vectors to RAM */
	calypso_bootrom(1);
	calypso_exceptions_install();

	/* Initialize interrupt controller */
	irq_init();

	/* initialize MODEM UART to be used for sercomm*/
	uart_init(SERCOMM_UART_NR, 1);
	uart_baudrate(SERCOMM_UART_NR, UART_115200);

	/* Initialize IRDA UART to be used for old-school console code.
	 * note: IRDA uart only accessible on C115 and C117 PCB */
	uart_init(CONS_UART_NR, 1);
	uart_baudrate(CONS_UART_NR, UART_115200);

	/* Initialize hardware timers */
	hwtimer_init();

	/* Initialize DMA controller */
	dma_init();

	/* Initialize real time clock */
	rtc_init();

	/* Initialize system timers (uses hwtimer 2) */
	timer_init();

	/* Initialize LCD driver (uses I2C) and backlight */
	display = &st7558_display;
	display_init();
	bl_mode_pwl(1);
	bl_level(50);

	/* Initialize keypad driver */
	keypad_init(1);

	/* Initialize ABB driver (uses SPI) */
	twl3025_init();
}

void target_init(void)
{
	uint32_t base_addr;
	uint8_t slot;

	dprintf(INFO, "target_init()\n");

	spmi_init(PMIC_ARB_CHANNEL_NUM, PMIC_ARB_OWNER_ID);

	target_keystatus();

	if (target_use_signed_kernel())
		target_crypto_init_params();
	/* Display splash screen if enabled */
#if DISPLAY_SPLASH_SCREEN
	dprintf(INFO, "Display Init: Start\n");
	display_init();
	dprintf(INFO, "Display Init: Done\n");
#endif

	/* Trying Slot 1*/
	slot = 1;
	base_addr = mmc_sdc_base[slot - 1];
	if (mmc_boot_main(slot, base_addr))
	{

		/* Trying Slot 2 next */
		slot = 2;
		base_addr = mmc_sdc_base[slot - 1];
		if (mmc_boot_main(slot, base_addr)) {
			dprintf(CRITICAL, "mmc init failed!");
			ASSERT(0);
		}
	}
}

void target_init(void)
{
	dprintf(INFO, "target_init()\n");

	spmi_init(PMIC_ARB_CHANNEL_NUM, PMIC_ARB_OWNER_ID);

	/* Save PM8941 version info. */
	pmic_ver = pm8x41_get_pmic_rev();

	target_keystatus();

	if (target_use_signed_kernel())
		target_crypto_init_params();
	/* Display splash screen if enabled */
#if DISPLAY_SPLASH_SCREEN
	dprintf(INFO, "Display Init: Start\n");
	if (board_hardware_subtype() != HW_PLATFORM_SUBTYPE_CDP_INTERPOSER)
	{
		display_init();
	}
	dprintf(INFO, "Display Init: Done\n");
#endif

	/*
	 * Set drive strength & pull ctrl for
	 * emmc
	 */
	set_sdc_power_ctrl();

#if MMC_SDHCI_SUPPORT
	target_mmc_sdhci_init();
#else
	target_mmc_mci_init();
#endif
}