int main(void)
{
struct mxt_device device; /* Device data container */
/* Initialize the USART configuration struct */
const usart_serial_options_t usart_serial_options = {
.baudrate = USART_SERIAL_EXAMPLE_BAUDRATE,
.charlength = USART_SERIAL_CHAR_LENGTH,
.paritytype = USART_SERIAL_PARITY,
.stopbits = USART_SERIAL_STOP_BIT
};
sysclk_init(); /* Initialize system clocks */
board_init(); /* Initialize board */
/* Initialize the mXT touch device */
mxt_init(&device);
/* Initialize stdio on USART */
stdio_serial_init(USART_SERIAL_EXAMPLE, &usart_serial_options);
printf("\n\rmaXTouch data USART transmitter\n\r");
while (true) {
/* Check for any pending messages and run message handler if any
* message is found in the queue */
if (mxt_is_message_pending(&device)) {
mxt_handler(&device);
}
}
return 0;
}
/**
* \brief Handle maXTouch messages
*
* This function handles the maXTouch messages, triggering the drawing of
* squares around new or moved touches, and removing the squares around
* released touches.
*
* \param device Pointer to mxt_device struct
*/
static void mxt_handler(struct mxt_device *device)
{
static struct finger fingers[MAX_TOUCHES];
static const gfx_color_t finger_colors[MAX_TOUCHES] = {
GFX_COLOR_RED,
GFX_COLOR_GREEN,
GFX_COLOR_BLUE,
GFX_COLOR_CYAN,
GFX_COLOR_YELLOW,
GFX_COLOR_MAGENTA,
GFX_COLOR_WHITE,
GFX_COLOR_GRAY,
};
struct mxt_touch_event touch_event;
struct finger *curr_finger;
uint8_t finger_index;
do {
/* Get the first touch event in queue */
if (mxt_read_touch_event(device, &touch_event) != STATUS_OK) {
continue;
}
/* Discard non press, movement or release events */
if (!(touch_event.status &
(MXT_PRESS_EVENT | MXT_MOVE_EVENT | MXT_RELEASE_EVENT))) {
continue;
}
/* Use the touch ID as finger index */
finger_index = touch_event.id;
/* Skip if touch ID is out of bounds */
if (!(finger_index < MAX_TOUCHES)) {
continue;
}
/* Get address of current finger info struct */
curr_finger = &fingers[finger_index];
/* If finger already registered (and thus drawn), clear it on the display */
if (curr_finger->enable) {
draw_finger_square(curr_finger, DISPLAY_COLOR);
}
/* Update finger info - finger is enabled unless it was released */
curr_finger->enable = !(touch_event.status & MXT_RELEASE_EVENT);
/* If the finger is now enabled, we need to update its position and redraw */
if (curr_finger->enable) {
/* Compute new display coordinates from touch coordinates */
get_finger_display_coordinates(&touch_event, curr_finger);
/* Draw updated representation on the display */
draw_finger_square(curr_finger,
finger_colors[finger_index]);
}
} while (mxt_is_message_pending(device));
}
/**
* \brief Main application function
*
* This function executes the necessary initialization calls and displays the
* demo widgets before entering the main work loop of the application.
*
* The main work loop reads out the touch events from the mXT143E Xplained and
* enqueues the corresponding touch events in the window system, before
* processing the window system's event queue.
*/
int main(void)
{
static struct mxt_device device;
board_init();
sysclk_init();
membag_init();
gfx_init();
mxt_init(&device);
win_init();
setup_root_window();
app_widget_launch();
while (true) {
/* Process received messages from the maXTouch device */
while (mxt_is_message_pending(&device)) {
struct mxt_touch_event touch_event;
struct win_pointer_event win_touch_event;
/* Get the first touch event in queue */
if (mxt_read_touch_event(&device,
&touch_event) != STATUS_OK) {
continue;
}
/* Translate touch event type into a WTK event type */
if (touch_event.status & MXT_PRESS_EVENT) {
win_touch_event.type = WIN_POINTER_PRESS;
} else if (touch_event.status & MXT_MOVE_EVENT) {
win_touch_event.type = WIN_POINTER_MOVE;
} else if (touch_event.status & MXT_RELEASE_EVENT) {
win_touch_event.type = WIN_POINTER_RELEASE;
} else {
continue;
}
/* Indicate the touch event is a non-relative movement
* with the virtual touch button pressed
*/
win_touch_event.is_relative = false;
win_touch_event.buttons = WIN_TOUCH_BUTTON;
/* Translate the touch X and Y position into a screen
* coordinate
*/
win_touch_event.pos.x =
((uint32_t)(4096 - touch_event.x) * gfx_get_width()) / 4096;
win_touch_event.pos.y =
((uint32_t)(4096 - touch_event.y) * gfx_get_height()) / 4096;
win_queue_pointer_event(&win_touch_event);
}
/* Process queued events in the windowing system */
win_process_events();
}
}
/**
* \brief Convert touch events from the touchscreen into window pointer events
*
* Reads touch events in from the touchscreen and converts them into a
* Window Manager pointer event, for enqueuing into the window event queue.
*
* \return Boolean true if a touch event was read, false if no touch event
* or a corrupt touch event was received
*/
static bool read_touch_event(struct mxt_device *device,
struct win_pointer_event *win_touch_event)
{
struct mxt_touch_event touch_event;
/* Abort if no touch event is pending */
if (!(mxt_is_message_pending(device))) {
return false;
}
/* Get the first touch event in queue */
if (mxt_read_touch_event(device, &touch_event) != STATUS_OK) {
return false;
}
/* Translate touch event type into a WTK event type */
if (touch_event.status & MXT_PRESS_EVENT) {
win_touch_event->type = WIN_POINTER_PRESS;
} else if (touch_event.status & MXT_MOVE_EVENT) {
win_touch_event->type = WIN_POINTER_MOVE;
} else if (touch_event.status & MXT_RELEASE_EVENT) {
win_touch_event->type = WIN_POINTER_RELEASE;
} else {
return false;
}
/* Indicate the touch event is a non-relative movement with the virtual
* touch button pressed
*/
win_touch_event->is_relative = false;
win_touch_event->buttons = WIN_TOUCH_BUTTON;
/* Translate the touch X and Y position into a screen coordinate */
win_touch_event->pos.x =
((uint32_t)(4096 - touch_event.x) * gfx_get_width()) / 4096;
win_touch_event->pos.y =
((uint32_t)(4096 - touch_event.y) * gfx_get_height()) / 4096;
return true;
}
static void mxt_handler(struct mxt_device *device)
{
/* USART tx buffer initialized to 0 */
char tx_buf[STRING_LENGTH * MAX_ENTRIES] = {0};
uint8_t i = 0; /* Iterator */
/* Temporary touch event data struct */
struct mxt_touch_event touch_event;
/* Collect touch events and put the data in a string,
* maximum 2 events at the time */
do {
/* Temporary buffer for each new touch event line */
char buf[STRING_LENGTH];
/* Read next next touch event in the queue, discard if read fails */
if (mxt_read_touch_event(device, &touch_event) != STATUS_OK) {
continue;
}
/* Format a new entry in the data string that will be sent over USART */
sprintf(buf, "Nr: %1d, X:%4d, Y:%4d, Status:0x%2x\n\r",
touch_event.id, touch_event.x, touch_event.y,
touch_event.status);
/* Add the new string to the string buffer */
strcat(tx_buf, buf);
i++;
/* Check if there is still messages in the queue and
* if we have reached the maximum numbers of events */
} while ((mxt_is_message_pending(device)) & (i < MAX_ENTRIES));
/* If there is any entries in the buffer, send them over USART */
if (i > 0) {
usart_serial_write_packet(USART_SERIAL_EXAMPLE, (uint8_t *)tx_buf, strlen(tx_buf));
}
}
/**
* \brief Main application loop
*
* This is the main application function, which runs all the initialization
* code, clears the display and enters a loop in which it continuously polls for
* new messages from the maXTouch device. If one or more messages are pending,
* the maXTouch message handler is invoked.
*/
int main(void)
{
/* maXTouch data structure */
static struct mxt_device device;
/* Basic init routines */
board_init();
sysclk_init();
gfx_init();
mxt_init(&device);
/* Clear the display */
gfx_draw_filled_rect(0, 0, gfx_get_width(), gfx_get_height(),
DISPLAY_COLOR);
while (true) {
/* Check for any pending messages and run message handler if any
* message is found in the queue */
if (mxt_is_message_pending(&device)) {
mxt_handler(&device);
}
}
}
/**
* \brief Main application loop
*
* This is the main application function, which runs all the initialization
* code, clears the display and enters a loop in which it continuously polls
* for new messages from the maXTouch device. If one or more messages are
* pending, the maXTouch message handler is invoked.
*/
int main(void)
{
/* maXTouch data structure */
static struct mxt_device device;
/* Basic init routines */
board_init();
sysclk_init();
gfx_init();
mxt_init(&device);
/* Draw the paint pallet to the display */
draw_paint_pallet();
/* Draw instructions to the display */
gfx_draw_string_aligned(
"Select a color from the pallet below, and\n"
"use your finger(s) to draw onto the display.\n\n"
"Multiple simultaneous fingers are supported,\n"
"and the drawing size varies according to the\n"
"pressure of the touch.\n\n"
"Select MUL to draw using multiple colors.\n\n"
"Select CLR to clear the display.",
gfx_get_width() / 2,
(gfx_get_height() - PALLET_HEIGHT) / 2,
&sysfont, GFX_COLOR_TRANSPARENT, GFX_COLOR_WHITE,
TEXT_POS_CENTER, TEXT_ALIGN_LEFT);
while (true) {
/* Check for any pending messages and run message handler if any
* message is found in the queue */
if (mxt_is_message_pending(&device)) {
mxt_handler(&device);
}
}
}
/**
* \brief Handle maXTouch messages
*
* This function handles the maXTouch messages, triggering the drawing of
* squares around new or moved touches, and removing the squares around
* released touches.
*
* \param device Pointer to mxt_device struct
*/
static void mxt_handler(struct mxt_device *device)
{
struct mxt_touch_event touch_event;
gfx_coord_t screen_touch_x, screen_touch_y, screen_touch_size;
do {
/* Get the first touch event in queue */
if (mxt_read_touch_event(device, &touch_event) != STATUS_OK) {
continue;
}
/* Discard non press, movement or release events */
if (!(touch_event.status &
(MXT_PRESS_EVENT | MXT_MOVE_EVENT | MXT_RELEASE_EVENT))) {
continue;
}
/* Rescale from 4k touch X-coordinate to the display width */
screen_touch_x = ((uint32_t)(4096 - touch_event.x) * gfx_get_width()) / 4096;
/* Rescale from 4k touch Y-coordinate to the display height */
screen_touch_y = ((uint32_t)(4096 - touch_event.y) * gfx_get_height()) / 4096;
/* Scale the touch size to a value suitable for the target display */
screen_touch_size = touch_event.size;
/* Check if the touch is within the drawing area */
if (screen_touch_y < (gfx_get_height() - PALLET_HEIGHT)) {
/* Obtain the color to draw from the pallet colors */
gfx_color_t draw_color = pallet_colors[selected_pallet_color];
/* Color pallet index 0 selects multi-color mode */
if (selected_pallet_color == 0) {
draw_color = get_next_rainbow_color();
}
/* Set clipping area */
gfx_set_clipping(0, 0, gfx_get_width(),
(gfx_get_height() - PALLET_HEIGHT - 2));
/* Draw touch point on the screen in the selected color */
gfx_draw_filled_circle(screen_touch_x, screen_touch_y,
screen_touch_size, draw_color, GFX_WHOLE);
/* Reset clipping area */
gfx_set_clipping(0, 0, gfx_get_width(), gfx_get_height());
} else if (touch_event.status & MXT_PRESS_EVENT) {
/* Calculate the pressed pallet entry */
uint8_t pallete_index = (screen_touch_x / PALLET_COLOR_WIDTH);
/* The last entry in the pallet clears the screen */
if (pallete_index == (NUM_PALLET_COLORS - 1)) {
/* Indicate display is being cleared */
draw_pallet_labels(true);
/* Clear the display */
gfx_draw_filled_rect(0, 0, gfx_get_width(),
(gfx_get_height() - PALLET_HEIGHT - 1),
GFX_COLOR_BLACK);
/* Indicate display has been cleared */
draw_pallet_labels(false);
} else {
/* Change color selection based on the color chosen */
selected_pallet_color = pallete_index;
/* Draw new selection box around chosen color */
update_pallet_selection();
}
}
} while (mxt_is_message_pending(device));
}
/**
* \brief Main application function
*
* This function ensures that the hardware and drivers are initialized before
* entering an infinite work loop.
*
* In the work loop, the maXTouch device is polled for new touch events and any
* new event is passed on to the user interface implementation for processing.
* The loop then attempts to enter sleep.
*
* The user interface processing itself is not started by the work loop, but by
* the USB callback function for start of frame.
*/
int main(void)
{
#ifdef USB_DEVICE_LOW_SPEED
uint16_t virtual_sof_sub;
uint16_t virtual_sof;
#endif
/* maXTouch data structure */
static struct mxt_device device;
/* Initialize system clocks */
sysclk_init();
/* Initialize interrupt vectors */
irq_initialize_vectors();
/* Enable interrupts */
cpu_irq_enable();
/* Initialize the sleep manager */
sleepmgr_init();
/* Initialize the board */
board_init();
/* Initialize the mXT touch device */
mxt_init(&device);
/* Initialize the graphical library */
gfx_init();
/* Set correct landscape orientation */
gfx_set_orientation(GFX_SWITCH_XY | GFX_FLIP_Y);
/* Set background color */
gfx_draw_filled_rect(0, 0, gfx_get_width(), gfx_get_height(),
COLOR_BACKGROUND);
/* Draw the help text */
gfx_draw_string_aligned(
"Middle finger to move cursor\n"
"Index finger to left click\n"
"Ring finger to right click",
gfx_get_width() / 2, gfx_get_height() / 2,
&sysfont, GFX_COLOR_TRANSPARENT, GFX_COLOR_WHITE,
TEXT_POS_CENTER, TEXT_ALIGN_CENTER);
/* Initialize the user interface */
ui_init();
ui_powerdown();
/* Start USB stack to authorize VBus monitoring */
udc_start();
/* Check if there are any new touch data pending */
while (true) {
if (mxt_is_message_pending(&device)) {
if (mxt_read_touch_event(&device, &ui_touch_event) == STATUS_OK) {
ui_flag_new_touch_event();
}
}
/* Try to sleep */
sleepmgr_enter_sleep();
#ifdef USB_DEVICE_LOW_SPEED
/* No USB "Keep alive" interrupt available in low speed
* to scan mouse interface then use main loop */
if (main_b_mouse_enable) {
virtual_sof_sub = 0;
virtual_sof = 0;
if (virtual_sof_sub++ == 700) {
virtual_sof_sub = 0;
ui_process(virtual_sof++);
}
}
#endif
}
}