/** \brief Configures touch library and measurement setup
*
* @pre Interrupts must be enabled in order to trigger regular measurements
* The touch configuration requires a fixed CPU speed to work properly in this
* case we need 2 MHz.
*/
void touch_init(void)
{
#ifdef QTOUCH_STUDIO_MASKS
SNS_array[0][0] = 0x40;
SNS_array[0][1] = 0x0;
SNS_array[1][0] = 0x0;
SNS_array[1][1] = 0x0;
SNSK_array[0][0] = 0x80;
SNSK_array[0][1] = 0x0;
SNSK_array[1][0] = 0x0;
SNSK_array[1][1] = 0x0;
#endif
config_sensor();
qt_init_sensing();
qt_set_parameters();
init_timer_isr();
/* Set up callback function. This function is called after the library
* has made capacitive measurements, but before it has processed them.
* The user can use this hook to apply filter functions to the measured
* signal values.(Possibly to fix sensor layout faults)
*/
qt_filter_callback = 0;
#ifdef _DEBUG_INTERFACE_
QDebug_Init();
#endif
}
/*============================================================================
Name : main
------------------------------------------------------------------------------
Purpose : main code entry point
Input :
Output :
Notes :
============================================================================*/
int main( void )
{
/*status flags to indicate the re-burst for library*/
uint16_t status_flag = 0u;
uint16_t burst_flag = 0u;
#ifdef QTOUCH_STUDIO_MASKS
SNS_array[0]=0x01;
SNS_array[1]=0x00;
SNSK_array[0]=0x02;
SNSK_array[1]=0x00;
#endif
/* initialise host app, pins, watchdog, etc */
init_system();
/* Configure the Sensors as keys or Keys With Rotor/Sliders in this function */
config_sensors();
/* initialise touch sensing */
qt_init_sensing();
/* Set the parameters like recalibration threshold, Max_On_Duration etc in this function by the user */
qt_set_parameters( );
/* configure timer ISR to fire regularly */
init_timer_isr();
/* Address to pass address of user functions */
/* This function is called after the library has made capacitive measurements,
* but before it has processed them. The user can use this hook to apply filter
* functions to the measured signal values.(Possibly to fix sensor layout faults) */
qt_filter_callback = 0;
/* enable interrupts */
__enable_interrupt();
/* loop forever */
for( ; ; )
{
if( time_to_measure_touch )
{
/* clear flag: it's time to measure touch */
time_to_measure_touch = 0u;
do {
/* one time measure touch sensors */
status_flag = qt_measure_sensors( current_time_ms_touch );
burst_flag = status_flag & QTLIB_BURST_AGAIN;
/*Time critical host application code goes here*/
}while ( burst_flag) ;
}
/* Time Non-critical host application code goes here */
}
}
int main( void )
{
/* initialise host app, pins, watchdog, etc */
init_system();
/* configure timer ISR to fire regularly */
init_timer_isr();
/* Initialize Touch sensors */
touch_init();
/* loop forever */
for( ; ; )
{
touch_measure();
/* Time Non-critical host application code goes here */
}
}
/**************************************************************************//**
* \brief Initialize QTouch.
******************************************************************************/
void BSP_InitQTouch(BSP_TouchEventHandler_t handler)
{
/* initialise host app, pins, watchdog, etc */
init_system();
/* Reset touch sensing */
qt_reset_sensing();
/*Configure Burst Length*/
burst_len_config();
config_sensors();
/* Initialise and set touch params */
qt_init_sensing();
qt_set_parameters();
init_timer_isr();
buzzer_init();
/* Address to pass address of user functions */
/* This function is called after the library has made capacitive
* measurements,
* but before it has processed them. The user can use this hook to
* apply filter
* functions to the measured signal values.(Possibly to fix sensor
* layout faults) */
/* This function is also used to send signal values to simulate Accelero
* meter,
* Just for demo purpose */
qt_filter_callback = qt_avr477_filter_cb;
cpu_irq_enable();
handler = handler;
}
int main( void )
{
/*status flags to indicate the re-burst for library*/
uint16_t status_flag = 0u;
uint16_t burst_flag = 0u;
/* initialise host app, pins, watchdog, etc */
init_system();
/* Configure the Sensors as keys or Keys With Rotor/Sliders in this function */
config_sensors();
/* initialise touch sensing */
qt_init_sensing();
/* Set the parameters like recalibration threshold, Max_On_Duration etc in this function by the user */
qt_set_parameters( );
/* configure timer ISR to fire regularly */
init_timer_isr();
#ifdef _DEBUG_INTERFACE_
timestamp1_hword = current_time_ms_touch;
timestamp1_lword = (uint16_t)TIMER_COUNTER_L;
timestamp1_lword |= (uint16_t)(TIMER_COUNTER_H << 8);
#endif
/* Address to pass address of user functions */
/* This function is called after the library has made capacitive measurements,
* but before it has processed them. The user can use this hook to apply filter
* functions to the measured signal values.(Possibly to fix sensor layout faults) */
qt_filter_callback = 0;
#ifdef _DEBUG_INTERFACE_
QDebug_Init();
#endif
/* enable interrupts */
__enable_interrupt();
#ifdef _DEBUG_INTERFACE_
/* Process commands from PC */
QDebug_ProcessCommands();
#endif
/* loop forever */
for( ; ; )
{
if( time_to_measure_touch )
{
/* clear flag: it's time to measure touch */
time_to_measure_touch = 0u;
do {
#ifdef _DEBUG_INTERFACE_
timestamp2_hword = current_time_ms_touch;
timestamp2_lword = (uint16_t)TIMER_COUNTER_L;
timestamp2_lword |= (uint16_t)(TIMER_COUNTER_H << 8);
#endif
/* one time measure touch sensors */
status_flag = qt_measure_sensors( current_time_ms_touch );
#ifdef _DEBUG_INTERFACE_
timestamp3_hword = current_time_ms_touch;
timestamp3_lword = (uint16_t)TIMER_COUNTER_L;
timestamp3_lword |= (uint16_t)(TIMER_COUNTER_H << 8);
#endif
burst_flag = status_flag & QTLIB_BURST_AGAIN;
#ifdef _DEBUG_INTERFACE_
/* send debug data */
QDebug_SendData(status_flag);
#endif
/*Time critical host application code goes here*/
}while ( burst_flag) ;
}
#ifdef _DEBUG_INTERFACE_
/* Process commands from PC */
QDebug_ProcessCommands();
#endif
/* Time Non-critical host application code goes here */
}
}
/**
* \brief getting-started Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
/*Status flags to indicate the re-burst for library */
uint16_t status_flag = 0u;
uint16_t burst_flag = 0u;
/* Initialize the SAM system */
init_system();
/* Reset touch sensing */
qt_reset_sensing();
/* Configure the Sensors as keys or Keys With Rotor/Sliders in this
function */
config_sensors();
/* Initialize touch sensing */
qt_init_sensing();
/* Set the parameters like recalibration threshold, Max_On_Duration etc
in this function by the user */
qt_set_parameters();
/* Configure timer ISR to fire regularly */
init_timer_isr();
/* Address to pass address of user functions */
/* This function is called after the library has made capacitive
measurements, but before it has processed them. The user can
use this hook to apply filter functions to the measured signal
values.(Possibly to fix sensor layout faults) */
qt_filter_callback = 0;
/* Loop forever */
for (;;) {
if (time_to_measure_touch) {
/* Clear flag: it's time to measure touch */
time_to_measure_touch = 0u;
do {
/* One time measure touch sensors */
status_flag = qt_measure_sensors
(current_time_ms_touch);
burst_flag = status_flag & QTLIB_BURST_AGAIN;
/*Time critical host application code goes here */
} while (burst_flag);
}
/* Get slider value and update the blink frequency */
if (GET_ROTOR_SLIDER_POSITION(0) != qt_shift_data) {
qt_shift_data = GET_ROTOR_SLIDER_POSITION(0);
#ifdef QT_DATA_REVERT
configure_tc((QT_MAX_DATA - qt_shift_data)/LED_FREQ_DIV);
#else
configure_tc(qt_shift_data/LED_FREQ_DIV);
#endif
}
}
}
int main( void )
{
init_system(); // initialise host app, pins, watchdog, etc
init_timer_isr(); // configure timer ISR to fire regularly
softuart_init();
softuart_puts("\nbattir3\n");
ir_init();
i2c_init();
blinkm_stop();
blinkm_setRGB( 0,0,0 );
_delay_ms(300);
// a little hello fanfare
for( int i=0;i<2; i++ ) {
softuart_printHex16( i );
softuart_puts("!");
blinkm_setRGB( 0x02,0x02,0x02);
_delay_ms(50);
blinkm_setRGB( 0x01,0x01,0x01);
_delay_ms(50);
}
blinkm_setRGB( 0,0,0 );
blinkm_playScript(0,0);
sei(); // enable interrupts
softuart_puts(":\n");
int power_on = 1;
// loop forever
for( ; ; ) {
if( time_to_measure ) {
time_to_measure = 0; // clear flag: time to measure touch
uint16_t key = ir_getkey();
if( key==0 ) // no key
continue;
softuart_puts("k:");
softuart_printHex16( key );
softuart_putc('\n');
if( key == IRKEY_ONE ) {
blinkm_fadeToRGB( 0xff,0x00,0x00 );
}
else if( key == IRKEY_TWO ) {
blinkm_fadeToRGB( 0x00,0xff,0x00 );
}
else if( key == IRKEY_THREE ) {
blinkm_fadeToRGB( 0x00,0x00,0xff );
}
else if( key == IRKEY_FOUR ) {
blinkm_fadeToRGB( 0xff,0xff,0x00 );
}
else if( key == IRKEY_FIVE ) {
blinkm_fadeToRGB( 0x00,0xff,0xff );
}
else if( key == IRKEY_SIX ) {
blinkm_fadeToRGB( 0xff,0x00,0xff );
}
else if( key == IRKEY_SEVEN ) {
blinkm_fadeToRGB( 0x11,0x11,0x11 );
}
else if( key == IRKEY_EIGHT ) {
blinkm_fadeToRGB( 0x80,0x80,0x80 );
}
else if( key == IRKEY_NINE ) {
blinkm_fadeToRGB( 0xff,0xff,0xff );
}
else if( key == IRKEY_ZERO ) {
blinkm_fadeToRGB( 0x00,0x00,0x00 );
}
else if( key == IRKEY_VOLUP ) {
blinkm_setFadespeed( 80 );
}
else if( key == IRKEY_VOLDN ) {
blinkm_setFadespeed( 5 );
}
else if( key == IRKEY_POWER ) {
if( power_on ) {
blinkm_stop();
blinkm_fadeToRGB( 0x00,0x00,0x00 );
power_on = 0;
} else {
blinkm_playScript(0,0);
power_on = 1;
}
_delay_ms(500); // arbitrary wait to approximate key debounce
}
else if( key == IRKEY_PLAY ) {
blinkm_playScript( 0, 0 );
}
}
} // for
}
int main(void)
{
/*Status flags to indicate the re-burst for library */
uint16_t status_flag = 0u;
uint16_t burst_flag = 0u;
uint8_t lft_pressed = 0;
uint8_t rgt_pressed = 0;
static uint8_t old_position = 0;
uint8_t uc_char;
uint8_t uc_flag;
sysclk_init();
board_init();
configure_buttons();
configure_hall();
wdt_disable(WDT);
pmc_enable_periph_clk(ID_PIOC);
qt_reset_sensing();
config_sensors();
qt_init_sensing();
/* Set the parameters like recalibration threshold, Max_On_Duration etc in this function by the user */
qt_set_parameters();
init_timer_isr();
qt_filter_callback = 0;
configure_console();
printf(STRING_HEADER);
configure_lcd();
g_pwm_channel = configure_pwm();
/* Cabeçalho do lcd */
pos_lcd_x = 20;
pos_lcd_y = 40;
start_lcd(pos_lcd_x, pos_lcd_y, ul_duty, hall_1, hall_2, hall_3, phase);
/* Infinite loop */
while (1) {
static uint8_t phase_aux;
static uint32_t hall_1_aux, hall_2_aux, hall_3_aux, ul_duty_aux;
/* Atualiza o display somente quando houver alteração nas variáveis que serão apresentadas */
if(ul_duty_aux != ul_duty)
{
escreve_int_lcd("dc = ", ul_duty*100/PERIOD_VALUE, pos_lcd_x, 40);
ul_duty_aux = ul_duty;
}
if(phase_aux != phase || hall_1_aux != hall_1 || hall_2_aux != hall_2 || hall_3_aux != hall_3)
{
escreve_int_lcd("hall1 = ", hall_1, pos_lcd_x, 60);
escreve_int_lcd("hall2 = ", hall_2, pos_lcd_x, 80);
escreve_int_lcd("hall3 = ", hall_3, pos_lcd_x, 100);
escreve_int_lcd("phase = ", phase, pos_lcd_x, 120);
phase_aux = phase;
hall_1_aux = hall_1;
hall_2_aux = hall_2;
hall_3_aux = hall_3;
}
if(motor_run == 0 && ul_duty != 0)
Hall_Phase();
uc_char = 0;
uc_flag = uart_read(CONSOLE_UART, &uc_char);
if (!uc_flag) {
if (uc_char == 't') {
printf(" duty cicle = %lu \r\n",ul_duty*100/PERIOD_VALUE);
printf(" hall1 = %lu \r\n", hall_1);
printf(" hall2 = %lu \r\n", hall_2);
printf(" hall3 = %lu \r\n", hall_3);
printf(" phase = %u \r\n\n", phase);
}
if (uc_char == 'a'){
if(ul_duty < PERIOD_VALUE) ul_duty++;
printf(" duty cicle = %lu \r\n",ul_duty*100/PERIOD_VALUE);
}
if (uc_char == 's'){
if(ul_duty > INIT_DUTY_VALUE) ul_duty--;
printf(" duty cicle = %lu \r\n",ul_duty*100/PERIOD_VALUE);
}
if (uc_char == 'd')
{
ensaio = 1;
printf(" Ensaio de rampa\r\n");
printf(" para parar pressione a letra 'P'\r\n");
}
if (uc_char == 'f')
{
ensaio = 2;
printf(" Ensaio de degrau\r\n");
printf(" para parar pressione a letra 'P'\r\n");
}
if (uc_char == 'p')
{
ensaio = 0;
ul_duty = 0;
}
if (uc_char == 'i')
{
sel_rot = !sel_rot;
printf(" Rotacao invertida\r\n");
printf(" para parar pressione a letra 'P'\r\n");
}
}
if (time_to_measure_touch) {
/* Clear flag: it's time to measure touch */
time_to_measure_touch = 0u;
do {
/* One time measure touch sensors */
status_flag = qt_measure_sensors(current_time_ms_touch);
burst_flag = status_flag & QTLIB_BURST_AGAIN;
/*Time critical host application code goes here */
} while (burst_flag);
}
/* Time Non-critical host application code goes here */
if ((GET_SENSOR_STATE(BOARD_LEFT_KEY_ID) != 0)
&& (lft_pressed == 0)) {
lft_pressed = 1;
if(ul_duty > INIT_DUTY_VALUE) ul_duty--;
printf(" duty cicle = %lu \r\n",ul_duty*100/PERIOD_VALUE);
} else {
if ((GET_SENSOR_STATE(BOARD_LEFT_KEY_ID) == 0)
&& (lft_pressed == 1)) {
lft_pressed = 0;
}
}
if ((GET_SENSOR_STATE(BOARD_RIGHT_KEY_ID) != 0)
&& (rgt_pressed == 0)) {
rgt_pressed = 1;
if(ul_duty < PERIOD_VALUE) ul_duty++;
printf(" duty cicle = %lu \r\n",ul_duty*100/PERIOD_VALUE);
} else {
if ((GET_SENSOR_STATE(BOARD_RIGHT_KEY_ID) == 0)
&& (rgt_pressed == 1)) {
rgt_pressed = 0;
}
}
if (GET_ROTOR_SLIDER_POSITION(0) != old_position) {
old_position = GET_ROTOR_SLIDER_POSITION(0);
if (motor_run==0) flag_hab_m = 1;
ul_duty = old_position*PERIOD_VALUE/255;
}
}
}
/**
* \brief Main Application Code
* - Initialize the system clocks
* - Initialize the touch functions
* - Initialize the timer
* - if debug interface is enabled, initialize the qdebug commmands
* - When touch status in detect, Set the led & send data to QTouch Studio
*/
int main (void)
{
// status flags to indicate the re-burst for library
uint16_t status_flag = 0u;
uint16_t burst_flag = 0u;
/**
* \brief Initialize the system clock
* Clock settings are done in cof_clock.h
* It sets the cpu to run at crystal frequency
* which uses OSC0 as souce
*/
sysclk_init();
//! Initializes the functions necessary for QTouch
qtouch_init();
//! Configure the timer ISR to fire regularly for QTouch Acquisition
init_timer_isr();
//! Address to pass address of user functions
/**
* \brief This function is called after the library has made
* capacitive measurements, but before it has processed them.
* The user can use this hook to apply filter functions to the measured
* signal values.(Possibly to fix sensor layout faults)
*/
qt_filter_callback = 0;
#ifdef _DEBUG_INTERFACE_
// Initialize QDebug protocol
QDebug_Init();
#endif
// Enable global interrupts
cpu_irq_enable();
#ifdef _DEBUG_INTERFACE_
// Process commands from PC
QDebug_ProcessCommands();
#endif
// loop forever
for( ; ; ) {
if( time_to_measure_touch ) {
if( qt_measure_data.qt_touch_status.sensor_states[0]) {
gpio_clr_gpio_pin(STATUS_LED);
} else {
gpio_set_gpio_pin(STATUS_LED);
}
// clear flag: it's time to measure touch
time_to_measure_touch = 0u;
do {
// one time measure touch sensors
status_flag = qt_measure_sensors( current_time_ms_touch );
burst_flag = status_flag & QTLIB_BURST_AGAIN;
/*Time critical host application code goes here*/
#ifdef _DEBUG_INTERFACE_
// send debug data
QDebug_SendData(status_flag);
#endif
} while (burst_flag) ;
#ifdef _DEBUG_INTERFACE_
// Process commands from PC
QDebug_ProcessCommands();
#endif
}
// Time Non-critical host application code goes here
} //end of loop forever
} // end of main
