libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/samd21/sam_d2x_asflib/common/services/adp/adp.h

944 lines
28 KiB
C
Raw Normal View History

add atmel SAM D21 bsp support
2017-08-30 12:18:28 +08:00
/**
* \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