示例#1
0
void beep()
{
    wyswietl_LCD("BEEP..BEEP");
    buzzer_on();
    _delay_ms(500);
    buzzer_off();
    _delay_ms(500);
    buzzer_on();
    _delay_ms(700);
    buzzer_off();
}
示例#2
0
void mymain(void)
{
    // set GPKCON0: output	(led1-led4: use GPK4-GPK7)
    GPKCON0 = 0x11110000;

    // set all led off (write 1 to be off)
    GPKDAT = 0x000000f0;

    // set GPF14 as output
    GPFCON |= 1<<28;
    GPFCON &= ~(1<<29);

    // set GPN0 as input
    GPNCON = 0;

    while(1)
    {
        if ( !(GPNDAT & (1<<0)) )
        {
            buzzer_on();
            led_on(0);
        }
        else
        {
            buzzer_off();
            led_off(0);
        }
    }
}
示例#3
0
文件: keypad.c 项目: houstar/ok6410
void keypad_buzzer(void)
{
	unsigned int keyStatus;
	while(1)
	{
		keyStatus = keyScan();
		if(keyStatus)
		{
			buzzer_on();
			delay();
			buzzer_off();
		}
		else
			buzzer_off();
	}
}
示例#4
0
void buzzer()
{

	buzzer_on();
	////_delay_ms(1000);
	buzzer_off();
}
//--------------------------------------------------------------------------------
// start the main function here
//--------------------------------------------------------------------------------
int main(void)
{
 float battery_low = 0;

 init_devices();
  
 packet_valid = 0;// initialise valid packet variable to 0
 
 // initially calculate the battery voltage 
 UCSRB = 0x00; 
 ADMUX = 0x26; //select ADC input 6
 battery_voltage = ADC_conversion(); 
 UCSRB = 0x98; 
 flag2 = 0;

 while(1)
 {
   // flag2 will rise once in 10sec and calculates the Battery voltage
   // and enables the UART communication
   if(flag2 == 1)
    {  	
	  ADMUX = 0x26;                           //select ADC input 6
      battery_voltage = ADC_conversion();  
      UCSRB = 0x98;                           
      flag2 = 0;
    }

   // if battery voltage is less then battery threshold value ,buzzer beeps
   battery_low = (battery_voltage * 0.041) + 0.7;  // battery voltage caluculation
   if(battery_low < BATTERY_TRHRESHOLD)
   { buzzer_on();  _delay_ms(200); buzzer_off();_delay_ms(200);}
  
   // following function beeps the buzzer twice after sucessfully reciving 10 packets
   // from the master(FireBird-V Hexapod robot)
   if(flag1 == 0)
   { 
    if(communication_proper_count > 10)
     { 
	   flag1 = 1;
	   buzzer_on();  _delay_ms(400); buzzer_off();_delay_ms(400);
	   buzzer_on();  _delay_ms(400); buzzer_off();_delay_ms(400);
     }  
   }

 }

}
示例#6
0
/**
 ****************************************************************************************
 * @brief Handles button press after cancel the jitter.
 *
 * @param[in] msgid     Id of the message received
 * @param[in] param     None
 * @param[in] dest_id   TASK_APP
 * @param[in] src_id    TASK_APP
 *
 * @return If the message was consumed or not.
 ****************************************************************************************
 */
int app_button_timer_handler(ke_msg_id_t const msgid, void const *param,
                               ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
    switch(msgid)
    {
        case APP_SYS_BUTTON_1_TIMER:
            // make sure the button is pressed
            if(gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)
            {
                if(APP_IDLE == ke_state_get(TASK_APP))
                {
                    struct app_proxr_env_tag *app_proxr_env = &app_env.proxr_ev;
                    if(!app_proxr_env->enabled)
                    {
                        // start adv
                        app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
                                app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
                                app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
                                GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);

#if (QN_DEEP_SLEEP_EN)
                        // prevent entering into deep sleep mode
                        sleep_set_pm(PM_SLEEP);
#endif
#if	(FB_OLED)
		ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
                    }
                }
                else if(APP_ADV == ke_state_get(TASK_APP))
                {
                    // stop adv
                    app_gap_adv_stop_req();

#if (QN_DEEP_SLEEP_EN)
                    // allow entering into deep sleep mode
                    sleep_set_pm(PM_DEEP_SLEEP);
#endif
#if	(FB_OLED)
		ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
                }
            }
            break;

        case APP_SYS_BUTTON_2_TIMER:
            if(gpio_read_pin(BUTTON2_PIN) == GPIO_LOW)
            {
                buzzer_off();
            }
            break;

        default:
            ASSERT_ERR(0);
            break;
    }

    return (KE_MSG_CONSUMED);
}
 //function for indication of eye-bling and raw values when removed from head
 void Eye_Blink ()
 {
   if (Eye_Enable)
   {
     if (On_Flag==1 && Off_Flag==0)
     {
       if ((Avg_Raw>Theshold_Eyeblink) && (Avg_Raw<350)) //eye-blink detected
       {
		   p++;
		   buzzer_on();
		   _delay_ms(500);
		   buzzer_off();
		  if(p==2){
		stop();
		velocity(240,240);
		left();
		_delay_ms(650);
		stop();
		run();
		p=0;
		   }
	   }
       else
       {
         if (Avg_Raw>350)  //Raw data values indication
         {
			buzzer_on();_delay_ms(50);buzzer_off(); //Sensor removed from head, bot stops.
			stop();
           On_Flag==0;Off_Flag==1;
         }
       }
	   }

	 else
     {
       PORTJ=0x00;
     }
	 }
   else    //Device is paired
   {
     PORTJ=0x01;
	 stop();
   }

 }
示例#8
0
//------------------------------------------------------------------------------
int board_init(void)
{
    u32 v1, v2;
    //printf("board_init\n");
	/* arch number of the board */
	gd->bd->bi_arch_number = MACH_TYPE_DAVINCI_EVM;

	/* address of boot parameters */
	gd->bd->bi_boot_params = 0x0000100; //LINUX_BOOT_PARAM_ADDR;

	/* if workarounds are needed */
	ka_errata_workarounds();

	/* Disable SSI Clock */
	word_write(KA_REGIF_BASE, word_read(KA_REGIF_BASE) & 0xffdfffff);
    
//        printf("Status %x\n", word_read(SDSW_M1_STATUS));
    //setenv ("bootdelay", "8");

    v1 = word_read(0x1ffc00);
    v2 = word_read(0x208000);

#ifndef BOOT_FROM_SD
    if (v2 == 0xe1a00000 || v2 == 0xe3a00000)
        setenv ("bootf", "mmc init; go 208000");
    else if (v2 == 0x56190527)
        setenv ("bootf", "mmc init; bootm 208000");
    else if (v1 == 0xe1a00000 || v1 == 0xe3a00000)
        setenv ("bootf", "mmc init; go 1ffc00");
    else if (v1 == 0x56190527)
        setenv ("bootf", "mmc init; bootm 1ffc00");
    else
#endif
    {
        //setenv ("bootf", "mmc init; fatload mmc 1 208000 image; go 208000");
        setenv ("bootf", "run boot_sd");
        //printf("v1 %x v2 %x\n", v1, v2);
        buzzer_off();
    }


	/* Enable UART */
	/*word_write(UART_LCR,  0x83);
	word_write(UART_INTR, 0x00);
	word_write(UART_RECV, 0x28);	//baudrate=19200,12MHz
	word_write(UART_LCR,  0x03); */

	/* Close PLL */
	/* Power on required peripherals */
	//timer_init();
	//word_write(GPIO_OUTPUT, 0x66);

	return(0);
}
void checkState(int t)
{
	while(t>0)
	{
		buzzer_on();
		_delay_ms(50);
		buzzer_off();
		_delay_ms(200);
		t--;
	}
}
/** @brief Low Battery alarm to be called for example with 1 Hz */
void beep_on_low_voltage(void)
{
	if (global_data.battery_voltage < BATTERY_LOW_VOLTAGE_ALARM)
	{
		buzzer_toggle();
	}
	else
	{
		buzzer_off();
	}
}
示例#11
0
//Main Function
void buzzer(void)
{
	init_devices_buzzer();
	for(int i=0;i<1;i++)
	{
		buzzer_on();
		_delay_ms(1000);		//delay
		buzzer_off();
		_delay_ms(1000);		//delay
	}
}
示例#12
0
void sh_cmd1(void)
{
//	time_tt t = {};
//	clean_lcd(BACK_COL);
//	gettime(&t);

	buzzer_init();
	buzzer_on();
	udelay(1000*1000);
	buzzer_off();
	udelay(1000*1000);
}
示例#13
0
/**
 ****************************************************************************************
 * @brief Handles alert stop timer.
 *
 * @param[in] msgid     APP_PROXR_ALERT_STOP_TO
 * @param[in] param     Null
 * @param[in] dest_id   TASK_APP
 * @param[in] src_id    TASK_NONE
 *
 * @return If the message was consumed or not.
 * @description
 * This handler is used to request the Application to start the alert on the device
 * considering the indicated alert level. The handler may be triggered on two conditions:
 * The IAS alert level characteristic has been written to a valid value, in which case
 * alert_lvl will be set to the IAS alert level value.
 * A disconnection with a reason other than the normal local/remote link terminations has
 * been received, in which case alert_lvl will be set to the LLS alert level value.
 * The Application actions following reception of this indication are strictly implementation
 * specific (it may try to reconnect to the peer and stop alert upon that, or timeout the
 * alert after acertain time, please see the specification)
 ****************************************************************************************
 */
int app_proxr_alert_to_handler(ke_msg_id_t const msgid,
                               void *param,
                               ke_task_id_t const dest_id,
                               ke_task_id_t const src_id)
{
    // Stop proxr alert
    buzzer_off();

    //app_proxr_env->alert_lvl = 0;
    QPRINTF("alert_stop_timer_handler.\r\n");
    return (KE_MSG_CONSUMED);
}
/**
  Turn left at an intersection.
*/
void turn_left(){
	buzzer_off();
	motion_set(0x05);
	velocity(100,100);
	_delay_ms(1000);
	while(1){
		print_sensor_data();
		read_sensors();
		if(Center_white_line < W_THRESHOLD) break;
	}
	velocity(0,0);
}
示例#15
0
void buzzer_beep(int n)
{
	int i;

	for (i = 0; i < n; i++)
	{
		buzzer_on();
		mdelay(100);
		
		buzzer_off();
		mdelay(100);
	}
}
//Main Function
int main(void)
{
	init_devices();
	while(1)
	{
	if((PINE & 0x80) == 0x80) //switch is not pressed
		{
			buzzer_off(); //Turn off buzzer
			PORTJ = 0x00; //Turn off bargraph LEDs			
		}
	else
		{
			
			buzzer_on(); //Turn on buzzer
			PORTJ = 0xFF; //Turn on bargraph LEDs
		}
	}	
}
示例#17
0
void update_node()
{
  if(to_process ==1)
		{   
		    lcd_cursor(2,13);
		    lcd_string(store);
			
			visited =atoi(store);
			
			check_node[visited]=1;
			to_process=0;
			buzzer_off();
			for(k=0;k<4;k++)
			 store[k]=0;
			forward();
			return;
		}
}
int isPlus()
{

	if((Left_white_line >0x20 && Center_white_line>0x20) || (Right_white_line >0x20 && Center_white_line>0x20))
	{
	buzzer_on();
	_delay_ms(100);
	buzzer_off();
	_delay_ms(100);	


	return 1;
	}
	else
	{
	return 0;
	}
}
int move_bot()
{
    init_sensor_values();
    while(checkobstacle()==0) {}
    buzzer_off();
    if(checkintersection() == 1)
    {
        //communicate with coordinator
        comintersection();
        stop();
        _delay_ms(100);
        return 0;
    }
    else
    {
        follow();
        return 1;
    }
}
示例#20
0
int detect_program_bin(void)
{
    int ret, size, count;
    u32 *buf;
    buf = (u32 *)0xe00000;

    fat_register_device(&mmc_blk_dev,1);
    //buzzer_off();

    size = file_fat_read ("program.bin", buf, 128 * 1024);
    if (size > 1 && (buf[0] == 0xea000012 || buf[0] == 0x120000ea))
    {
        buzzer_on(0);
        run_command("go e00000", 0);
        buzzer_off();
    }
    //buzzer_off();
    return 0;
}
示例#21
0
void main()
{

		buzzer_off();
		pcf_8591_init();
		timer0_init();
		timer1_init();
		while(1)
		{
				switch(mod)
				{
						case 1:
									re =  pcf_8591_rd();
									delay(20);
									l3 = weight(re,l3);
									break;
						case 2:
									TR0 = 0;
									if(leixing == 1)
									{
										display(mod,ht1,0);
											Delay1000ms(ht1);
											ht1--;
											if(ht1 == 0)
												mod = 1;
										}
									else
									{	
										display(mod,ht2,0);
											Delay1000ms(ht2);
											ht2--;
										if(ht2 == 0)
												mod = 1;
									}
								
									
									break;
						case 3:
									break;
				}
		}
}
示例#22
0
void menu_key_test(void) {
    u8 i;
    u16 bit;
    
    // cleanup screen and disable possible low bat warning
    buzzer_off();
    key_beep();
    menu_battery_low = 0;	// it will be set automatically again
    battery_low_shutup = 0;

    // do full screen blink
    lcd_set_full_on();
    delay_menu_always(2);
    while (btns(BTN_ENTER))  stop();  // wait for release of ENTER
    lcd_clear();

    button_autorepeat(0);	// disable autorepeats
    btnra();

    // show intro text
    lcd_chars("KEY");
    lcd_update_stop();		// wait for key

    while (1) {
	if (btnl(BTN_BACK | BTN_ENTER))  break;

	for (i = 0, bit = 1; i < 16; i++, bit <<= 1) {
	    if (btn(bit)) {
		key_beep();
		lcd_chars(key_ids[i]);
		if (btnl(bit))  lcd_7seg(L7_L);
		else lcd_set(L7SEG, LB_EMPTY);
		lcd_update();
		break;
	    }
	}
	btnra();
	stop();
    }
    key_beep();
    apply_model_config();
}
void detect(){	
if(USART1_RX_vect()==0xAA){ //check SYNC byte 1
if(USART1_RX_vect()==0xAA){ //check SYNC byte 2
	payloadlength=USART1_RX_vect();
	      if(payloadlength < 169) {                     //Payload length can not be greater than 169
      generatedChecksum = 0;
      for(int i = 0; i < payloadlength; i++) {
	      payloaddata[i] = USART1_RX_vect();            //Read payload into memory
	      generatedChecksum += payloaddata[i];
      }
	checksum = USART1_RX_vect();                      //Read checksum byte from stream
	generatedChecksum = 255 - generatedChecksum;
	
	        if(checksum == generatedChecksum) {       //Checking whether checksum received is correct. If buzzer turns on then packet is correct.
		buzzer_on();_delay_ms(100);buzzer_off();_delay_ms(100);
					}
					}
				}												        
				}	
}	 
示例#24
0
文件: main.c 项目: yuanyiyixi/arm
int test(void)
{
	int i = 0;
	led_init();
	buzzer_init();
	k1_init();
	while(1)
	{
		if(k1_is_down())
		{
		buzzer_on();
		led_on(i%4 + 1);
		delay(1);
		buzzer_off();
		led_off(i%4 + 1);
		delay(1);
		i++;
		}
	}
	return 0;
}
示例#25
0
/** Inicjalizacja urządzeń wejścia / wyjścia.
*/
void ioinit(void)
{
	uint8_t i;
	hd44780_init();
	hd44780_outcmd(HD44780_CLR);
	hd44780_wait_ready();
	hd44780_outcmd(HD44780_ENTMODE(1, 0));
	hd44780_wait_ready();
	hd44780_outcmd(HD44780_DISPCTL(1, 1, 1));
	hd44780_wait_ready();
	hd44780_outcmd(HD44780_CGADDR(0));
	for(i=0; i<64; i++) {
		hd44780_outdata(pgm_read_byte(&extraChar[i]));
	}

	TCCR1B = _BV(WGM12) | _BV(CS11);                        // licznik / 8 - wyzerwoanie na porownanie
	TIMSK = _BV(OCIE1A);                                    // przerwanie na porownanie wartosci
	OCR1A = TAU1;                                           // warto licznika porownania

	usart_init(UBRR_VALUE);

	onewire_init();

	twi_init();

	outputs_init();

	top_off_init();

	qbuttons_init();

	ui_init();

	BUZZER_DDR |= _BV(BUZZER_SWITCH);
	buzzer_off();

	wdt_enable(WDTO_2S);
}
/**
  Go forward by a certain specified number of steps.
*/
void go_distance(unsigned char x)
{
	reset_shaft_counters();
   forward();
	velocity(100,100);
	PORTJ = 0x00;
	while(1){
		read_sensors();
		print_sensor_data();
		if( Front_IR_Sensor<0xF0)
		{
			stop();
			buzzer_on();
		}
		else
		{
			forward();
			buzzer_off();
		}
		if((ShaftCountLeft + ShaftCountRight)*5 > x*10)
			break;
	}
	velocity(0,0);
}
示例#27
0
/**
 ****************************************************************************************
 * @brief   Show proxr alert. User can add their own code here to show alert.
 ****************************************************************************************
 */
static void usr_proxr_alert(struct proxr_alert_ind *param)
{
    // If it is PROXR_LLS_CHAR writting indication, don't alert,
    // otherwise (PROXR_IAS_CHAR, disconnect) to alert
    if (param->char_code == PROXR_IAS_CHAR || app_proxr_env->enabled == false)
    {
        if(param->alert_lvl == 2)
        {
            buzzer_on(BUZZ_VOL_HIGH);
            ke_timer_set(APP_PROXR_ALERT_STOP_TIMER, TASK_APP, 500);    // 5 seconds
        }
        else if(param->alert_lvl == 1)
        {
            buzzer_on(BUZZ_VOL_LOW);
            ke_timer_set(APP_PROXR_ALERT_STOP_TIMER, TASK_APP, 500);    // 5 seconds
        }
        else
        {
            buzzer_off();
            ke_timer_clear(APP_PROXR_ALERT_STOP_TIMER, TASK_APP);
        }
    }

}
示例#28
0
__EXPORT int nsh_archinitialize(void)
{
	int result;

	message("\n");

	/* configure always-on ADC pins */
	stm32_configgpio(GPIO_ADC1_IN0);
	stm32_configgpio(GPIO_ADC1_IN10);
	stm32_configgpio(GPIO_ADC1_IN11);

	stm32_configgpio(GPIO_UART_SBUS_INVERTER);
#ifdef CONFIG_RC_INPUTS_TYPE(RC_INPUT_SBUS)
	stm32_gpiowrite(GPIO_UART_SBUS_INVERTER, 1);
#else
	stm32_gpiowrite(GPIO_UART_SBUS_INVERTER, 0);
#endif

	/* configure the high-resolution time/callout interface */
	hrt_init();

	/* configure CPU load estimation */
#ifdef CONFIG_SCHED_INSTRUMENTATION
	cpuload_initialize_once();
#endif


















	/* initial BUZZER state */
	drv_buzzer_start();
	buzzer_off(BUZZER_EXT);

	/* initial LED state */
	drv_led_start();
	led_off(LED_AMBER);
	led_off(LED_BLUE);
	led_off(LED_GREEN);
	led_off(LED_EXT1);
	led_off(LED_EXT2);



	/* Configure SPI-based devices */

	message("[boot] Initializing SPI port 1\n");
	spi1 = up_spiinitialize(1);

	if (!spi1) {
		message("[boot] FAILED to initialize SPI port 1\r\n");
		led_on(LED_AMBER);
		return -ENODEV;
	}

	/* Default SPI1 to 1MHz and de-assert the known chip selects. */
	SPI_SETFREQUENCY(spi1, 10000000);
	SPI_SETBITS(spi1, 8);
	SPI_SETMODE(spi1, SPIDEV_MODE3);
	SPI_SELECT(spi1, GPIO_SPI_CS_MS5611, false);
	SPI_SELECT(spi1, GPIO_SPI_CS_EXP_MS5611, false);
	SPI_SELECT(spi1, GPIO_SPI_CS_EXP_MPU6000, false);
	SPI_SELECT(spi1, GPIO_SPI_CS_EXP_HMC5983, false);
	SPI_SELECT(spi1, GPIO_SPI_CS_EXP_WIFI_EEPROM, false);
	up_udelay(20);

	message("[boot] Successfully initialized SPI port 1\r\n");

//	message("[boot] Initializing Wireless Module\n");
//	wireless_archinitialize();

	message("[boot] Initializing SPI port 2\n");
	spi2 = up_spiinitialize(2);

	if (!spi2) {
		message("[boot] FAILED to initialize SPI port 2\r\n");
		led_on(LED_AMBER);
		return -ENODEV;
	}

	/* Default SPI2 to 1MHz and de-assert the known chip selects. */
	SPI_SETFREQUENCY(spi2, 10000000);
	SPI_SETBITS(spi2, 8);
	SPI_SETMODE(spi2, SPIDEV_MODE3);
	SPI_SELECT(spi2, GPIO_SPI_CS_MPU6000, false);
	SPI_SELECT(spi2, GPIO_SPI_CS_IMU_MS5611, false);
	SPI_SELECT(spi2, GPIO_SPI_CS_IMU_MPU6000, false);
	SPI_SELECT(spi2, GPIO_SPI_CS_IMU_HMC5983, false);
	SPI_SELECT(spi2, GPIO_SPI_CS_IMU_EEPROM, false);

	message("[boot] Successfully initialized SPI port 2\n");

	/* Get the SPI port for the microSD slot */

	message("[boot] Initializing SPI port 3\n");
	spi3 = up_spiinitialize(3);

	if (!spi3) {
		message("[boot] FAILED to initialize SPI port 3\n");
		led_on(LED_AMBER);
		return -ENODEV;
	}

	/* Default SPI3 to 1MHz and de-assert the known chip selects. */
	SPI_SETFREQUENCY(spi3, 10000000);
	SPI_SETBITS(spi3, 8);
	SPI_SETMODE(spi3, SPIDEV_MODE3);
	SPI_SELECT(spi3, GPIO_SPI_CS_DATAFLASH, false);
	SPI_SELECT(spi3, GPIO_SPI_CS_EEPROM, false);
	SPI_SELECT(spi3, GPIO_SPI_CS_SDCARD, false);

	message("[boot] Successfully initialized SPI port 3\n");

	/* Now bind the SPI interface to the MMCSD driver */
	result = mmcsd_spislotinitialize(CONFIG_NSH_MMCSDMINOR, CONFIG_NSH_MMCSDSLOTNO, spi3);

	if (result != OK) {
		message("[boot] FAILED to bind SPI port 3 to the MMCSD driver\n");
		led_on(LED_AMBER);
		return -ENODEV;
	}

	message("[boot] Successfully bound SPI port 3 to the MMCSD driver\n");

	return OK;
}
示例#29
0
void menu_global_setup(void) {
    u8 item = 0;
    u8 item_val = 0;		// now selecting item
    global_setup_t func = gs_config[item];

    // cleanup screen and disable possible low bat warning
    buzzer_off();
    key_beep();
    menu_battery_low = 0;	// it will be set automatically again
    backlight_set_default(BACKLIGHT_MAX);
    backlight_on();
    lcd_clear();

    lcd_segment(LS_MENU_MODEL, LS_ON);
    lcd_segment_blink(LS_MENU_MODEL, LB_INV);
    lcd_segment_blink(LS_MENU_NAME, LB_INV);
    lcd_update();
    func(0);			// show current value

    while (1) {
	btnra();
	stop();

	if (btnl(BTN_BACK | BTN_ENTER))  break;

	if (btn(BTN_ENTER)) {
	    if (item > 0) {		// not for firmware version
		key_beep();
		item_val = (u8)(1 - item_val);
		if (item_val) {
		    // changing value
		    lcd_chars_blink(LB_SPC);
		}
		else {
		    // selecting item
		    lcd_chars_blink(LB_OFF);
		}
	    }
	}

	else if (btn(BTN_ROT_ALL)) {
	    if (item_val) {
		// change item value
		func(1);
		lcd_chars_blink(LB_SPC);
	    }
	    else {
		// select another item
		func(0xff);		// un-show labels
		if (btn(BTN_ROT_L)) {
		    if (item)  item--;
		    else       item = GS_CONFIG_SIZE - 1;
		}
		else {
		    if (++item >= GS_CONFIG_SIZE)  item = 0;
		}
		func = gs_config[item];
		func(0);		// show current value
	    }
	    lcd_update();
	}
    }

    func(0xff);		// un-show labels, apply resets
    beep(60);
    lcd_clear();
    config_global_save();
    apply_global_config();
}
示例#30
0
// shut up battery low beeper
static void kf_battery_low_shutup(u8 *id, u8 *param, u8 flags, s16 *pv) {
    battery_low_shutup = 1;
    buzzer_off();
}