Exemplo n.º 1
0
void device_led_default(struct ss_device * dev, uint32_t ctl)
{
	if (dev->ledno) {
		DCC_LOG2(LOG_INFO, "dev=%d ctl=0x%x", dev->addr, ctl);

		/* Poll LED state */
		if ((ctl & 0x5) == 0x5) {
			led_flash(dev->ledno - 1, 64);
		} else if ((ctl & 0x4) == 0x4) {
			led_on(dev->ledno - 1);
		} else
			led_off(dev->ledno - 1);
	}

	if ((ctl & 0x4) == 0x4)
		dev->led = 1;
	else
		dev->led = 0;
}
Exemplo n.º 2
0
void __attribute__((interrupt("IRQ"))) interrupt_handler(void) {
 	static int lit = 0;

	/* Check that it was in fact a timer interrupt */
	if (mmio_read(IRQ_BASIC_PENDING)&&0x1) {
		
		/* Clear the ARM Timer interrupt		*/
		mmio_write(TIMER_IRQ_CLEAR, 0x1);

		/* Toggle the LED state */
		if(lit) {
			led_off();
			lit = 0;
		} else {
			led_on();
			lit = 1;
		}
	} else printk("Other Interrupt \r\n");
}
Exemplo n.º 3
0
/**
 *   \brief This will start a sleep operation.
 *
 *   \param val Used for remembering the new menu to display after a wakeup.
*/
void
menu_run_sleep(uint8_t *val)
{
    /* Turn off LED, LCD, ADC, Timer 1, SPI */
    led_off();
    lcd_deinit();
 	key_deinit();
    PRR |= (1 << PRTIM1) | (1 << PRSPI);

    /* Tell the 1284P to turn off the radio and sleep */
	sleep_count=0;
    uart_serial_send_frame(SEND_SLEEP, 1, (uint8_t *)&sleep_count);

    /* Turn off UART when transmission is complete */
	while(!(UCSR0A & (1 << TXC0)));
    _delay_us(10000); //deinit trash clears done flag on 1284p
	uart_deinit();

    /* Go to sleep until button is pushed */
    sleep_now(0);

    /* Yawn, waking up, turn on LCD with Raven Logo */
    lcd_init();
    lcd_symbol_set(LCD_SYMBOL_RAVEN);

	/* Disable interrupts before powering everything up */
    cli();
    key_init();
    PRR &= ~((1 << PRTIM1) | (1 << PRSPI));
 	uart_init();

    /* Enable interrupts, Wake up 1284p and radio */
	sei();
    sleep_wakeup();
//	uart_init();//flush receive buffer

    /* Wait for buttons up */
    while (key_state_get() != KEY_NO_KEY)
        ;
    if (is_button()){
        get_button();
    }
}
Exemplo n.º 4
0
/* Fading test */
void fading(void)
{
    int i;
    while (1)
    {
        for (i = 255; i > 5; i --)
        {
            led_on(GREEN);
            output(i);
            delay(30);
        }
        for (i = 5; i < 255; i ++)
        {
            led_off(GREEN);
            output(i);
            delay(30);
        }
    }
}
Exemplo n.º 5
0
int main(void)
{
	target_init();
	HAL_SET_PIN_DIRECTIONS();
	wdt_disable();
    
	//hal_init( NULL, NULL );

	led_on( LED_ALL );
	hal_delay( 500 );
	led_off( LED_ALL );

	dbo_open(0, 38400);

	// the parameter id can be 0-3 denoting timer hardware 0 to 3
     	timer_interrupt_driven_test( 0 );
    // 	timer_query_driven_test( 2 );
  		while(1){}
}
Exemplo n.º 6
0
void send_data_loop(float temperature_sensor_value, int light_sensor_value) {
  if (LWiFi.status() == LWIFI_STATUS_DISCONNECTED) {
    Serial.println("Disconnected from WiFi");
    while (0 == LWiFi.connect(ssid, LWiFiLoginInfo(WIFI_AUTH, key))){
      Serial.println("Connecting to WiFi...");
      delay(1000);
    }

  }
  LDateTime.getRtc(&rtc);
  if ((rtc - lrtc) >= per) {
     senddata(temperature_sensor_value, light_sensor_value);
    lrtc = rtc;
  }
  //Check for TCP socket command from MCS Server 
  String tcpcmd="";
  while (c.available())
   {
      int v = c.read();
      if (v != -1)
      {
        Serial.print((char)v);
        tcpcmd += (char)v;
        if (tcpcmd.indexOf("led on") >= 0) {
          Serial.print("Received actuator command: "); Serial.println(tcpcmd);  
          Serial.println("Switching LED ON...");  
          led_on();  
          tcpcmd="";
        }else if(tcpcmd.indexOf("led off") >= 0) {  
          Serial.print("Received actuator command: "); Serial.println(tcpcmd);  
          Serial.println("Switching LED OFF...");  
          led_off();  
          tcpcmd="";
        }
      }
   }
  //Check for hearbeat interval 
  LDateTime.getRtc(&rtc2);
  if ((rtc2 - lrtc2) >= per1) {
    heartBeat();
    lrtc2 = rtc2;
  }  
}
Exemplo n.º 7
0
static int __init led_init(void)
{
	int error = 0;
	printk(KERN_ALERT "Init called\n");

	/*if (!wmi_has_guid(DELL_LED_BIOS_GUID))
		return -ENODEV;

	error = led_off();
	if (error != 0)
		return -ENODEV;
	*/
	printk(KERN_ALERT "classdev_register return : %d\n",error);
	if(!(error = led_classdev_register(NULL, &led))){
		led_on();
		led_off();
	}
	return 0;
}
Exemplo n.º 8
0
int main (void)
{
    system_init ();

    led_init ();
    button_init ();

    while (1)
    {
        if (button_pressed_p ())
        {
            led_on ();
        }
        else
        {
            led_off ();
        }
    }
}
Exemplo n.º 9
0
/** @brief: Function for handling the RTC0 interrupts.
 * Triggered on TICK and COMPARE0 match.
 */
static void rtc_handler(nrf_drv_rtc_int_type_t int_type)
{
    switch (int_type)
    {
    case CC_PERIODIC:
        periodic_task();
        break;
    case CC_DEBOUNCE:
        btn_debounce();
        break;
    case CC_BLINK:
        if (!g_btn_pressed)
            led_off();
        rtc_cc_disable(CC_BLINK);
        break;
    default:
        ;
    }
}
Exemplo n.º 10
0
void main_thread()
{
	printf_(OS_WELCOME_MESSAGE);

	u32 res = hmc5883_init();

	while (1)
	{
		led_on(LED_1);
		hmc5883_read();
		//printf_("%u : %i %i %i\n", res, g_hmc5883.mx, g_hmc5883.my, g_hmc5883.mz);
		printf_("%u : %i \n", res, g_hmc5883.mz);
		led_off(LED_1);


		timer_delay_ms(100);
	}

	robot_main();
}
Exemplo n.º 11
0
// Handle hard faults
static void __attribute__((naked)) HardFault_Handler(void)
{
    u32 loops;
    while (1)
    {
        led_on(LED_1);
        loops = 10000000;
        while (loops--)
            __asm("nop");


        led_off(LED_1);
        loops = 10000000;
        while (loops--)
            __asm("nop");
    }

    while (1)
        __asm("nop");
}
Exemplo n.º 12
0
void asv2_evolve( void * svcptr, TiEvent * e )
{
	TiAppService2 * svc = (TiAppService2 *)svcptr;

	switch (svc->state)
	{
	case 0:
		led_on( LED_GREEN );
		svc->state = 1;
		break;
	case 1:
		led_off( LED_GREEN );
		svc->state = 0;
	}

	if (svc->listener != NULL)
	{
		svc->listener( svc->lisowner, e );
	}
}
Exemplo n.º 13
0
void tx_callback(Trans_Tx_Result result)
{
	if(result == TransPacketSent)
	{
		#ifdef USE_LEDS
		led_off(3);
		#endif
		log_print_string("ACK SEND");
	}
	else
	{
		#ifdef USE_LEDS
		led_toggle(2);
		#endif
		log_print_string("TX ACK CCA FAIL");
	}

	// Restart channel scanning
	start_channel_scan = true;
}
Exemplo n.º 14
0
void hit_by(uint8_t who)
{
  uint16_t respawn_timer;

  add_to_hitlist(who);
  Save(FLASH_HITLIST,(uint16_t*)&hitlist,HITLIST_SIZE);

  config.health --;
  Save(FLASH_CONFIG,(uint16_t*)&config, CONFIG_SIZE);

  play_song((uint16_t*)death_song,sizeof(death_song)/sizeof(uint16_t),60000,0);

  if(!config.health)
  {
    red_led_on();
    super_dead_mode();
    return;
  }

  respawn_timer = config.respawn_delay;
  while(respawn_timer)
  {
    respawn_timer--;
    red_led_on();
    for(uint8_t i=0;i<50;i++)
    {
        handle_music();
        delay_1_ms();
    }

    if(respawn_timer < 30)
    {
        led_off();
    }
    for(uint8_t i=0;i<50;i++)
    {
        handle_music();
        delay_1_ms();
    }
  }
}
Exemplo n.º 15
0
void IR_range_blast(uint16_t power)
{
	delay_ms(POST_BROADCAST_DELAY);
	
	//uint32_t timer[20];
	//timer[0] = get_16bit_time(); //Top of the function.
	uint16_t pre_sync_op = get_16bit_time();
	for(uint8_t dir = 0; dir < 6; dir++)
	{
		set_ir_power(dir, power);
	}
	while((get_16bit_time() - pre_sync_op) < TIME_FOR_SET_IR_POWERS);


	//set_rgb(128,0,64);
	//_delay_ms(1);
	//led_off();
	//_delay_ms(10);



	for(uint8_t dir = 0; dir < 6; dir++)
	{
		//IR_emit(dir, DELAY_BETWEEN_RB_MEASUREMENTS*NUMBER_OF_RB_MEASUREMENTS);
		//timer[(3*dir + 0) + 1] = get_16bit_time();//Top of the for loop.
		delay_ms((DELAY_BETWEEN_RB_MEASUREMENTS + TIME_FOR_GET_IR_VALS)*(NUMBER_PRE_MEASUREMENTS));
		IR_emit(dir, (DELAY_BETWEEN_RB_MEASUREMENTS + TIME_FOR_GET_IR_VALS)*(NUMBER_OF_RB_MEASUREMENTS - (NUMBER_PRE_MEASUREMENTS + NUMBER_POST_MEASUREMENTS + 1))); //The -1 is 'cause we shouldn't count the baseline measurements.
		delay_ms((DELAY_BETWEEN_RB_MEASUREMENTS + TIME_FOR_GET_IR_VALS)*(NUMBER_POST_MEASUREMENTS));
		//timer[(3*dir + 1) + 1] = get_16bit_time();//post emit
		set_green_led(100);
		delay_ms(DELAY_BETWEEN_RB_TRANSMISSIONS);
		led_off();
		//timer[(3*dir + 2) + 1] = get_16bit_time();//bottom of the for loop.
		
		//_delay_ms(10);
		//IR_emit(1, DELAY_BETWEEN_RB_MEASUREMENTS*NUMBER_OF_RB_MEASUREMENTS-20); // strictly for debugging the timing
		//_delay_ms(DELAY_BETWEEN_RB_TRANSMISSIONS+10);
	}
	//timer[19] = get_16bit_time();//End of function.
	//debug_print_timer(timer);
}
Exemplo n.º 16
0
/**
 *   \brief This will start a sleep with wakes for temperature measurement and web requests.
 *
 *   \param val Used for remembering the new menu to display after a wakeup.
*/
void
menu_run_doze(uint8_t *val)
{
    /* Turn off LED, LCD */
    led_off();
    lcd_deinit();

    /* Debounce */
    while (key_state_get() != KEY_NO_KEY) ;
     
    /* Stay in doze loop until button is pressed*/
    while (ENTER_PORT & (1<<ENTER_PIN)) {
 
     /* Tell 1284p to sleep for 4 seconds */
	 /* It will ignore the request if TCP/IP sessions are active */
     /* Alter these timings as desired, or comment out to sleep only the 3290p */
		sleep_count=4;
        uart_serial_send_frame(SEND_SLEEP, 1, (uint8_t *)&sleep_count);

     /* Wait for transmission complete, then sleep 3290p for 5 seconds */
 		while(!(UCSR0A & (1 << TXC0)));
//		uart_deinit();
        sleep_now(sleep_count+1);
//		uart_init();

    /* 1284p should be awake by now, update temperature and give it time to process */
		menu_send_temp();
	    _delay_us(20000);
 	}

    /* Wake LCD, turn on Raven logo */
    lcd_init();
    lcd_symbol_set(LCD_SYMBOL_RAVEN);
    sleep_wakeup();
    /* Wait for buttons up */
    while (key_state_get() != KEY_NO_KEY)
        ;
    if (is_button()){
        get_button();
    }
}
Exemplo n.º 17
0
//Kommunikation
void command(uint8_t *buf) {
	uint8_t m_comand = buf[0];
	struct rgb rgb_color;
	struct hsv hsv_color;
		
	switch (m_comand) {
		case mpxl_cmd_off:
			led_off();
			break;
				
		case mpxl_cmd_on:
			led_on();
			break;
				
		case mpxl_cmd_setRGB:
			rgb_color.Red = buf[1];
			rgb_color.Green = buf[2];
			rgb_color.Blue = buf[3];
			set_led_color(&rgb_color);
			break;
			
		case mpxl_cmd_setHSV:
			hsv_color.hsv[0] = buf[1];
			hsv_color.hsv[1] = buf[2];
			hsv_color.saturation = buf[3];
			hsv_color.value = buf[4];
			hsv2rgb(&hsv_color,&rgb_color);
			set_led_color(&rgb_color);
			break;
			
	   case mpxl_cmd_fade:
			rgb_color.Red = buf[1];
 			rgb_color.Green = buf[2];
 			rgb_color.Blue = buf[3];
 			rgb_fade_int(rgb_color, buf[4]);
 			
		case mpxl_cmd_script:
			script_handler(buf);
			break;
	}		
}
Exemplo n.º 18
0
void tx_callback(Trans_Tx_Result result)
{
	counter++;

	if(result == TransPacketSent)
	{
		#ifdef USE_LEDS
		led_off(3);
		#endif
		log_print_string("TX OK");
	}
	else
	{
		#ifdef USE_LEDS
		led_toggle(1);
		#endif
		log_print_string("TX CCA FAIL");
	}

	tx = 0;
}
Exemplo n.º 19
0
/* blink leds */
void
blink(void)
{
	int i, times;
	short h;
	
	if ((input_line[5] == ' ') && (isdigit(input_line[6])))
		times = 10 * (input_line[6] - '0');
	else
		times = 1;
	
	for (i = 1; i <= times; i++)
	{
		for (h = 1; h <= 8; h++)
			led_on(h);
		usleep((int)(set_time / 2));
		for (h = 1; h <= 8; h++)
			led_off(h);
		usleep((int)(set_time / 2));
	}
}
Exemplo n.º 20
0
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;
}
Exemplo n.º 21
0
/**
 * Create a debug terminal for testing Bluetooth.
 */
void ksimpleterminal( void )
{
    
int c;

    led_on();

    for( ;; )
    {	
	c = kgetc( (void *)0 );

	if( c != SYSERR )
	    kputc( (void *)0, c );
	led_off();
	if( c == 'q' )
	  break;


    }
  
}
Exemplo n.º 22
0
void launch_launcher(void) {
    if (launcher.state != launcher.last_state) {  // if we are entering the state, do initialization stuff
        launcher.last_state =  launcher.state;
    }

    if (!pin_read(launcher.load_sensor)) {
        launcher.loaded = 1;
        led_on(&led1);
        pin_clear(launcher.elevator_motor);
    }

    if (launcher.loaded) {
        pin_set(launcher.launch_motor);
        if (!pin_read(launcher.launch_sensor)) {
            limit_flag = 1;
        }

        if (pin_read(launcher.launch_sensor) && limit_flag) {
            limit_counter++;
        }

        if (limit_counter >= 100) {
            launcher.state = rest_launcher;
        }
    } else {
        if (launcher.over) {
            launcher.state = over_launcher;
        }
    }

    if (launcher.state != launcher.last_state) {  // if we are leaving the state, do clean up stuff
        pin_clear(launcher.launch_motor);
        pin_set(launcher.elevator_motor);
        launcher.launch = 0;
        launcher.loaded = 0;
        led_off(&led1);
        limit_flag = 0;
        limit_counter = 0;
    }
}
Exemplo n.º 23
0
void
jump_to_app()
{
	const uint32_t *app_base = (const uint32_t *)APP_LOAD_ADDRESS;

	/*
	 * We refuse to program the first word of the app until the upload is marked
	 * complete by the host.  So if it's not 0xffffffff, we should try booting it.
	 */
	if (app_base[0] == 0xffffffff)
		return;
	/*
	 * The second word of the app is the entrypoint; it must point within the
	 * flash area (or we have a bad flash).
	 */
	if (app_base[1] < APP_LOAD_ADDRESS)
		return;
	if (app_base[1] >= (APP_LOAD_ADDRESS + board_info.fw_size))
		return;

	/* just for paranoia's sake */
	flash_lock();

	/* kill the systick interrupt */
	systick_interrupt_disable();
	systick_counter_disable();

	/* and set a specific LED pattern */
	led_off(LED_ACTIVITY);
	led_on(LED_BOOTLOADER);

	/* the interface */
	cfini();

	/* switch exception handlers to the application */
	SCB_VTOR = APP_LOAD_ADDRESS;

	/* extract the stack and entrypoint from the app vector table and go */
	do_jump(app_base[0], app_base[1]);
}
Exemplo n.º 24
0
int main(void)
{

  /* USER CODE BEGIN 1 */
    uint8_t i = 0;
    
  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();

  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */
      i = (i >= 3)? 0 : i + 1;
      led_on(LED_0 << i);
      HAL_Delay(500);
      led_off(LED_0 << i);
      HAL_Delay(500);
      
  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}
Exemplo n.º 25
0
static int board_button_irq(int irq, FAR void *context)
{
	static struct timespec time_down;

	if (board_pwr_button_down()) {

		led_on(BOARD_LED_RED);

		clock_gettime(CLOCK_REALTIME, &time_down);

	} else {

		led_off(BOARD_LED_RED);

		struct timespec now;

		clock_gettime(CLOCK_REALTIME, &now);

		uint64_t tdown_ms = time_down.tv_sec * 1000 + time_down.tv_nsec / 1000000;

		uint64_t tnow_ms  = now.tv_sec * 1000 + now.tv_nsec / 1000000;

		if (tdown_ms != 0 && (tnow_ms - tdown_ms) >= MS_PWR_BUTTON_DOWN) {

			led_on(BOARD_LED_BLUE);

			up_mdelay(200);
			stm32_pwr_enablebkp(true);
			/* XXX wow, this is evil - write a magic number into backup register zero */
			*(uint32_t *)0x40002850 = 0xdeaddead;
			stm32_pwr_enablebkp(false);
			up_mdelay(50);
			up_systemreset();

			while (1);
		}
	}

	return OK;
}
Exemplo n.º 26
0
/**
 * ggrbug mode
 * - simulate geiger counter sounds
 */
static void geiger(void)
{
	uint8_t max = 200;
	uint8_t min = 10;

	static timer_t mytimer;
	static bool blink;
	if (mode_uninitialized) {
		init_leds();
		music_setNote(NOTE_PAUSE, 0);
		mode_uninitialized = false;
		timer_set(&mytimer, 10);
		blink = false;
	};
	if (timer_expired(&mytimer)) {
		if (!blink) {
			/*lets blink*/
			int i = (rand() % 3);
			switch (i) {
				case 0: led_on(LED_L); break;
				case 1: led_on(LED_R); break;
				default: led_on(LED_L | LED_R); break;
			};
			if (rand() % 10 > 8)
				set_motor(MOTOR_ON);
			music_setNote(NOTE_C, 5);
			timer_set(&mytimer, 2);
			blink = true;
		} else {
			/*stop blink*/
			led_off(LED_L | LED_R);
			set_motor(MOTOR_OFF);
			music_setNote(NOTE_PAUSE, 0);
			timer_set(&mytimer, (rand() % (max - min)) + min);
			blink = false;
		}

	}//end if timer_expired

}
Exemplo n.º 27
0
static int board_button_irq(int irq, FAR void *context)
{
	static struct timespec time_down;

	if (board_pwr_button_down()) {

		led_on(BOARD_LED_RED);
		clock_gettime(CLOCK_REALTIME, &time_down);
		power_state_notification(PWR_BUTTON_DOWN);

	} else {

		power_state_notification(PWR_BUTTON_UP);

		led_off(BOARD_LED_RED);

		struct timespec now;

		clock_gettime(CLOCK_REALTIME, &now);

		uint64_t tdown_ms = time_down.tv_sec * 1000 + time_down.tv_nsec / 1000000;

		uint64_t tnow_ms  = now.tv_sec * 1000 + now.tv_nsec / 1000000;

		if (tdown_ms != 0 && (tnow_ms - tdown_ms) >= MS_PWR_BUTTON_DOWN) {

			led_on(BOARD_LED_BLUE);

			if (power_state_notification(PWR_BUTTON_REQUEST_SHUT_DOWN) == PWR_BUTTON_RESPONSE_SHUT_DOWN_NOW) {
				up_mdelay(200);
				board_shutdown();
			}

		} else {
			power_state_notification(PWR_BUTTON_IDEL);
		}
	}

	return OK;
}
Exemplo n.º 28
0
/**
 * @brief Timer event handler for PWM.
 *
 * @param[in] p_context             General purpose pointer. Will be passed to the time-out handler
 *                                  when the timer expires.
 *
 */
static void pwm_timeout_handler(void * p_context)
{
    ret_code_t err_code;
    uint8_t duty_cycle;
    
    low_power_pwm_t * p_pwm_instance = (low_power_pwm_t *)p_context;
    
    p_pwm_instance->pwm_state = NRF_DRV_STATE_INITIALIZED;
    
    if(p_pwm_instance->evt_type == LOW_POWER_PWM_EVENT_PERIOD)
    {        
        if (p_pwm_instance->handler)
        {
            p_pwm_instance->handler(p_pwm_instance);
        }
        
        duty_cycle = p_pwm_instance->duty_cycle;
        
        if(duty_cycle == p_pwm_instance->period)    // Process duty cycle 100%
        {
            led_on(p_pwm_instance);
            p_pwm_instance->timeout_ticks = p_pwm_instance->period + APP_TIMER_MIN_TIMEOUT_TICKS;
        }
        else if (duty_cycle == 0)   // Process duty cycle 0%
        {
            led_off(p_pwm_instance);
            p_pwm_instance->timeout_ticks = p_pwm_instance->period + APP_TIMER_MIN_TIMEOUT_TICKS;
        }
        else // Process any other duty cycle than 0 or 100%
        {
            led_on(p_pwm_instance);
            p_pwm_instance->timeout_ticks = ((duty_cycle*p_pwm_instance->period)>>8) +
                                APP_TIMER_MIN_TIMEOUT_TICKS;
            // setting next state
            p_pwm_instance->evt_type = LOW_POWER_PWM_EVENT_DUTY_CYCLE;
        }
    }
    else
    {
Exemplo n.º 29
0
void usbModuleDisable(void)
{
	wait_ms(100);
	led_off();
	/* ==== Interrupt mask level change ==== */
	set_imask(15);				//(0x000000F0);

	/* USBコントローラディセーブル */
	INTC.IPR10.BIT._USB = 0;	/* Set USB interrupt level */
	USB.SYSCFG.WORD = 0x0481;	/* DPRUP off */
	wait_ms(30);
	USB.SYSCFG.WORD = 0x0401;	/* HSE off */
	wait_ms(30);
	USB.SYSCFG.WORD = 0x0400;	/* USB off */
	wait_ms(30);
	USB.SYSCFG.WORD = 0x0;		/* SCKE off */
	usb_reset_module();			/* USBモジュール リセット */

	wait_ms(1200);
	INTC.IBNR.WORD = 0x0000;	/* レジスタバングディセーブル */
	cache_disable();
}
Exemplo n.º 30
0
void* led(void *data) {
	dev = open("/dev/led", O_WRONLY);

	if (dev != -1) {
		while(active_mode){
			if (communicating == 1){
				led_on();
				usleep(50000);
				led_shuffle();
			} 
			else {
				led_off();
			}
		}
		close(dev);
	} 
		else {
		printf( "Device Open ERROR!\n");
		exit(1);
	}

}