1207 lines
53 KiB
C++
1207 lines
53 KiB
C++
#include "RGBController.h"
|
|
#include <cstring>
|
|
|
|
unsigned char * RGBController::GetDeviceDescription()
|
|
{
|
|
unsigned int data_ptr = 0;
|
|
unsigned int data_size = 0;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Calculate data size |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short name_len = strlen(name.c_str()) + 1;
|
|
unsigned short description_len = strlen(description.c_str()) + 1;
|
|
unsigned short version_len = strlen(version.c_str()) + 1;
|
|
unsigned short serial_len = strlen(serial.c_str()) + 1;
|
|
unsigned short location_len = strlen(location.c_str()) + 1;
|
|
unsigned short num_modes = modes.size();
|
|
unsigned short num_zones = zones.size();
|
|
unsigned short num_leds = leds.size();
|
|
unsigned short num_colors = colors.size();
|
|
|
|
unsigned short *mode_name_len = new unsigned short[num_modes];
|
|
unsigned short *zone_name_len = new unsigned short[num_zones];
|
|
unsigned short *led_name_len = new unsigned short[num_leds];
|
|
|
|
unsigned short *mode_num_colors = new unsigned short[num_modes];
|
|
|
|
data_size += sizeof(data_size);
|
|
data_size += sizeof(device_type);
|
|
data_size += name_len + sizeof(name_len);
|
|
data_size += description_len + sizeof(description_len);
|
|
data_size += version_len + sizeof(version_len);
|
|
data_size += serial_len + sizeof(serial_len);
|
|
data_size += location_len + sizeof(location_len);
|
|
|
|
data_size += sizeof(num_modes);
|
|
data_size += sizeof(active_mode);
|
|
|
|
for(int mode_index = 0; mode_index < num_modes; mode_index++)
|
|
{
|
|
mode_name_len[mode_index] = strlen(modes[mode_index].name.c_str()) + 1;
|
|
mode_num_colors[mode_index] = modes[mode_index].colors.size();
|
|
|
|
data_size += mode_name_len[mode_index] + sizeof(mode_name_len[mode_index]);
|
|
data_size += sizeof(modes[mode_index].value);
|
|
data_size += sizeof(modes[mode_index].flags);
|
|
data_size += sizeof(modes[mode_index].speed_min);
|
|
data_size += sizeof(modes[mode_index].speed_max);
|
|
data_size += sizeof(modes[mode_index].colors_min);
|
|
data_size += sizeof(modes[mode_index].colors_max);
|
|
data_size += sizeof(modes[mode_index].speed);
|
|
data_size += sizeof(modes[mode_index].direction);
|
|
data_size += sizeof(modes[mode_index].color_mode);
|
|
data_size += sizeof(mode_num_colors[mode_index]);
|
|
data_size += (mode_num_colors[mode_index] * sizeof(RGBColor));
|
|
}
|
|
|
|
data_size += sizeof(num_zones);
|
|
|
|
for(int zone_index = 0; zone_index < num_zones; zone_index++)
|
|
{
|
|
zone_name_len[zone_index] = strlen(zones[zone_index].name.c_str()) + 1;
|
|
|
|
data_size += zone_name_len[zone_index] + sizeof(zone_name_len[zone_index]);
|
|
data_size += sizeof(zones[zone_index].type);
|
|
data_size += sizeof(zones[zone_index].leds_min);
|
|
data_size += sizeof(zones[zone_index].leds_max);
|
|
data_size += sizeof(zones[zone_index].leds_count);
|
|
}
|
|
|
|
data_size += sizeof(num_leds);
|
|
|
|
for(int led_index = 0; led_index < num_leds; led_index++)
|
|
{
|
|
led_name_len[led_index] = strlen(leds[led_index].name.c_str()) + 1;
|
|
|
|
data_size += led_name_len[led_index] + sizeof(led_name_len[led_index]);
|
|
|
|
data_size += sizeof(leds[led_index].value);
|
|
}
|
|
|
|
data_size += sizeof(num_colors);
|
|
data_size += num_colors * sizeof(RGBColor);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Create data buffer |
|
|
\*---------------------------------------------------------*/
|
|
unsigned char *data_buf = new unsigned char[data_size];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in data size |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
|
|
data_ptr += sizeof(data_size);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in type |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &type, sizeof(device_type));
|
|
data_ptr += sizeof(device_type);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &name_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], name.c_str());
|
|
data_ptr += name_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in description (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &description_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], description.c_str());
|
|
data_ptr += description_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in version (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &version_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], version.c_str());
|
|
data_ptr += version_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in serial (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &serial_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], serial.c_str());
|
|
data_ptr += serial_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in location (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &location_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], location.c_str());
|
|
data_ptr += location_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of modes (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &num_modes, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in active mode (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &active_mode, sizeof(active_mode));
|
|
data_ptr += sizeof(active_mode);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in modes |
|
|
\*---------------------------------------------------------*/
|
|
for(int mode_index = 0; mode_index < num_modes; mode_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &mode_name_len[mode_index], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], modes[mode_index].name.c_str());
|
|
data_ptr += mode_name_len[mode_index];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode value (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].value, sizeof(modes[mode_index].value));
|
|
data_ptr += sizeof(modes[mode_index].value);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode flags (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].flags, sizeof(modes[mode_index].flags));
|
|
data_ptr += sizeof(modes[mode_index].flags);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].speed_min, sizeof(modes[mode_index].speed_min));
|
|
data_ptr += sizeof(modes[mode_index].speed_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].speed_max, sizeof(modes[mode_index].speed_max));
|
|
data_ptr += sizeof(modes[mode_index].speed_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].colors_min, sizeof(modes[mode_index].colors_min));
|
|
data_ptr += sizeof(modes[mode_index].colors_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].colors_max, sizeof(modes[mode_index].colors_max));
|
|
data_ptr += sizeof(modes[mode_index].colors_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].speed, sizeof(modes[mode_index].speed));
|
|
data_ptr += sizeof(modes[mode_index].speed);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode direction (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].direction, sizeof(modes[mode_index].direction));
|
|
data_ptr += sizeof(modes[mode_index].direction);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode color_mode (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].color_mode, sizeof(modes[mode_index].color_mode));
|
|
data_ptr += sizeof(modes[mode_index].color_mode);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode number of colors |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &mode_num_colors[mode_index], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode mode colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < mode_num_colors[mode_index]; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode_index].colors[color_index], sizeof(modes[mode_index].colors[color_index]));
|
|
data_ptr += sizeof(modes[mode_index].colors[color_index]);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of zones (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &num_zones, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zones |
|
|
\*---------------------------------------------------------*/
|
|
for(int zone_index = 0; zone_index < num_zones; zone_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zone_name_len[zone_index], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], zones[zone_index].name.c_str());
|
|
data_ptr += zone_name_len[zone_index];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone type (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zones[zone_index].type, sizeof(zones[zone_index].type));
|
|
data_ptr += sizeof(zones[zone_index].type);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone minimum LED count (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zones[zone_index].leds_min, sizeof(zones[zone_index].leds_min));
|
|
data_ptr += sizeof(zones[zone_index].leds_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone maximum LED count (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zones[zone_index].leds_max, sizeof(zones[zone_index].leds_max));
|
|
data_ptr += sizeof(zones[zone_index].leds_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone LED count (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zones[zone_index].leds_count, sizeof(zones[zone_index].leds_count));
|
|
data_ptr += sizeof(zones[zone_index].leds_count);
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of LEDs (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &num_leds, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LEDs |
|
|
\*---------------------------------------------------------*/
|
|
for(int led_index = 0; led_index < num_leds; led_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short ledname_len = strlen(leds[led_index].name.c_str()) + 1;
|
|
memcpy(&data_buf[data_ptr], &ledname_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], leds[led_index].name.c_str());
|
|
data_ptr += ledname_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED value (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &leds[led_index].value, sizeof(leds[led_index].value));
|
|
data_ptr += sizeof(leds[led_index].value);
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of colors (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &num_colors, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < num_colors; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &colors[color_index], sizeof(colors[color_index]));
|
|
data_ptr += sizeof(colors[color_index]);
|
|
}
|
|
|
|
|
|
delete[] mode_name_len;
|
|
delete[] zone_name_len;
|
|
delete[] led_name_len;
|
|
|
|
delete[] mode_num_colors;
|
|
|
|
return(data_buf);
|
|
}
|
|
|
|
void RGBController::ReadDeviceDescription(unsigned char* data_buf)
|
|
{
|
|
unsigned int data_ptr = 0;
|
|
|
|
data_ptr += sizeof(unsigned int);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in type |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&type, &data_buf[data_ptr], sizeof(device_type));
|
|
data_ptr += sizeof(device_type);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in name |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short name_len;
|
|
memcpy(&name_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
name = (char *)&data_buf[data_ptr];
|
|
data_ptr += name_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in description |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short description_len;
|
|
memcpy(&description_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
description = (char *)&data_buf[data_ptr];
|
|
data_ptr += description_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in version |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short version_len;
|
|
memcpy(&version_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
version = (char *)&data_buf[data_ptr];
|
|
data_ptr += version_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in serial |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short serial_len;
|
|
memcpy(&serial_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
serial = (char *)&data_buf[data_ptr];
|
|
data_ptr += serial_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in location |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short location_len;
|
|
memcpy(&location_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
location = (char *)&data_buf[data_ptr];
|
|
data_ptr += location_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of modes (data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short num_modes;
|
|
memcpy(&num_modes, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in active mode (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&active_mode, &data_buf[data_ptr], sizeof(active_mode));
|
|
data_ptr += sizeof(active_mode);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in modes |
|
|
\*---------------------------------------------------------*/
|
|
for(int mode_index = 0; mode_index < num_modes; mode_index++)
|
|
{
|
|
mode new_mode;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short modename_len;
|
|
memcpy(&modename_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
new_mode.name = (char *)&data_buf[data_ptr];
|
|
data_ptr += modename_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode value (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.value, &data_buf[data_ptr], sizeof(new_mode.value));
|
|
data_ptr += sizeof(new_mode.value);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode flags (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.flags, &data_buf[data_ptr], sizeof(new_mode.flags));
|
|
data_ptr += sizeof(new_mode.flags);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.speed_min, &data_buf[data_ptr], sizeof(new_mode.speed_min));
|
|
data_ptr += sizeof(new_mode.speed_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.speed_max, &data_buf[data_ptr], sizeof(new_mode.speed_max));
|
|
data_ptr += sizeof(new_mode.speed_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.colors_min, &data_buf[data_ptr], sizeof(new_mode.colors_min));
|
|
data_ptr += sizeof(new_mode.colors_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.colors_max, &data_buf[data_ptr], sizeof(new_mode.colors_max));
|
|
data_ptr += sizeof(new_mode.colors_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.speed, &data_buf[data_ptr], sizeof(new_mode.speed));
|
|
data_ptr += sizeof(new_mode.speed);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode direction (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.direction, &data_buf[data_ptr], sizeof(new_mode.direction));
|
|
data_ptr += sizeof(new_mode.direction);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode color_mode (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode.color_mode, &data_buf[data_ptr], sizeof(new_mode.color_mode));
|
|
data_ptr += sizeof(new_mode.color_mode);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode number of colors |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short mode_num_colors;
|
|
memcpy(&mode_num_colors, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode mode colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < mode_num_colors; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
RGBColor new_color;
|
|
memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
|
|
data_ptr += sizeof(modes[mode_index].colors[color_index]);
|
|
|
|
new_mode.colors.push_back(new_color);
|
|
}
|
|
|
|
modes.push_back(new_mode);
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of zones (data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short num_zones;
|
|
memcpy(&num_zones, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zones |
|
|
\*---------------------------------------------------------*/
|
|
for(int zone_index = 0; zone_index < num_zones; zone_index++)
|
|
{
|
|
zone new_zone;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short zonename_len;
|
|
memcpy(&zonename_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
new_zone.name = (char *)&data_buf[data_ptr];
|
|
data_ptr += zonename_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone type (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_zone.type, &data_buf[data_ptr], sizeof(new_zone.type));
|
|
data_ptr += sizeof(new_zone.type);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone minimum LED count (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_zone.leds_min, &data_buf[data_ptr], sizeof(new_zone.leds_min));
|
|
data_ptr += sizeof(new_zone.leds_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone maximum LED count (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_zone.leds_max, &data_buf[data_ptr], sizeof(new_zone.leds_max));
|
|
data_ptr += sizeof(new_zone.leds_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone LED count (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_zone.leds_count, &data_buf[data_ptr], sizeof(new_zone.leds_count));
|
|
data_ptr += sizeof(new_zone.leds_count);
|
|
|
|
zones.push_back(new_zone);
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of LEDs (data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short num_leds;
|
|
memcpy(&num_leds, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LEDs |
|
|
\*---------------------------------------------------------*/
|
|
for(int led_index = 0; led_index < num_leds; led_index++)
|
|
{
|
|
led new_led;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short ledname_len;
|
|
memcpy(&ledname_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
new_led.name = (char *)&data_buf[data_ptr];
|
|
data_ptr += ledname_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED value (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_led.value, &data_buf[data_ptr], sizeof(new_led.value));
|
|
data_ptr += sizeof(new_led.value);
|
|
|
|
leds.push_back(new_led);
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of colors (data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short num_colors;
|
|
memcpy(&num_colors, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < num_colors; color_index++)
|
|
{
|
|
RGBColor new_color;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
|
|
data_ptr += sizeof(RGBColor);
|
|
|
|
colors.push_back(new_color);
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Setup colors |
|
|
\*---------------------------------------------------------*/
|
|
SetupColors();
|
|
}
|
|
|
|
unsigned char * RGBController::GetModeDescription(int mode)
|
|
{
|
|
unsigned int data_ptr = 0;
|
|
unsigned int data_size = 0;
|
|
|
|
unsigned short mode_name_len;
|
|
unsigned short mode_num_colors;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Calculate data size |
|
|
\*---------------------------------------------------------*/
|
|
mode_name_len = strlen(modes[mode].name.c_str()) + 1;
|
|
mode_num_colors = modes[mode].colors.size();
|
|
|
|
data_size += sizeof(data_size);
|
|
data_size += sizeof(mode);
|
|
data_size += sizeof(mode_name_len);
|
|
data_size += mode_name_len;
|
|
data_size += sizeof(modes[mode].value);
|
|
data_size += sizeof(modes[mode].flags);
|
|
data_size += sizeof(modes[mode].speed_min);
|
|
data_size += sizeof(modes[mode].speed_max);
|
|
data_size += sizeof(modes[mode].colors_min);
|
|
data_size += sizeof(modes[mode].colors_max);
|
|
data_size += sizeof(modes[mode].speed);
|
|
data_size += sizeof(modes[mode].direction);
|
|
data_size += sizeof(modes[mode].color_mode);
|
|
data_size += sizeof(mode_num_colors);
|
|
data_size += (mode_num_colors * sizeof(RGBColor));
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Create data buffer |
|
|
\*---------------------------------------------------------*/
|
|
unsigned char *data_buf = new unsigned char[data_size];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in data size |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
|
|
data_ptr += sizeof(data_size);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode index |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &mode, sizeof(int));
|
|
data_ptr += sizeof(int);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &mode_name_len, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
strcpy((char *)&data_buf[data_ptr], modes[mode].name.c_str());
|
|
data_ptr += mode_name_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode value (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].value, sizeof(modes[mode].value));
|
|
data_ptr += sizeof(modes[mode].value);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode flags (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].flags, sizeof(modes[mode].flags));
|
|
data_ptr += sizeof(modes[mode].flags);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].speed_min, sizeof(modes[mode].speed_min));
|
|
data_ptr += sizeof(modes[mode].speed_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].speed_max, sizeof(modes[mode].speed_max));
|
|
data_ptr += sizeof(modes[mode].speed_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].colors_min, sizeof(modes[mode].colors_min));
|
|
data_ptr += sizeof(modes[mode].colors_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].colors_max, sizeof(modes[mode].colors_max));
|
|
data_ptr += sizeof(modes[mode].colors_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].speed, sizeof(modes[mode].speed));
|
|
data_ptr += sizeof(modes[mode].speed);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode direction (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].direction, sizeof(modes[mode].direction));
|
|
data_ptr += sizeof(modes[mode].direction);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode color_mode (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].color_mode, sizeof(modes[mode].color_mode));
|
|
data_ptr += sizeof(modes[mode].color_mode);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode number of colors |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &mode_num_colors, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode mode colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < mode_num_colors; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &modes[mode].colors[color_index], sizeof(modes[mode].colors[color_index]));
|
|
data_ptr += sizeof(modes[mode].colors[color_index]);
|
|
}
|
|
|
|
return(data_buf);
|
|
}
|
|
|
|
void RGBController::SetModeDescription(unsigned char* data_buf)
|
|
{
|
|
int mode_idx;
|
|
unsigned int data_ptr = sizeof(unsigned int);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode index |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&mode_idx, &data_buf[data_ptr], sizeof(int));
|
|
data_ptr += sizeof(int);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Get pointer to target mode |
|
|
\*---------------------------------------------------------*/
|
|
mode * new_mode = &modes[mode_idx];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Set active mode to the new mode |
|
|
\*---------------------------------------------------------*/
|
|
active_mode = mode_idx;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode name (size+data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short modename_len;
|
|
memcpy(&modename_len, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
new_mode->name = (char *)&data_buf[data_ptr];
|
|
data_ptr += modename_len;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode value (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->value, &data_buf[data_ptr], sizeof(new_mode->value));
|
|
data_ptr += sizeof(new_mode->value);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode flags (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->flags, &data_buf[data_ptr], sizeof(new_mode->flags));
|
|
data_ptr += sizeof(new_mode->flags);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->speed_min, &data_buf[data_ptr], sizeof(new_mode->speed_min));
|
|
data_ptr += sizeof(new_mode->speed_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->speed_max, &data_buf[data_ptr], sizeof(new_mode->speed_max));
|
|
data_ptr += sizeof(new_mode->speed_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_min (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->colors_min, &data_buf[data_ptr], sizeof(new_mode->colors_min));
|
|
data_ptr += sizeof(new_mode->colors_min);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode colors_max (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->colors_max, &data_buf[data_ptr], sizeof(new_mode->colors_max));
|
|
data_ptr += sizeof(new_mode->colors_max);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode speed (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->speed, &data_buf[data_ptr], sizeof(new_mode->speed));
|
|
data_ptr += sizeof(new_mode->speed);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode direction (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->direction, &data_buf[data_ptr], sizeof(new_mode->direction));
|
|
data_ptr += sizeof(new_mode->direction);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode color_mode (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_mode->color_mode, &data_buf[data_ptr], sizeof(new_mode->color_mode));
|
|
data_ptr += sizeof(new_mode->color_mode);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode number of colors |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short mode_num_colors;
|
|
memcpy(&mode_num_colors, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in mode mode colors |
|
|
\*---------------------------------------------------------*/
|
|
new_mode->colors.clear();
|
|
for(int color_index = 0; color_index < mode_num_colors; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
RGBColor new_color;
|
|
memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
|
|
data_ptr += sizeof(RGBColor);
|
|
|
|
new_mode->colors.push_back(new_color);
|
|
}
|
|
|
|
printf("read data ptr %d\r\n", data_ptr);
|
|
}
|
|
|
|
unsigned char * RGBController::GetColorDescription()
|
|
{
|
|
unsigned int data_ptr = 0;
|
|
unsigned int data_size = 0;
|
|
|
|
unsigned short num_colors = colors.size();
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Calculate data size |
|
|
\*---------------------------------------------------------*/
|
|
data_size += sizeof(data_size);
|
|
data_size += sizeof(num_colors);
|
|
data_size += num_colors * sizeof(RGBColor);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Create data buffer |
|
|
\*---------------------------------------------------------*/
|
|
unsigned char *data_buf = new unsigned char[data_size];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in data size |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
|
|
data_ptr += sizeof(data_size);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of colors (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &num_colors, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < num_colors; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &colors[color_index], sizeof(colors[color_index]));
|
|
data_ptr += sizeof(colors[color_index]);
|
|
}
|
|
|
|
return(data_buf);
|
|
}
|
|
|
|
void RGBController::SetColorDescription(unsigned char* data_buf)
|
|
{
|
|
unsigned int data_ptr = sizeof(unsigned int);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of colors (data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short num_colors;
|
|
memcpy(&num_colors, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < num_colors; color_index++)
|
|
{
|
|
RGBColor new_color;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
|
|
data_ptr += sizeof(RGBColor);
|
|
|
|
colors[color_index] = new_color;
|
|
}
|
|
}
|
|
|
|
unsigned char * RGBController::GetZoneColorDescription(int zone)
|
|
{
|
|
unsigned int data_ptr = 0;
|
|
unsigned int data_size = 0;
|
|
|
|
unsigned short num_colors = zones[zone].leds_count;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Calculate data size |
|
|
\*---------------------------------------------------------*/
|
|
data_size += sizeof(data_size);
|
|
data_size += sizeof(zone);
|
|
data_size += sizeof(num_colors);
|
|
data_size += num_colors * sizeof(RGBColor);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Create data buffer |
|
|
\*---------------------------------------------------------*/
|
|
unsigned char *data_buf = new unsigned char[data_size];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in data size |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
|
|
data_ptr += sizeof(data_size);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone index |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zone, sizeof(zone));
|
|
data_ptr += sizeof(zone);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of colors (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &num_colors, sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < num_colors; color_index++)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[data_ptr], &zones[zone].colors[color_index], sizeof(zones[zone].colors[color_index]));
|
|
data_ptr += sizeof(zones[zone].colors[color_index]);
|
|
}
|
|
|
|
return(data_buf);
|
|
}
|
|
|
|
void RGBController::SetZoneColorDescription(unsigned char* data_buf)
|
|
{
|
|
unsigned int data_ptr = sizeof(unsigned int);
|
|
unsigned int zone_idx;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in zone index |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&zone_idx, &data_buf[data_ptr], sizeof(zone_idx));
|
|
data_ptr += sizeof(zone_idx);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in number of colors (data) |
|
|
\*---------------------------------------------------------*/
|
|
unsigned short num_colors;
|
|
memcpy(&num_colors, &data_buf[data_ptr], sizeof(unsigned short));
|
|
data_ptr += sizeof(unsigned short);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in colors |
|
|
\*---------------------------------------------------------*/
|
|
for(int color_index = 0; color_index < num_colors; color_index++)
|
|
{
|
|
RGBColor new_color;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in color (data) |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&new_color, &data_buf[data_ptr], sizeof(RGBColor));
|
|
data_ptr += sizeof(RGBColor);
|
|
|
|
zones[zone_idx].colors[color_index] = new_color;
|
|
}
|
|
}
|
|
|
|
unsigned char * RGBController::GetSingleLEDColorDescription(int led)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Fixed size descrption: |
|
|
| int: LED index |
|
|
| RGBColor: LED color |
|
|
\*---------------------------------------------------------*/
|
|
unsigned char *data_buf = new unsigned char[sizeof(int) + sizeof(RGBColor)];
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED index |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[0], &led, sizeof(int));
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED color |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&data_buf[sizeof(led)], &colors[led], sizeof(RGBColor));
|
|
|
|
return(data_buf);
|
|
}
|
|
|
|
void RGBController::SetSingleLEDColorDescription(unsigned char* data_buf)
|
|
{
|
|
/*---------------------------------------------------------*\
|
|
| Fixed size descrption: |
|
|
| int: LED index |
|
|
| RGBColor: LED color |
|
|
\*---------------------------------------------------------*/
|
|
int led_idx;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED index |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&led_idx, &data_buf[0], sizeof(led_idx));
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Copy in LED color |
|
|
\*---------------------------------------------------------*/
|
|
memcpy(&colors[led_idx], &data_buf[sizeof(led_idx)], sizeof(RGBColor));
|
|
}
|
|
|
|
void RGBController::SetupColors()
|
|
{
|
|
unsigned int total_led_count;
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Determine total number of LEDs on the device |
|
|
\*---------------------------------------------------------*/
|
|
total_led_count = 0;
|
|
|
|
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
|
{
|
|
total_led_count += zones[zone_idx].leds_count;
|
|
}
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Set the size of the color buffer to the number of LEDs |
|
|
\*---------------------------------------------------------*/
|
|
colors.resize(total_led_count);
|
|
|
|
/*---------------------------------------------------------*\
|
|
| Set the color buffer pointers on each zone |
|
|
\*---------------------------------------------------------*/
|
|
total_led_count = 0;
|
|
|
|
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
|
{
|
|
zones[zone_idx].start_idx=total_led_count;
|
|
|
|
if((colors.size() > 0) && (zones[zone_idx].leds_count > 0))
|
|
{
|
|
zones[zone_idx].colors = &colors[total_led_count];
|
|
}
|
|
else
|
|
{
|
|
zones[zone_idx].colors = NULL;
|
|
}
|
|
|
|
if((leds.size() > 0) && (zones[zone_idx].leds_count > 0))
|
|
{
|
|
zones[zone_idx].leds = &leds[total_led_count];
|
|
}
|
|
else
|
|
{
|
|
zones[zone_idx].leds = NULL;
|
|
}
|
|
|
|
|
|
total_led_count += zones[zone_idx].leds_count;
|
|
}
|
|
}
|
|
|
|
RGBColor RGBController::GetLED(unsigned int led)
|
|
{
|
|
if(led < colors.size())
|
|
{
|
|
return(colors[led]);
|
|
}
|
|
else
|
|
{
|
|
return(0x00000000);
|
|
}
|
|
}
|
|
|
|
void RGBController::SetLED(unsigned int led, RGBColor color)
|
|
{
|
|
if(led < colors.size())
|
|
{
|
|
colors[led] = color;
|
|
|
|
UpdateSingleLED(led);
|
|
}
|
|
}
|
|
|
|
void RGBController::SetAllLEDs(RGBColor color)
|
|
{
|
|
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
|
{
|
|
SetAllZoneLEDs(zone_idx, color);
|
|
}
|
|
|
|
UpdateLEDs();
|
|
}
|
|
|
|
void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
|
|
{
|
|
for (std::size_t color_idx = 0; color_idx < zones[zone].leds_count; color_idx++)
|
|
{
|
|
zones[zone].colors[color_idx] = color;
|
|
}
|
|
|
|
UpdateZoneLEDs(zone);
|
|
}
|
|
|
|
int RGBController::GetMode()
|
|
{
|
|
return(active_mode);
|
|
}
|
|
|
|
void RGBController::SetMode(int mode)
|
|
{
|
|
active_mode = mode;
|
|
|
|
UpdateMode();
|
|
}
|
|
|
|
std::string device_type_to_str(device_type type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case DEVICE_TYPE_MOTHERBOARD:
|
|
return "Motherboard";
|
|
case DEVICE_TYPE_DRAM:
|
|
return "DRAM";
|
|
case DEVICE_TYPE_GPU:
|
|
return "GPU";
|
|
case DEVICE_TYPE_COOLER:
|
|
return "Cooler";
|
|
case DEVICE_TYPE_LEDSTRIP:
|
|
return "LED Strip";
|
|
case DEVICE_TYPE_KEYBOARD:
|
|
return "Keyboard";
|
|
case DEVICE_TYPE_MOUSE:
|
|
return "Mouse";
|
|
case DEVICE_TYPE_MOUSEMAT:
|
|
return "Mousemat";
|
|
case DEVICE_TYPE_HEADSET:
|
|
return "Headset";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
}
|