/* This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* OreoLED I2C driver. Based primarily on ArduPilot OreoLED_PX4.cpp, but with some components from orleod.cpp from px4 firmware */ #include <AP_HAL/AP_HAL.h> #include <AP_HAL/I2CDevice.h> #include <AP_BoardConfig/AP_BoardConfig.h> #include "OreoLED_I2C.h" #include "AP_Notify.h" #include <utility> // OreoLEDs start at address 0x68 and add device number. So LED2 is at 0x6A #define OREOLED_BASE_I2C_ADDR 0x68 #define OREOLED_BACKLEFT 0 // back left led instance number #define OREOLED_BACKRIGHT 1 // back right led instance number #define OREOLED_FRONTRIGHT 2 // front right led instance number #define OREOLED_FRONTLEFT 3 // front left led instance number #define PERIOD_SLOW 800 // slow flash rate #define PERIOD_FAST 500 // fast flash rate #define PERIOD_SUPER 150 // super fast rate #define PO_ALTERNATE 180 // 180 degree phase offset #define OREOLED_BOOT_CMD_BOOT_APP 0x60 #define OREOLED_BOOT_CMD_BOOT_NONCE 0xA2 extern const AP_HAL::HAL& hal; // constructor OreoLED_I2C::OreoLED_I2C(uint8_t bus, uint8_t theme): NotifyDevice(), _bus(bus), _oreo_theme(theme) { } // // Initialize the LEDs // bool OreoLED_I2C::init() { // first look for led on external bus _dev = std::move(hal.i2c_mgr->get_device(_bus, OREOLED_BASE_I2C_ADDR)); if (!_dev) { return false; } // register timer _dev->register_periodic_callback(1000, FUNCTOR_BIND_MEMBER(&OreoLED_I2C::update_timer, void)); // return health return true; } // UPDATE device according to timed_updated. Called at 50Hz void OreoLED_I2C::update() { if (slow_counter()) { return; // slow rate from 50hz to 10hz } if (mode_firmware_update()) { return; // don't go any further if the Pixhawk is in firmware update } if (mode_init()) { return; // don't go any further if the Pixhawk is initializing } if (mode_failsafe_radio()) { return; // don't go any further if the Pixhawk is is in radio failsafe } set_standard_colors(); if (mode_failsafe_batt()) { return; // stop here if the battery is low. } if (_pattern_override) { return; // stop here if in mavlink LED control override. } if (mode_auto_flight()) { return; // stop here if in an autopilot mode. } mode_pilot_flight(); // stop here if in an pilot controlled mode. } // Slow the update rate from 50hz to 10hz // Returns true if counting up // Returns false and resets one counter hits 5 bool OreoLED_I2C::slow_counter() { _slow_count++; if (_slow_count < 5) { return true; } else { _slow_count = 0; return false; } } // Procedure for when Pixhawk is in FW update / bootloader // Makes all LEDs go into color cycle mode // Returns true if firmware update in progress. False if not bool OreoLED_I2C::mode_firmware_update() { if (AP_Notify::flags.firmware_update) { set_macro(OREOLED_INSTANCE_ALL, OREOLED_PARAM_MACRO_COLOUR_CYCLE); return true; } else { return false; } } // Makes all LEDs rapidly strobe blue while gyros initialize. bool OreoLED_I2C::mode_init() { if (AP_Notify::flags.initialising) { set_rgb(OREOLED_INSTANCE_ALL, OREOLED_PATTERN_STROBE, 0, 0, 255,0,0,0,PERIOD_SUPER,0); return true; } else { return false; } } // Procedure for when Pixhawk is in radio failsafe // LEDs perform alternating Red X pattern bool OreoLED_I2C::mode_failsafe_radio() { if (AP_Notify::flags.failsafe_radio) { set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SLOW,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SLOW,PO_ALTERNATE); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SLOW,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SLOW,0); } return AP_Notify::flags.failsafe_radio; } // Procedure to set standard rear LED colors in aviation theme // Back LEDS White for normal, yellow for GPS not usable, purple for EKF bad] // Returns true GPS or EKF problem, returns false if all ok bool OreoLED_I2C::set_standard_colors() { if (!(AP_Notify::flags.gps_fusion)) { _rear_color_r = 255; _rear_color_g = 50; _rear_color_b = 0; return true; } else if (AP_Notify::flags.ekf_bad) { _rear_color_r = 255; _rear_color_g = 0; _rear_color_b = 255; return true; } else { _rear_color_r = 255; _rear_color_g = 255; _rear_color_b = 255; return false; } } // Procedure to set low battery LED output // Colors standard // Fast strobe alternating front/back bool OreoLED_I2C::mode_failsafe_batt() { if (AP_Notify::flags.failsafe_battery) { switch (_oreo_theme) { case OreoLED_Aircraft: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 0, 255, 0,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, _rear_color_r, _rear_color_g, _rear_color_b,0,0,0,PERIOD_FAST,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, _rear_color_r, _rear_color_g, _rear_color_b,0,0,0,PERIOD_FAST,PO_ALTERNATE); break; case OreoLED_Automobile: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_FAST,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_FAST,PO_ALTERNATE); break; default: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_FAST,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_FAST,PO_ALTERNATE); break; } } return AP_Notify::flags.failsafe_battery; } // Procedure for when Pixhawk is in an autopilot mode // Makes all LEDs strobe super fast using standard colors bool OreoLED_I2C::mode_auto_flight() { switch (_oreo_theme) { case OreoLED_Aircraft: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SUPER,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 0, 255, 0,0,0,0,PERIOD_SUPER,0); if ((AP_Notify::flags.pre_arm_check && AP_Notify::flags.pre_arm_gps_check) || AP_Notify::flags.armed) { set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, _rear_color_r, _rear_color_g, _rear_color_b,0,0,0,PERIOD_SUPER,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, _rear_color_r, _rear_color_g, _rear_color_b,0,0,0,PERIOD_SUPER,PO_ALTERNATE); } else { set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_SOLID, _rear_color_r, _rear_color_g, _rear_color_b); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_SOLID, _rear_color_r, _rear_color_g, _rear_color_b); } break; case OreoLED_Automobile: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_SUPER,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_SUPER,0); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SUPER,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SUPER,PO_ALTERNATE); break; default: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_SUPER,0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_STROBE, 255, 255, 255,0,0,0,PERIOD_SUPER,0); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SUPER,PO_ALTERNATE); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, 255, 0, 0,0,0,0,PERIOD_SUPER,PO_ALTERNATE); break; } return AP_Notify::flags.autopilot_mode; } // Procedure for when Pixhawk is in a pilot controlled mode // All LEDs use standard pattern and colors bool OreoLED_I2C::mode_pilot_flight() { switch (_oreo_theme) { case OreoLED_Aircraft: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_SOLID, 255, 0, 0); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_SOLID, 0, 255, 0); if ((AP_Notify::flags.pre_arm_check && AP_Notify::flags.pre_arm_gps_check) || AP_Notify::flags.armed) { set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_STROBE, _rear_color_r, _rear_color_g, _rear_color_b,0,0,0,PERIOD_FAST,0); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_STROBE, _rear_color_r, _rear_color_g, _rear_color_b,0,0,0,PERIOD_FAST,PO_ALTERNATE); } else { set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_SOLID, _rear_color_r, _rear_color_g, _rear_color_b); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_SOLID, _rear_color_r, _rear_color_g, _rear_color_b); } break; case OreoLED_Automobile: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_SOLID, 255, 255, 255); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_SOLID, 255, 255, 255); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_SOLID, 255, 0, 0); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_SOLID, 255, 0, 0); break; default: set_rgb(OREOLED_FRONTLEFT, OREOLED_PATTERN_SOLID, 255, 255, 255); set_rgb(OREOLED_FRONTRIGHT, OREOLED_PATTERN_SOLID, 255, 255, 255); set_rgb(OREOLED_BACKLEFT, OREOLED_PATTERN_SOLID, 255, 0, 0); set_rgb(OREOLED_BACKRIGHT, OREOLED_PATTERN_SOLID, 255, 0, 0); break; } return true; } // set_rgb - Solid color settings only void OreoLED_I2C::set_rgb(uint8_t instance, uint8_t red, uint8_t green, uint8_t blue) { set_rgb(instance, OREOLED_PATTERN_SOLID, red, green, blue); } // set_rgb - Set a color and selected pattern. void OreoLED_I2C::set_rgb(uint8_t instance, oreoled_pattern pattern, uint8_t red, uint8_t green, uint8_t blue) { // get semaphore WITH_SEMAPHORE(_sem); // check for all instances if (instance == OREOLED_INSTANCE_ALL) { // store desired rgb for all LEDs for (uint8_t i=0; i<OREOLED_NUM_LEDS; i++) { _state_desired[i].set_rgb(pattern, red, green, blue); if (!(_state_desired[i] == _state_sent[i])) { _send_required = true; } } } else if (instance < OREOLED_NUM_LEDS) { // store desired rgb for one LED _state_desired[instance].set_rgb(pattern, red, green, blue); if (!(_state_desired[instance] == _state_sent[instance])) { _send_required = true; } } } // set_rgb - Sets a color, pattern, and uses extended options for amplitude, period, and phase offset void OreoLED_I2C::set_rgb(uint8_t instance, oreoled_pattern pattern, uint8_t red, uint8_t green, uint8_t blue, uint8_t amplitude_red, uint8_t amplitude_green, uint8_t amplitude_blue, uint16_t period, uint16_t phase_offset) { WITH_SEMAPHORE(_sem); // check for all instances if (instance == OREOLED_INSTANCE_ALL) { // store desired rgb for all LEDs for (uint8_t i=0; i<OREOLED_NUM_LEDS; i++) { _state_desired[i].set_rgb(pattern, red, green, blue, amplitude_red, amplitude_green, amplitude_blue, period, phase_offset); if (!(_state_desired[i] == _state_sent[i])) { _send_required = true; } } } else if (instance < OREOLED_NUM_LEDS) { // store desired rgb for one LED _state_desired[instance].set_rgb(pattern, red, green, blue, amplitude_red, amplitude_green, amplitude_blue, period, phase_offset); if (!(_state_desired[instance] == _state_sent[instance])) { _send_required = true; } } } // set_macro - set macro for one or all LEDs void OreoLED_I2C::set_macro(uint8_t instance, oreoled_macro macro) { WITH_SEMAPHORE(_sem); // check for all instances if (instance == OREOLED_INSTANCE_ALL) { // store desired macro for all LEDs for (uint8_t i=0; i<OREOLED_NUM_LEDS; i++) { _state_desired[i].set_macro(macro); if (!(_state_desired[i] == _state_sent[i])) { _send_required = true; } } } else if (instance < OREOLED_NUM_LEDS) { // store desired macro for one LED _state_desired[instance].set_macro(macro); if (!(_state_desired[instance] == _state_sent[instance])) { _send_required = true; } } } // Clear the desired state void OreoLED_I2C::clear_state(void) { WITH_SEMAPHORE(_sem); for (uint8_t i=0; i<OREOLED_NUM_LEDS; i++) { _state_desired[i].clear_state(); } _send_required = false; } /* send a command onto the I2C bus */ bool OreoLED_I2C::command_send(oreoled_cmd_t &cmd) { //printf("sending %u\n", cmd.num_bytes); _dev->set_address(OREOLED_BASE_I2C_ADDR + cmd.led_num); /* Calculate XOR CRC and append to the i2c write data */ uint8_t cmd_xor = OREOLED_BASE_I2C_ADDR + cmd.led_num; for (uint8_t i = 0; i < cmd.num_bytes; i++) { cmd_xor ^= cmd.buff[i]; } cmd.buff[cmd.num_bytes++] = cmd_xor; uint8_t reply[3] {}; bool ret = _dev->transfer(cmd.buff, cmd.num_bytes, reply, sizeof(reply)); //printf("command[%u] %02x %02x %02x %s -> %02x %02x %02x\n", cmd.led_num, ret?"OK":"fail", reply[0], reply[1], reply[2]); return ret; } /* send boot command to all LEDs */ void OreoLED_I2C::boot_leds(void) { oreoled_cmd_t cmd; for (uint8_t i=0; i<OREOLED_NUM_LEDS; i++) { cmd.led_num = i; cmd.buff[0] = OREOLED_BOOT_CMD_BOOT_APP; cmd.buff[1] = OREOLED_BOOT_CMD_BOOT_NONCE; cmd.buff[2] = OREOLED_BASE_I2C_ADDR + i; cmd.num_bytes = 3; command_send(cmd); } } // update_timer - called by scheduler and updates driver with commands void OreoLED_I2C::update_timer(void) { WITH_SEMAPHORE(_sem); uint32_t now = AP_HAL::millis(); if (_boot_count < 20 && now - _last_boot_ms > 100) { // send boot command 20 times _boot_count++; _last_boot_ms = now; boot_leds(); } // send a sync every 4.1s. The driver uses 4ms, but using // exactly 4ms does not work. It seems that the oreoled firmware // relies on the inaccuracy of the NuttX scheduling for this to // work, and exactly 4ms from ChibiOS causes syncronisation to // fail if (now - _last_sync_ms > 4100) { _last_sync_ms = now; send_sync(); } // exit immediately if send not required, or state is being updated if (!_send_required) { return; } // for each LED for (uint8_t i=0; i<OREOLED_NUM_LEDS; i++) { // check for state change if (true) { switch (_state_desired[i].mode) { case OREOLED_MODE_MACRO: { oreoled_cmd_t cmd {}; cmd.led_num = i; cmd.buff[0] = OREOLED_PATTERN_PARAMUPDATE; cmd.buff[1] = OREOLED_PARAM_MACRO; cmd.buff[2] = _state_desired[i].macro; cmd.num_bytes = 3; command_send(cmd); break; } case OREOLED_MODE_RGB: { oreoled_cmd_t cmd {}; cmd.led_num = i; cmd.buff[0] = _state_desired[i].pattern; cmd.buff[1] = OREOLED_PARAM_BIAS_RED; cmd.buff[2] = _state_desired[i].red; cmd.buff[3] = OREOLED_PARAM_BIAS_GREEN; cmd.buff[4] = _state_desired[i].green; cmd.buff[5] = OREOLED_PARAM_BIAS_BLUE; cmd.buff[6] = _state_desired[i].blue; cmd.num_bytes = 7; command_send(cmd); break; } case OREOLED_MODE_RGB_EXTENDED: { oreoled_cmd_t cmd {}; cmd.led_num = i; cmd.buff[0] = _state_desired[i].pattern; cmd.buff[1] = OREOLED_PARAM_BIAS_RED; cmd.buff[2] = _state_desired[i].red; cmd.buff[3] = OREOLED_PARAM_BIAS_GREEN; cmd.buff[4] = _state_desired[i].green; cmd.buff[5] = OREOLED_PARAM_BIAS_BLUE; cmd.buff[6] = _state_desired[i].blue; cmd.buff[7] = OREOLED_PARAM_AMPLITUDE_RED; cmd.buff[8] = _state_desired[i].amplitude_red; cmd.buff[9] = OREOLED_PARAM_AMPLITUDE_GREEN; cmd.buff[10] = _state_desired[i].amplitude_green; cmd.buff[11] = OREOLED_PARAM_AMPLITUDE_BLUE; cmd.buff[12] = _state_desired[i].amplitude_blue; // Note: The Oreo LED controller expects to receive uint16 values // in little endian order cmd.buff[13] = OREOLED_PARAM_PERIOD; cmd.buff[14] = (_state_desired[i].period & 0xFF00) >> 8; cmd.buff[15] = (_state_desired[i].period & 0x00FF); cmd.buff[16] = OREOLED_PARAM_PHASEOFFSET; cmd.buff[17] = (_state_desired[i].phase_offset & 0xFF00) >> 8; cmd.buff[18] = (_state_desired[i].phase_offset & 0x00FF); cmd.num_bytes = 19; command_send(cmd); break; } default: break; }; // save state change _state_sent[i] = _state_desired[i]; } } // flag updates sent _send_required = false; } void OreoLED_I2C::send_sync(void) { /* set I2C address to zero */ _dev->set_address(0); /* prepare command : 0x01 = general hardware call, 0x00 = I2C address of master (but we don't act as a slave so set to zero)*/ uint8_t msg[] = {0x01, 0x00}; /* send I2C command */ _dev->set_retries(0); _dev->transfer(msg, sizeof(msg), nullptr, 0); _dev->set_retries(2); } // Handle an LED_CONTROL mavlink message void OreoLED_I2C::handle_led_control(const mavlink_message_t &msg) { // decode mavlink message mavlink_led_control_t packet; mavlink_msg_led_control_decode(&msg, &packet); // exit immediately if instance is invalid if (packet.instance >= OREOLED_NUM_LEDS && packet.instance != OREOLED_INSTANCE_ALL) { return; } // if pattern is OFF, we clear pattern override so normal lighting should resume if (packet.pattern == LED_CONTROL_PATTERN_OFF) { _pattern_override = 0; clear_state(); return; } if (packet.pattern == LED_CONTROL_PATTERN_CUSTOM) { // Here we handle two different "sub commands", // depending on the bytes in the first CUSTOM_HEADER_LENGTH // of the custom pattern byte buffer // Return if we don't have at least CUSTOM_HEADER_LENGTH bytes if (packet.custom_len < CUSTOM_HEADER_LENGTH) { return; } // check for the RGB0 sub-command if (memcmp(packet.custom_bytes, "RGB0", CUSTOM_HEADER_LENGTH) == 0) { // check to make sure the total length matches the length of the RGB0 command + data values if (packet.custom_len != CUSTOM_HEADER_LENGTH + 4) { return; } // check for valid pattern id if (packet.custom_bytes[CUSTOM_HEADER_LENGTH] >= OREOLED_PATTERN_ENUM_COUNT) { return; } // convert the first byte after the command to a oreoled_pattern oreoled_pattern pattern = (oreoled_pattern)packet.custom_bytes[CUSTOM_HEADER_LENGTH]; // call the set_rgb function, using the rest of the bytes as the RGB values set_rgb(packet.instance, pattern, packet.custom_bytes[CUSTOM_HEADER_LENGTH + 1], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 2], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 3]); } else if (memcmp(packet.custom_bytes, "RGB1", CUSTOM_HEADER_LENGTH) == 0) { // check for the RGB1 sub-command // check to make sure the total length matches the length of the RGB1 command + data values if (packet.custom_len != CUSTOM_HEADER_LENGTH + 11) { return; } // check for valid pattern id if (packet.custom_bytes[CUSTOM_HEADER_LENGTH] >= OREOLED_PATTERN_ENUM_COUNT) { return; } // convert the first byte after the command to a oreoled_pattern oreoled_pattern pattern = (oreoled_pattern)packet.custom_bytes[CUSTOM_HEADER_LENGTH]; // uint16_t values are stored in custom_bytes in little endian order // assume the flight controller is little endian when decoding values uint16_t period = ((0x00FF & (uint16_t)packet.custom_bytes[CUSTOM_HEADER_LENGTH + 7]) << 8) | (0x00FF & (uint16_t)packet.custom_bytes[CUSTOM_HEADER_LENGTH + 8]); uint16_t phase_offset = ((0x00FF & (uint16_t)packet.custom_bytes[CUSTOM_HEADER_LENGTH + 9]) << 8) | (0x00FF & (uint16_t)packet.custom_bytes[CUSTOM_HEADER_LENGTH + 10]); // call the set_rgb function, using the rest of the bytes as the RGB values set_rgb(packet.instance, pattern, packet.custom_bytes[CUSTOM_HEADER_LENGTH + 1], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 2], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 3], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 4], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 5], packet.custom_bytes[CUSTOM_HEADER_LENGTH + 6], period, phase_offset); } else { // unrecognized command return; } } else { // other patterns sent as macro set_macro(packet.instance, (oreoled_macro)packet.pattern); } _pattern_override = packet.pattern; } OreoLED_I2C::oreo_state::oreo_state() { clear_state(); } void OreoLED_I2C::oreo_state::clear_state() { mode = OREOLED_MODE_NONE; pattern = OREOLED_PATTERN_OFF; macro = OREOLED_PARAM_MACRO_RESET; red = 0; green = 0; blue = 0; amplitude_red = 0; amplitude_green = 0; amplitude_blue = 0; period = 0; repeat = 0; phase_offset = 0; } void OreoLED_I2C::oreo_state::set_macro(oreoled_macro new_macro) { clear_state(); mode = OREOLED_MODE_MACRO; macro = new_macro; } void OreoLED_I2C::oreo_state::set_rgb(enum oreoled_pattern new_pattern, uint8_t new_red, uint8_t new_green, uint8_t new_blue) { clear_state(); mode = OREOLED_MODE_RGB; pattern = new_pattern; red = new_red; green = new_green; blue = new_blue; } void OreoLED_I2C::oreo_state::set_rgb(enum oreoled_pattern new_pattern, uint8_t new_red, uint8_t new_green, uint8_t new_blue, uint8_t new_amplitude_red, uint8_t new_amplitude_green, uint8_t new_amplitude_blue, uint16_t new_period, uint16_t new_phase_offset) { clear_state(); mode = OREOLED_MODE_RGB_EXTENDED; pattern = new_pattern; red = new_red; green = new_green; blue = new_blue; amplitude_red = new_amplitude_red; amplitude_green = new_amplitude_green; amplitude_blue = new_amplitude_blue; period = new_period; phase_offset = new_phase_offset; } bool OreoLED_I2C::oreo_state::operator==(const OreoLED_I2C::oreo_state &os) { return ((os.mode==mode) && (os.pattern==pattern) && (os.macro==macro) && (os.red==red) && (os.green==green) && (os.blue==blue) && (os.amplitude_red==amplitude_red) && (os.amplitude_green==amplitude_green) && (os.amplitude_blue==amplitude_blue) && (os.period==period) && (os.repeat==repeat) && (os.phase_offset==phase_offset)); }