path: root/bsp/samd21/sam_d2x_asflib/common/services/adp/adp.h

/**
 * \file
 *
 * \brief ADP service implementation
 *
 * Copyright (C) 2015 Atmel Corporation. All rights reserved.
 *
 * \asf_license_start
 *
 * \page License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. The name of Atmel may not be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 4. This software may only be redistributed and used in connection with an
 *    Atmel microcontroller product.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * \asf_license_stop
 *
 */
/*
 * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
 */

#ifndef ADP_H_INCLUDED
#define ADP_H_INCLUDED

#include <compiler.h>

/** Version of ADP implemented here */
#define ADP_VERSION                 1

/** Start token for ADP data */
#define ADP_TOKEN                   0xFF

/** Maximum number of streams from PC to target */
#define ADP_MAX_INCOMMING_STREAMS   5
/** Maximum number of streams from target to PC */
#define ADP_MAX_OUTGOING_STREAMS    5

/** Maximum number of bytes target can request from PC in one request */
#define ADP_MAX_BYTE_REQUEST        20

/** Length of ADP packet header: Token, Message ID, Data Length */
#define ADP_LENGTH_PACKET_HEADER    4

/** Maximum number of bytes in data part of ADP packet */
#define ADP_MAX_PACKET_DATA_SIZE    254

/** Maximum number of all bytes in ADP packet */
#define  ADP_MAX_PACKET_LENGTH (ADP_LENGTH_PACKET_HEADER + ADP_MAX_PACKET_DATA_SIZE)

/** Key used to identify proper handshake message */
#define ADP_HANDSHAKE_KEY {0x58, 0x99, 0xAB, 0xC9, 0x0F, 0xE2, 0xF7, 0xAA}

/** ADP RGB color definitions. Other RGB values can be used as well */
#define ADP_COLOR_WHITE   0xFF, 0xFF, 0xFF
#define ADP_COLOR_BLACK   0x00, 0x00, 0x00
#define ADP_COLOR_SILVER  0xC0, 0xC0, 0xC0
#define ADP_COLOR_GRAY    0x80, 0x80, 0x80
#define ADP_COLOR_MAROON  0x80, 0x00, 0x00
#define ADP_COLOR_RED     0xFF, 0x00, 0x00
#define ADP_COLOR_PURPLE  0x80, 0x00, 0x80
#define ADP_COLOR_FUCHSIA 0xFF, 0x00, 0xFF
#define ADP_COLOR_GREEN   0x00, 0x80, 0x00
#define ADP_COLOR_LIME    0x00, 0xFF, 0x00
#define ADP_COLOR_OLIVE   0x80, 0x80, 0x00
#define ADP_COLOR_YELLOW  0xFF, 0xFF, 0x00
#define ADP_COLOR_NAVY    0x00, 0x00, 0x80
#define ADP_COLOR_BLUE    0x00, 0x00, 0xFF
#define ADP_COLOR_TEAL    0x00, 0x80, 0x80
#define ADP_COLOR_AQUA    0x00, 0xFF, 0xFF
#define ADP_COLOR_ORANGE  0xFF, 0xA5, 0x00

/** States in receive state machine */
enum rx_state_e {
	/** We are idle, waiting for a new packet */
	RX_STATE_IDLE,
	/** Start symbol received, waiting for Message ID */
	RX_STATE_WAIT_MSG_ID,
	/** Message ID received, waiting for data length */
	RX_STATE_WAIT_LENGTH_LSB,
	/** Message ID received, waiting for data length */
	RX_STATE_WAIT_LENGTH_MSB,
	/** Length received; we are receiving packet data */
	RX_STATE_GET_DATA,
	/** Start symbol received */
	RX_STATE_GOT_SYMBOL,
};

/** Max length of labels */
 #define ADP_CONF_MAX_LABEL 20

static inline void adp_set_color(uint8_t* struct_member, uint8_t c_red, uint8_t c_green, uint8_t c_blue)
{
	struct_member[0] = c_red;
	struct_member[1] = c_green;
	struct_member[2] = c_blue;
}


#define adp_set_string(struct_member, string)                  \
		Assert(sizeof(struct_member));                         \
		strncpy(struct_member, string, sizeof(struct_member)); \
		struct_member[sizeof(struct_member)-1] = '\0';

/* MESSAGE FORMAT */
SHORTENUM struct adp_msg_format {
	/* Start token for ADP data */
	uint8_t protocol_token;
	/* Describes what data is sent */
	uint8_t protocol_msg_id;
	/* Length of data packet */
	uint16_t data_length;
	/* Data packet for the message */
	uint8_t data[ADP_MAX_PACKET_DATA_SIZE];
};


/* MSG_REQ_HANDSHAKE */
#define MSG_REQ_HANDSHAKE 0x00
#define MSQ_REQ_HANDSHAKE_LEN 10
enum adp_handshake_options {
	/* Use GPIO */
	ADP_HANDSHAKE_OPTIONS_GPIO,
	/* Lock configuration */
	ADP_HANDSHAKE_OPTIONS_LOCK,
};
SHORTENUM struct adp_msg_request_handshake {
	/* Version of protocol on target */
	uint8_t protocol_version;
	/* Is GPIO in use in this app?
	 * Can user change configuration on PC side? 
	 */
	uint8_t options;
	/* Token used to verify ADP protocol */
	uint8_t key[8];
};

/* MSG_RES_HANDSHAKE */
#define MSG_RES_HANDSHAKE 0x10
enum adp_handshake_status {
	/* Handshake accepted */
	ADP_HANDSHAKE_ACCEPTED,
	/* Handshake rejected. Invalid protocol version */
	ADP_HANDSHAKE_REJECTED_PROTOCOL,
	/* Handshake rejected. Other reason */
	ADP_HANDSHAKE_REJECTED_OTHER,
};
SHORTENUM struct adp_msg_response_handshake {
	enum adp_handshake_status status;
};

enum adp_handshake_status adp_wait_for_handshake(void);

/* MSG_REQ_STATUS */
#define MSG_REQ_STATUS 0x02
#define MSG_REQ_STATUS_LEN 0
/* This message has no data */

/* MSG_RES_STATUS */
#define MSG_RES_STATUS 0x12
enum adp_status_code {
	/* Invalid packet received */
	ADP_STATUS_INVALID_PACKET,
	/* Invalid configuration data received */
	ADP_STATUS_INVALID_CONFIGURATION,
	/* Data ready to be transmitted to target */
	ADP_STATUS_DATA_READY,
	/* Invalid stream request (req_data) */
	ADP_STATUS_INVALID_REQUEST,
	/* No data available on stream (req_data) */
	ADP_STATUS_NO_DATA,
	/* Request target software reset */
	ADP_STATUS_RESET,
};
SHORTENUM struct adp_msg_response_status {
	enum adp_status_code status;
};

enum adp_status_code adp_request_status(void);

/* MSG_RES_DATA */
#define MSG_RES_DATA 0x14
#define MSG_RES_DATA_MAX_LEN (ADP_MAX_BYTE_REQUEST + 4)
SHORTENUM struct adp_msg_response_data {
	/* ID of stream */
	uint8_t stream_id;
	/* Number of bytes in packet. 
	 * If the target has requested data from an unknown stream, or if stream 
	 * has no data to send, this field should be set to 0 and the appropriate 
	 * status flag should be set.
	 */
	uint8_t bytes_sent;
	/* The data */		
	uint8_t data[ADP_MAX_BYTE_REQUEST];
};

void adp_request_data(uint8_t stream_id, uint8_t bytes_to_send, struct adp_msg_response_data *response);

#define MSG_RES_PACKET_DATA_MAX_LEN (ADP_MAX_BYTE_REQUEST + 2)
SHORTENUM struct adp_msg_packet_data {
	uint16_t stream_id;
	uint8_t bytes_sent;
	uint8_t data[ADP_MAX_BYTE_REQUEST];
};
bool adp_receive_packet_data(uint8_t *receive_buf);

/* MSG_CONF_STREAM */
enum adp_stream_type {
	ADP_STREAM_EVENT,
	ADP_STREAM_STRING,
	ADP_STREAM_UINT_8,
	ADP_STREAM_INT_8,
	ADP_STREAM_UINT_16,
	ADP_STREAM_INT_16,
	ADP_STREAM_UINT_32,
	ADP_STREAM_INT_32,
	ADP_STREAM_XY_8,
	ADP_STREAM_XY_16,
	ADP_STREAM_XY_32,
	ADP_STREAM_BOOL,
	ADP_STREAM_FLOAT,
};

enum adp_stream_state {
	ADP_STREAM_OFF,
	ADP_STREAM_ON,
};

enum adp_stream_mode {
	/* Incoming (normal) */
	ADP_STREAM_IN,
	/* Incoming (single value) */
	ADP_STREAM_IN_SINGLE,
	/* Outgoing */
	ADP_STREAM_OUT,
};

#define MSG_CONF_ACK       0x30
#define ADP_ACK_NOT_OK     0
#define ADP_ACK_OK         1

#define MSG_CONF_INFO      0x28
#define MSG_CONF_INFO_LEN
bool adp_configure_info(const char* title, const char* description);

#define MSG_CONF_STREAM     0x20
#define MSG_CONF_STREAM_LEN 5
SHORTENUM struct adp_msg_configure_stream {
	/* ID of stream */
	uint16_t stream_id;
	/* Stream type */
	enum adp_stream_type type;
	/* Stream mode/direction */
	enum adp_stream_mode mode;
	/* Stream state */
	enum adp_stream_state state;
};

static inline void adp_configure_stream_get_defaults(struct adp_msg_configure_stream *const config)
{
	Assert(config);
	config->stream_id = 0;
	config->type = ADP_STREAM_UINT_8;
	config->mode = ADP_STREAM_OUT;
	config->state = ADP_STREAM_ON;
}

bool adp_configure_stream(struct adp_msg_configure_stream *const config, const char* label);

/* MSG_CONF_TOGGLE_STREAM */
#define MSG_CONF_TOGGLE_STREAM   0x21
#define MSG_CONF_TOGGLE_STREAM_LEN 3
SHORTENUM struct adp_msg_toggle_stream {
	uint16_t               stream_id;
	enum adp_stream_state  state;
};
bool adp_toggle_stream(struct adp_msg_toggle_stream *const config);

/* MSG_CONF_GRAPH */
#define MSG_CONF_GRAPH           0x22
#define MSG_CONF_GRAPH_LEN       23

enum adp_graph_scale_mode {
	ADP_GRAPH_SCALE_OFF,
	ADP_GRAPH_SCALE_AUTO
};

enum adp_graph_scroll_mode {
	/* No scrolling */
	ADP_GRAPH_SCROLL_OFF,
	/* Stepping */
	ADP_GRAPH_SCROLL_STEP,
	/* Scroll */
	ADP_GRAPH_SCROLL_SCROLL,
	/* Circular/sweep */
	ADP_GRAPH_SCROLL_CIRCULAR
};

SHORTENUM struct adp_msg_configure_graph {
	/* ID of new graph */
	uint8_t graph_id;
	/* Range Xmin value */
	uint32_t x_min;
	/* Range Xmax value */
	uint32_t x_max;
	/* Xscale numerator */
	uint32_t x_scale_numerator;
	/* X range scale value. Set to 0 to enable auto range */
	uint32_t x_scale_denominator;
	/* Vertical scaling */
	enum adp_graph_scale_mode scale_mode;
	/* RGB background color */
	uint8_t background_color[3];
	/* Horizontal scrolling */
	enum adp_graph_scroll_mode scroll_mode;
};

static inline void adp_configure_graph_get_defaults(struct adp_msg_configure_graph *const config)
{
	Assert(config);
	config->graph_id = 0;
	config->x_min = 0;
	config->x_max = 0;
	config->x_scale_numerator = 0;
	config->x_scale_denominator = 0;
	config->scale_mode = ADP_GRAPH_SCALE_OFF;
	adp_set_color(config->background_color, ADP_COLOR_WHITE);
	config->scroll_mode = ADP_GRAPH_SCROLL_SCROLL;
}

bool adp_configure_graph(struct adp_msg_configure_graph *const config, \
						const char* graph_label, const char* x_label);

/* MSG_CONF_AXIS */
#define MSG_CONF_AXIS       0x29
#define MSG_CONF_AXIS_LEN   24
SHORTENUM struct adp_msg_conf_axis {
	/* ID of new axis */
	uint16_t axis_id;
	/* ID of graph */
	uint16_t graph_id;
	/* Range Ymin value */
	int32_t y_min;
	/* Range Ymax value */
	int32_t y_max;
	/* X range scale value.	Set to 0 to enable auto range */
	uint32_t x_scale_numerator;
	/* X range scale value.	Set to 0 to enable auto range */
	uint32_t x_scale_denominator;
	/* Mode */
	uint8_t mode;                                         // TODO
	/* RGB color */
	uint8_t color[3];
};

static inline void adp_add_axis_to_graph_get_defaults(struct adp_msg_conf_axis *const config)
{
	Assert(config);
	config->axis_id = 0;
	config->graph_id = 0;
	config->y_min = 0;
	config->y_max = 0;
	config->x_scale_numerator = 0;
	config->x_scale_denominator = 0;
	config->mode = 0;
	adp_set_color(config->color, ADP_COLOR_BLACK);
}

bool adp_add_axis_to_graph(struct adp_msg_conf_axis *const config, const char* label);

/* MSG_CONF_ADD_STREAM_TO_GRAPH */
#define MSG_CONF_ADD_STREAM_TO_AXIS       0x23
#define MSG_CONF_ADD_STREAM_TO_AXIS_LEN   32

#define ADP_AXIS_LINE_bm    0x01
#define ADP_AXIS_POINTS_bm  0x02

SHORTENUM struct adp_msg_add_stream_to_axis {
	/* ID of graph */
	uint16_t graph_id;
	/* ID of new axis */
	uint16_t axis_id;
	/* ID of stream */
	uint16_t stream_id;
	/* Sample rate of stream, set to 0 if NA */
	uint32_t sample_rate_numerator;
	/* Sample rate of stream, set to 0 if NA */
	uint32_t sample_rate_denominator;
	/* Range Ymin value */
	uint32_t y_scale_numerator;
	/* Range Ymax value */
	uint32_t y_scale_denominator;
	/* Offset of values */
	uint32_t y_offset;
	/* Adjust the transparency */
	uint8_t transparency;
	/* For graphs:  bit 0 = line on/off
	 *              bit 1 = points on/off
	 * For text:    bit 0 = flag
	 *              bit 1 = text
	 */
	uint8_t mode;                           // TODO
	/* Thickness of line */
	uint8_t line_thickness;
	/* RGB color of line */
	uint8_t line_color[3];
};

static inline void adp_add_stream_to_axis_get_defaults(struct adp_msg_add_stream_to_axis *const config)
{
	Assert(config);
	config->graph_id = 0;
	config->axis_id = 0;
	config->stream_id = 0;
	config->sample_rate_numerator = 0;
	config->sample_rate_denominator = 0;
	config->y_scale_numerator = 0;
	config->y_scale_denominator = 0;
	config->y_offset = 0;
	config->transparency = 0;
	config->mode = ADP_AXIS_LINE_bm;
	config->line_thickness = 1;
	adp_set_color(config->line_color, ADP_COLOR_BLACK);
}

bool adp_add_stream_to_axis(struct adp_msg_add_stream_to_axis *const config);

/* MSG_CONF_CURSOR_TO_GRAPH */
#define MSG_CONF_CURSOR_TO_GRAPH     0x24
#define MSG_CONF_CURSOR_TO_GRAPH_LEN 35
SHORTENUM struct adp_msg_add_cursor_to_graph {
	/* ID of streama */
	uint16_t stream_id;
	/* ID of graph */
	uint16_t graph_id;
	/* ID of axis */
	uint16_t axis_id;
	/* Thickness of line */
	uint8_t thickness;
	/* RGB color of cursor */
	uint8_t color[3];
	/* Starting point of cursor */
	uint32_t initial_value;
	/* Minimum allowed value */
	uint32_t minimum_value;
	/* Maximum */
	uint32_t maximum_value;
	/* Numerator of scaling value */
	uint32_t scale_numerator;
	/* Denominator of scaling value */
	uint32_t scale_denominator;
	/* Offset of value */
	uint32_t scale_offset;
	/* The style of line: Solid, dashed, dotted.. */
	uint8_t line_style;          // TODO
};

static inline void adp_add_cursor_to_graph_get_defaults(struct adp_msg_add_cursor_to_graph *const config)
{
	Assert(config);
	config->stream_id = 0;
	config->graph_id = 0;
	config->axis_id = 0;
	config->thickness = 1;
	adp_set_color(config->color, ADP_COLOR_WHITE);
	config->initial_value = 0;
	config->minimum_value = 0;
	config->maximum_value = 0;
	config->scale_numerator = 0;
	config->scale_denominator = 0;
	config->scale_offset = 0;
	config->line_style = 0;
}

bool adp_add_cursor_to_graph(struct adp_msg_add_cursor_to_graph *const config, const char* label);

/* MSG_CONF_GPIO_TO_GRAPH */
#define MSG_CONF_GPIO_TO_GRAPH       0x25
#define MSG_CONF_GPIO_TO_GRAPH_LEN   15
SHORTENUM struct adp_msg_conf_gpio_to_graph {
	/* ID of graph */
	uint16_t graph_id;
	/* GPIO number to add to graph. Bit 0: GPIO0. bit 1: GPIO1 etc. */
	uint8_t gpio_number;
	/* Used to group graphs and cursors to the same scale */
	uint8_t group_id;
	/* Adjust the transparency */
	uint8_t transparency;
	/* Mode */
	uint16_t mode;                                    // TODO
	/* Thickness of line */
	uint8_t line_thickness;
	/* RGB color of line when GPIO pin is high */
	uint8_t line_color_high_state[3];
	/* RGB color of line when GPIO pin is low */
	uint8_t line_color_low_state[3];
	/* The style of line */
	uint8_t line_style;
};

static inline void adp_gpio_to_graph_get_defaults(struct adp_msg_conf_gpio_to_graph *const config)
{
	Assert(config);
	config->graph_id = 0;
	config->gpio_number = 0;
	config->group_id = 0;
	config->transparency = 0;
	config->mode = 0;
	config->line_thickness = 1;
	adp_set_color(config->line_color_high_state, ADP_COLOR_WHITE);
	adp_set_color(config->line_color_low_state, ADP_COLOR_WHITE);
	config->line_style = 0;
}

bool adp_add_gpio_to_graph(struct adp_msg_conf_gpio_to_graph *const config, \
						const char* tag_high_state, const char* tag_low_state);

/* MSG_CONF_TERMINAL */
#define MSG_CONF_TERMINAL        0x26
#define MSG_CONF_TERMINAL_LEN    10
SHORTENUM struct adp_msg_conf_terminal {
	/* ID of terminal */
	uint16_t terminal_id;
	/* Number of characters wide */
	uint8_t width;
	/* Number of characters high */
	uint8_t height;
	/* RGB background color */
	uint8_t background_color[3];
	/* RGB background color */
	uint8_t foreground_color[3];
};

static inline void adp_configure_terminal_get_defaults(struct adp_msg_conf_terminal *const config)
{
	Assert(config);
	config->terminal_id = 0;
	config->width = 80;
	config->height = 25;
	adp_set_color(config->background_color, ADP_COLOR_WHITE);
	adp_set_color(config->foreground_color, ADP_COLOR_BLACK);
}

bool adp_configure_terminal(struct adp_msg_conf_terminal *const config, const char* label);

/* MSG_CONF_ADD_TO_TERMINAL */
#define MSG_CONF_ADD_TO_TERMINAL       0x27
#define MSG_CONF_ADD_TO_TERMINAL_LEN   11
SHORTENUM struct adp_msg_add_stream_to_terminal {
	/* ID of Terminal */
	uint16_t terminal_id;
	/* ID of stream */
	uint16_t stream_id;
	/* 0bx x x N T S F F
	 * N = implicit newline in incoming text
	 * T = enable tag
	 * S = timestamped
	 * F = format (Hex, decimal, binary, ascii)
	 */
	uint8_t mode;                                    // TODO
	/* RGB color of the text stream received */
	uint8_t text_color[3];
	/* RGB color of the tag text */
	uint8_t tag_text_color[3];
};

static inline void adp_add_stream_to_terminal_get_defaults(struct adp_msg_add_stream_to_terminal *const config)
{
	Assert(config);
	config->terminal_id = 0;
	config->stream_id = 0;
	config->mode = 0;
	adp_set_color(config->text_color, ADP_COLOR_BLACK);
	adp_set_color(config->tag_text_color, ADP_COLOR_BLACK);
}

bool adp_add_stream_to_terminal(struct adp_msg_add_stream_to_terminal *const config, const char* tag_text);

/* MSG_CONF_DASHBOARD */
#define MSG_CONF_DASHBOARD       0x2A
#define MSG_CONF_DASHBOARD_LEN   7
SHORTENUM struct adp_msg_conf_dashboard {
	uint16_t dashboard_id;
	uint8_t color[3];
	uint16_t height;
};

static inline void adp_conf_dashboard_get_defaults(struct adp_msg_conf_dashboard *const config)
{
	Assert(config);
	config->dashboard_id = 0;
	adp_set_color(config->color, ADP_COLOR_BLACK);
	config->height = 100;
}

bool adp_add_dashboard(struct adp_msg_conf_dashboard *const config, const char* label);

/* MSG_CONF_DASHBOARD_ELEMENT */
#define MSG_CONF_DASHBOARD_ELEMENT 0x2B

enum adp_dashboard_element_type {
	ADP_ELEMENT_TYPE_LABEL,
	ADP_ELEMENT_TYPE_BUTTON,
	ADP_ELEMENT_TYPE_SLIDER,
	ADP_ELEMENT_TYPE_PROGRESS,
	ADP_ELEMENT_TYPE_SIGNAL,
	ADP_ELEMENT_TYPE_SEGMENT,
	ADP_ELEMENT_TYPE_GRAPH,
	ADP_ELEMENT_TYPE_TEXT,
	ADP_ELEMENT_TYPE_RADIO,
	ADP_ELEMENT_TYPE_PIE,
};

#define MSG_CONF_DASHBOARD_COMMON_LEN    14
#define ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS \
	uint16_t  dashboard_id; \
	uint16_t  element_id;   \
	uint8_t   z_index;      \
	uint16_t  x;            \
	uint16_t  y;            \
	uint16_t  width;        \
	uint16_t  height;       \
	enum adp_dashboard_element_type element_type 

SHORTENUM struct adp_msg_conf_dashboard_element_common {
	/* Dashboard ID */
	uint16_t  dashboard_id;
	/* Unique ID of element */
	uint16_t  element_id;
	/* Order index */
	uint8_t   z_index;
	/* X-coordinate of element location. 0 is leftmost position on dashboard */
	uint16_t  x;
	/* Y-coordinate of element location. 0 is topmost position on dashboard */
	uint16_t  y;
	/* Width of element */
	uint16_t  width;
	/* Height of element */
	uint16_t  height;
	/* See each element type below */
	enum adp_dashboard_element_type element_type;
};

static inline void adp_conf_dashboard_element_get_defaults(struct adp_msg_conf_dashboard_element_common *const config)
{
	Assert(config);
	config->dashboard_id = 0;
	config->element_id = 0;
	config->z_index = 0;
	config->x = 0;
	config->y = 0;
	config->width = 0;
	config->height = 0;
}

enum adp_label_attribute_alignment {
	BOLD_OFF_ITALIC_OFF,
	BOLD_ON_ITALIC_OFF,
	BOLD_OFF_ITALIC_ON,
	BOLD_ON_ITALIC_ON,
};

enum adp_label_horisontal_alignment {
	HORISONTAL_ALIGNMENT_LEFT,
	HORISONTAL_ALIGNMENT_CENTER,
	HORISONTAL_ALIGNMENT_RIGHT,
};

enum adp_label_vertical_alignment {
	VERTICAL_ALIGNMENT_TOP,
	VERTICAL_ALIGNMENT_CENTER,
	VERTICAL_ALIGNMENT_BOTTOM,
};

#define ADP_ELEMENT_TYPE_LABEL_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 12)
SHORTENUM struct adp_msg_conf_dashboard_element_label {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t                             font_size;
	uint8_t                             attribute;                               // TODO
	enum adp_label_horisontal_alignment horisontal_alignment;
	enum adp_label_vertical_alignment   vertical_alignment;
	uint8_t                             background_transparency;
	uint8_t                             background_color[3];
	uint8_t                             foreground_transparency;
	uint8_t                             foreground_color[3];
};

static inline void adp_conf_dashboard_label_get_defaults(struct adp_msg_conf_dashboard_element_label *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_LABEL;
	config->font_size = 10;
	config->attribute = 0;
	config->horisontal_alignment = HORISONTAL_ALIGNMENT_LEFT;
	config->vertical_alignment = VERTICAL_ALIGNMENT_CENTER;
	config->background_transparency = 0;
	adp_set_color(config->background_color, ADP_COLOR_BLACK);
	config->foreground_transparency = 0;
	adp_set_color(config->foreground_color, ADP_COLOR_BLACK);
}

bool adp_add_label_to_dashboard(struct adp_msg_conf_dashboard_element_label *const config, const char* label);

#define ADP_ELEMENT_TYPE_BUTTON_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 1)

SHORTENUM struct adp_msg_conf_dashboard_element_button {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t font_size;
};

static inline void adp_conf_dashboard_button_get_defaults(struct adp_msg_conf_dashboard_element_button *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_BUTTON;
	config->font_size = 10;
}

bool adp_add_button_to_dashboard(struct adp_msg_conf_dashboard_element_button *const config, const char* label);

#define ADP_ELEMENT_TYPE_SLIDER_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 12)
SHORTENUM struct adp_msg_conf_dashboard_element_slider {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint32_t minimum_value;
	uint32_t maximum_value;
	uint32_t initial_value;
};

static inline void adp_conf_dashboard_slider_get_defaults(struct adp_msg_conf_dashboard_element_slider *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_SLIDER;
	config->minimum_value = 0;
	config->maximum_value = 100;
	config->initial_value = 0;
}

bool adp_add_slider_to_dashboard(struct adp_msg_conf_dashboard_element_slider *const config);

#define ADP_ELEMENT_TYPE_SIGNAL_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 8)
SHORTENUM struct adp_msg_conf_dashboard_element_signal {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t on_transparency;
	uint8_t on_color[3];
	uint8_t off_transparency;
	uint8_t off_color[3];
};

static inline void adp_conf_dashboard_signal_get_defaults(struct adp_msg_conf_dashboard_element_signal *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_SIGNAL;
	config->on_transparency = 0;
	adp_set_color(config->on_color, ADP_COLOR_WHITE);
	config->off_transparency = 0;
	adp_set_color(config->off_color, ADP_COLOR_BLACK);
}

bool adp_add_signal_to_dashboard(struct adp_msg_conf_dashboard_element_signal *const config);

#define ADP_ELEMENT_TYPE_PROGRESS_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 15)
SHORTENUM struct adp_msg_conf_dashboard_element_progress {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint32_t minimum_value;
	uint32_t maximum_value;
	uint32_t initial_value;
	uint8_t color[3];
};

static inline void adp_conf_dashboard_progress_get_defaults(struct adp_msg_conf_dashboard_element_progress *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_PROGRESS;
	config->minimum_value = 0;
	config->maximum_value = 100;
	config->initial_value = 0;
	adp_set_color(config->color, ADP_COLOR_BLACK);
}

bool adp_add_progress_to_dashboard(struct adp_msg_conf_dashboard_element_progress *const config);

#define ADP_ELEMENT_TYPE_SEGMENT_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 6)
SHORTENUM struct adp_msg_conf_dashboard_element_segment {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	/* Values: 1 ~ 20 */
	uint8_t segment_count;
	/* Values: 2 ~ 16*/
	uint8_t base;
	uint8_t transparency;
	uint8_t color[3];
};

static inline void adp_conf_dashboard_segment_get_defaults(struct adp_msg_conf_dashboard_element_segment *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_SEGMENT;
	config->segment_count = 1;
	config->base = 10;
	config->transparency = 0;
	adp_set_color(config->color, ADP_COLOR_BLACK);
}

bool adp_add_segment_to_dashboard(struct adp_msg_conf_dashboard_element_segment *const config);

/* MSG_CONF_ADD_GRAPH_TO_ELEMENT */
#define  ADP_ELEMENT_TYPE_GRAPH_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 27)
typedef union {
	struct {
		uint8_t mouse:1;
		uint8_t fit_graph:1;
		uint8_t :6;
	} bit;
	uint8_t reg;
} mode_type;

SHORTENUM struct adp_msg_conf_dashboard_element_graph {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t title_color[3];
	uint8_t background_color[3];
	uint8_t graph_background_color[3];
	uint8_t plot_count;
	float x_min;
	float x_max;
	float y_min;
	float y_max;
	mode_type mode;
};

static inline void adp_conf_dashboard_graph_get_defaults(struct adp_msg_conf_dashboard_element_graph *const config)
{
	adp_conf_dashboard_element_get_defaults((struct adp_msg_conf_dashboard_element_common*)config);
	config->element_type = ADP_ELEMENT_TYPE_GRAPH;
	adp_set_color(config->title_color, ADP_COLOR_WHITE);
	adp_set_color(config->background_color, ADP_COLOR_BLACK);
	adp_set_color(config->graph_background_color, ADP_COLOR_BLACK);
	config->plot_count = 1;
	config->x_min = 0;
	config->x_max = 10;
	config->y_min = 0;
	config->y_max = 5;
	config->mode.bit.fit_graph = 1;
	config->mode.bit.mouse = 0;
}

bool adp_add_graph_to_dashboard(struct adp_msg_conf_dashboard_element_graph *const config, const char* title);


/* MSG_CONF_ADD_TEXT_TO_ELEMENT */
#define  ADP_ELEMENT_TYPE_TEXT_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 12)
SHORTENUM struct adp_msg_conf_dashboard_element_text {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t minimum[4];
	uint8_t maximum[4];
	uint8_t value[4];
};

bool adp_add_text_to_dashboard(struct adp_msg_conf_dashboard_element_text *const config);

/* MSG_CONF_ADD_RADIO_TO_ELEMENT */
#define  ADP_ELEMENT_TYPE_RADIO_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 3)

enum adp_radio_orientation {
	HORIZONTAL,
	VERTICAL,
};

SHORTENUM struct adp_msg_conf_dashboard_element_radio {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t font_size;
	uint8_t number_items;
	enum adp_radio_orientation orientation;
};
bool adp_add_radio_to_dashboard(struct adp_msg_conf_dashboard_element_radio *const config, const char* text);

/* MSG_CONF_ADD_PIE_TO_ELEMENT */
#define  ADP_ELEMENT_TYPE_PIE_LEN (MSG_CONF_DASHBOARD_COMMON_LEN + 7)

SHORTENUM struct adp_msg_conf_dashboard_element_pie {
	ADP_DASHBOARD_ELEMENT_COMMON_MEMBERS;
	uint8_t background_color[3];
	uint8_t title_color[3];
	uint8_t number_slices;
};
bool adp_add_pie_to_dashboard(struct adp_msg_conf_dashboard_element_pie *const config, const char* title);

/* MSG_CONF_ADD_STREAM_TO_ELEMENT */
#define MSG_CONF_ADD_STREAM_TO_ELEMENT       0x2C
#define MSG_CONF_ADD_STREAM_TO_ELEMENT_LEN   6

SHORTENUM struct adp_conf_add_stream_to_element {
	uint16_t dashboard_id;
	uint16_t element_id;
	uint16_t stream_id;
};

bool adp_add_stream_to_element(struct adp_conf_add_stream_to_element *const config);

/* MSG_DATA_STREAM */
#define MSG_DATA_STREAM 0x40
SHORTENUM struct adp_msg_data_stream_data {
	uint16_t stream_id;
	uint8_t data_size;
	uint8_t *data;
};

SHORTENUM struct adp_msg_data_stream {
	uint8_t number_of_streams;
	struct adp_msg_data_stream_data stream[ADP_MAX_OUTGOING_STREAMS];
};

bool adp_send_stream(struct adp_msg_data_stream *const stream_data, uint8_t* receive_buf);
bool adp_send_single_stream(uint8_t stream_id, uint8_t* data, uint8_t data_size, uint8_t* receive_buf);
bool adp_transceive_stream(struct adp_msg_data_stream *const stream_data, uint8_t *receive_buf);
bool adp_transceive_single_stream(uint16_t stream_id, uint8_t* data, uint8_t data_size, uint8_t* receive_buf);

/* Init SPI/TWI interface used. And some other misc init */
void adp_init(void);
uint16_t adp_add_send_byte(uint8_t* buffer, uint8_t index, uint8_t* data, uint16_t length);

#endif