void ui_usb_sof_event(void)
{
	static uint16_t counter_sof = 0;

	if (ui_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof > ui_device_speed_blink) {
			counter_sof = 0;
			LED_Toggle(LED0_GPIO);
		}
	}
}

int Spark_Save_Firmware_Chunk(FileTransfer::Descriptor& file, const uint8_t* chunk, void* reserved)
{
    TimingFlashUpdateTimeout = 0;
    int result = -1;
    system_notify_event(firmware_update, firmware_update_progress, &file);
    if (file.store==FileTransfer::Store::FIRMWARE)
    {
        result = HAL_FLASH_Update(chunk, file.chunk_address, file.chunk_size, NULL);
        LED_Toggle(LED_RGB);
    }
    return result;
}

/****************************************************************************
 Function: LED_InvertBank

 Parameters
     bank: one of the #define'd LED_BANKx values.
     pattern: char, which LEDs to toggle.

 Returns
     char: SUCCESS or ERROR

 Description
     Forces the LEDs in (bank) to toggle for each bit that is high in the pattern.

 Notes: none.

 Author: Gabriel Hugh Elkaim, 2011.12.25 01:16
 ****************************************************************************/
char LED_InvertBank(unsigned char bank, unsigned char pattern) {
    char i;
    pattern &= FULLBANK;
    if (ledStatus.led_on == FALSE) return ERROR;
    if ((bank & LED_BANK1) && (ledStatus.one_on)) {
        for (i = 0; i < NUMLEDSPERBANK; i++) {
            if (pattern & (1 << i)) LED_Toggle(i);
        }
        return SUCCESS;
    }
    return ERROR;
}

void
SysTickHandler(void)
{
    g_ulTickCount++;
    cofanie++;

    if((g_ulTickCount % 100) == 0)
    {
        LED_Toggle(BOTH_LEDS);
    }
    PushButtonDebouncer();
    BumpSensorDebouncer();
}

int main( void )
{
  bsp_gpio_init();
  bsp_temp_init();
  bsp_serial_init(NULL);

  while (1) {
    LED_Toggle();
    delay_ms(100);

    printf("chip temperature : %.2f degC\r\n", TEMP_GetTemperature());
  }
}

void ui_usb_sof_event(void)
{
	bool b_btn_state;
	static bool btn_suspend = false;
	static uint16_t counter_sof = 0;
	static uint16_t counter_sof_move_refresh = 0;

	if (ui_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof > ui_device_speed_blink) {
			counter_sof = 0;
			if (ui_hid_mouse_plug || ui_msc_plug) {
				LED_Toggle(LED0);
			} else {
				LED_On(LED0);
			}
			if (ui_test_done && !ui_test_result) {
				/* Test fail then blink BL */
				backlight_toggle();
			}
		}
		/* Scan button to enter in suspend mode and remote wakeup */
		b_btn_state = (!ioport_get_pin_level(GPIO_PUSH_BUTTON_0)) ?
				true : false;
		if (b_btn_state != btn_suspend) {
			/* Button have changed */
			btn_suspend = b_btn_state;
			if (b_btn_state) {
				/* Button has been pressed */
				LED_Off(LED0);
				backlight_off();
				ui_enable_asynchronous_interrupt();
				uhc_suspend(true);
				return;
			}
		}

		/* Move the remote mouse pointer on the Board Monitor screen */
		if (++counter_sof_move_refresh > 100) {
			counter_sof_move_refresh = 0;
			bm_mouse_pointer_move(bm_x / 8, bm_y / 8);
		}

		/* Power on a LED when the mouse button down */
		if (ui_nb_down) {
			LED_On(LED0);
		}
	}
}

__interrupt
#endif
static void tc_irq(void)
{
	// Increment the ms seconds counter
	tc_tick++;

	// Clear the interrupt flag. This is a side effect of reading the TC SR.
	tc_read_sr(EXAMPLE_TC, EXAMPLE_TC_CHANNEL);

	// specify that an interrupt has been raised
	update_timer = true;
	// Toggle a GPIO pin (this pin is used as a regular GPIO pin).
	LED_Toggle(LED0);
}

void FastBlink()
{
	LED_Off(LED0|LED1|LED2|LED3);

	unsigned int counter = 0;

	while (1)
	{
		//if (counter % 1)
		LED_Toggle(LED0);

		if (counter % 2)
		LED_Toggle(LED1);

		if (counter % 4)
		LED_Toggle(LED2);

		if (counter % 8)
		LED_Toggle(LED3);

		counter++;
		cpu_delay_ms(2, FOSCRC);
	}
}

/**
 * \brief Main code entry point.
 */
int main( void )
{
	/* Prepare the hardware */
	prvSetupHardware();

	/* Usi initialization */
	usi_init();

	/* Initialize USI communication structure */
	x_phy_serial_msg.uc_protocol_type = PROTOCOL_USER_DEFINED;

	while (1) {
		usi_process();
		/* blink led 0 */
		if (b_led_swap) {
			b_led_swap = false;
#if (BOARD == SAM4CMP_DB || BOARD == SAM4CMS_DB)
			LED_Toggle(LED4);
#else
			LED_Toggle(LED0);
#endif
		}
	}
}

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  MX_IWDG_Init();
  for (;;) {
	  /* Fast blinking LED */
    __HAL_IWDG_RELOAD_COUNTER(&hiwdg);
    LED_Toggle();
	  HAL_Delay(70);
  }
  /* USER CODE END 6 */

}

/**
  * @brief  This function handles SysTick Handler.
  * @param  None
  * @retval None
  */
void SysTick_Handler(void)
{
	static uint8_t count_time=0;
  OS_TimeMS ++;
	
	count_time++;
	if(count_time == 10)
	{
		GUI_TOUCH_Exec();			//每10ms调用一次，触发调用触摸驱动
		count_time =0;
	}	
  
	LED_Toggle();						//每100ms反转一次led
	
	
}

void ui_usb_sof_event(void)
{
	static uint16_t counter_sof = 0;

	if (ui_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof > ui_device_speed_blink) {
			counter_sof = 0;
			LED_Toggle(LED_0_PIN);
			if (ui_test_done && !ui_test_result) {
				/* Test fail */
				LED_Off(LED_0_PIN);
			}
		}
	}
}

/****************************************************************************************************
 * @fn      I2C_Slave_Wait_Completion
 *          This function allows application to pend on completion for slave transfer
 *
 ***************************************************************************************************/
static void I2C_Slave_Wait_Completion( void )
{
    OS_RESULT result;
    static uint32_t dessimate = 0;

    result = os_evt_wait_or( I2C_SLAVE_XFER_DONE, MSEC_TO_TICS(500));
    if (result == OS_R_TMO)
    {
        dessimate++;
        if ((dessimate & 0x1) == 0)
        {
            SensorHubIntLow(); //Deassert Interrupt
            //D1_printf("\t### WARNING - Timedout on I2C Slave completion (%d) ###\r\n", dessimate);
            LED_Toggle(LED_YELLOW);
        }
    }
}

void ui_usb_sof_event(void)
{
	bool b_btn_state;
	static bool btn_suspend = false;
	static uint16_t counter_sof = 0;

	if (ui_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof > ui_device_speed_blink) {
			counter_sof = 0;
			if (ui_hid_mouse_plug || ui_msc_plug) {
				LED_Toggle(LED0);
			} else {
				LED_On(LED0);
			}
			if (ui_test_done) {
				if (ui_test_result) {
					/* Test successful */
					LED_On(LED0);
				} else {
					/* Test fail */
					LED_Off(LED0);
				}
			}
		}
		/* Scan button to enter in suspend mode and remote wakeup */
		b_btn_state = (!ioport_get_pin_level(GPIO_PUSH_BUTTON_0)) ?
				true : false;
		if (b_btn_state != btn_suspend) {
			/* Button have changed */
			btn_suspend = b_btn_state;
			if (b_btn_state) {
				/* Button has been pressed */
				LED_Off(LED0);
				ui_enable_asynchronous_interrupt();
				uhc_suspend(true);
				return;
			}
		}

		/* Power on a LED when the mouse button down */
		if (ui_nb_down) {
			LED_On(LED0);
		}
	}
}

portTASK_FUNCTION(LED_Run_Task, pvParameters)
{
	while(1)
	{
//		while (xSemaphoreTake(DALI_LEDs_Task_Signal, 10) == pdTRUE) // 10ms timeout
//		{
//			uint8_t i = 10;
//			while(i--)
//			{
//				DALI_LED_Toggle();
//				vTaskDelay(20);
//			}
//		}
		LED_Toggle();
		vTaskDelay(300);
	}
//	vTaskDelete(NULL);
}

int main(void) {
uint32_t t;
uint32_t sindex = 0;
int i;

    SystemCoreClockSet(MSI48M_CLOCKSRC,0,2,0);

    SysTick_Config(SystemCoreClock/1000);

    APBPeripheralClockSet(0,0); /* Enable APBx */

    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN; /* Enable SysConfig, Comp, etc. */

    t = LED_Init(LED_ALL);

    t = LCD_Init();

    result = t;

    LED_Toggle(LED_GREEN);

    LCD_WriteString("hello");
    Delay(10000);

    LCD_WriteSegments(allsegs);
    Delay(10000);

    LCD_WriteToRAM(alldispsegs);
    Delay(10000);


    LCD_Clear();


    for (;;) {
        for(i=0;i<6;i++) {
            segs[i] = sorder[sindex];
        }
        LCD_WriteSegments(segs);
        Delay(2000);
        sindex++;
        if( sindex >= sizeof(sorder)/sizeof(uint32_t)) sindex = 0;
    }
}

void ui_usb_sof_event(void)
{
	bool b_btn_state;
	static bool btn_suspend_and_remotewakeup = false;
	static uint16_t counter_sof = 0;

	if (ui_enum_status == UHC_ENUM_SUCCESS) {
		/* Display device enumerated and in active mode */
		if (++counter_sof > ui_device_speed_blink) {
			counter_sof = 0;
			LED_Toggle(LED_YELLOW0);
		}

		/* Scan button to enter in suspend mode and remote wakeup */
		/*b_btn_state = (!gpio_pin_is_high(GPIO_PUSH_BUTTON_1)) ?
		        true : false;*/
		b_btn_state = true;

		if (b_btn_state != btn_suspend_and_remotewakeup) {
			/* Button have changed */
			btn_suspend_and_remotewakeup = b_btn_state;

			if (b_btn_state) {
				/* Button has been pressed */
				ui_enable_asynchronous_interrupt();
				USBH_suspend(true);
				return;
			}
		}

		/* Power on a LED when the mouse move */
		if (!ui_x && !ui_y && !ui_scroll) {
#if 2 == LED_NUM
			LED_Clear(LED_YELLOW1);
#endif
		} else {
			ui_x = ui_y = ui_scroll = 0;
#if 2 == LED_NUM
			LED_Set(LED_YELLOW1);
#endif
		}
	}
}

/*! \brief Toggle LED
 */
int32_t toggle_led(uint32_t number_of_toggles)
{
	volatile uint32_t start_count, end_count;
	int32_t result = 0;

	start_count = Get_system_register(AVR32_COUNT);

	for (uint32_t i = 0; i < number_of_toggles; i++) {
		LED_Toggle(LED0);
	}

	end_count = Get_system_register(AVR32_COUNT);
	result = end_count - start_count;

	print(EXAMPLE_USART, "       - Number of cycles: ");
	print_ulong(EXAMPLE_USART, result);
	print(EXAMPLE_USART, "\r\n");

	return result;
}

/** \brief User prompt routine
 *
 * This routine prompts the user to press the button and then waits
 * for him to do so.
 */
static void prompt_user(char *prompt_string)
{
	/* Output prompt string */
	printf("%s\r\n", prompt_string);

	/* Wait for user to push button before continuing */
	LED_Off(ALL_LEDS);

	/* Just blink LED until button is pushed */
	while (!SWITCH_PRESSED) {
		LED_Toggle(PROMPT_LED);
		delay_ms(100);
	}

	LED_Off(PROMPT_LED);

	/* Wait until button is released */
	while (SWITCH_PRESSED) {
	}
}

int main(void)
{
    serial_init();
    printf("Hello world!\n");
    
    printf("Malloc 1024 bytes... ");
    int i = 0;
    char *data = malloc(1024 * sizeof(char));

    printf("[%s]\n", (data == NULL ? "FAIL" : " OK "));
    printf("Global var @ %p\n", external);
    printf("Local var  @ %p\n", &i);
    printf("Heap var   @ %p\n", data);

    while(1) {
        printf("Toggle! %d\n", i++);
        LED_Toggle(LED0);
        delay_ms(500);
    }
}