rgb.h

Go to the documentation of this file.

/*
  rgb.h - typedefs, API structure and helper functions for RGB lights and LED strips
 
  Part of grblHAL
 
  Copyright (c) 2024-2025 Terje Io
 
  grblHAL 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.
 
  grblHAL 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 grblHAL. If not, see <http://www.gnu.org/licenses/>.
*/
 
typedef union {
    uint8_t value;
    uint8_t mask;
    struct {
        uint8_t B      :1,
                G      :1,
                R      :1,
                W      :1,
                unused :4;
    };
} rgb_color_mask_t;
 
typedef union {
    uint32_t value;
    struct {
        uint8_t B; 
        uint8_t G; 
        uint8_t R; 
        uint8_t W; 
    };
} rgb_color_t;
 
typedef union {
    uint8_t mask;
    struct {
        uint8_t is_blocking :1,
                is_strip    :1,
                unassigned  :6;
    };
} rgb_properties_t;
 
typedef void (*rgb_set_color_ptr)(uint16_t device, rgb_color_t color);
 
typedef void (*rgb_set_color_masked_ptr)(uint16_t device, rgb_color_t color, rgb_color_mask_t mask);
 
typedef uint8_t (*rgb_set_intensity_ptr)(uint8_t intensity);
 
typedef void (*rgb_write_ptr)(void);
 
typedef struct {
    rgb_set_color_ptr out;                  
    rgb_set_color_masked_ptr out_masked;    
    rgb_write_ptr write;                    
    rgb_set_intensity_ptr set_intensity;    
    rgb_color_t cap;                        
    rgb_properties_t flags;                 
    uint16_t num_devices;                   
} rgb_ptr_t;
 
// helper structure and functions, not used by the core
 
typedef struct {
    uint16_t num_leds;
    uint16_t num_bytes;
    uint8_t *leds;
    uint8_t intensity;
} neopixel_cfg_t;
 
static inline bool rgb_is_neopixels (rgb_ptr_t *device)
{
    return device->out != NULL && device->cap.R > 126 && device->cap.G > 126 && device->cap.B > 126;
}
 
static inline bool rgb_is_onoff (rgb_ptr_t *device)
{
    return device->out != NULL && device->cap.R == 1 && device->cap.G == 1 && device->cap.B == 1;
}
 
static inline void rgb_clear (rgb_ptr_t *device)
{
    if(device->set_intensity)
        device->set_intensity(255);
 
    if(rgb_is_neopixels(device) && device->num_devices) {
 
        uint32_t idx;
 
        for(idx = 0; idx <= device->num_devices; idx++)
            device->out(idx, (rgb_color_t){0});
 
        if(device->num_devices > 1 && device->write)
            device->write();
    }
}
 
// Intensity conversions
 
static inline rgb_color_t rgb_set_intensity (rgb_color_t color, uint8_t intensity)
{
    color.R = (uint8_t)(((color.R + 1) * intensity) >> 8);
    color.G = (uint8_t)(((color.G + 1) * intensity) >> 8);
    color.B = (uint8_t)(((color.B + 1) * intensity) >> 8);
 
    return color;
}
 
static inline rgb_color_t rgb_reset_intensity (rgb_color_t color, uint8_t intensity)
{
    color.R = (uint8_t)((color.R << 8) / (intensity + 1));
    color.G = (uint8_t)((color.G << 8) / (intensity + 1));
    color.B = (uint8_t)((color.B << 8) / (intensity + 1));
 
    return color;
}
 
// RGB to/from 3 bytes per pixel packed format
 
static inline void  rgb_3bpp_pack (uint8_t *led, rgb_color_t color, rgb_color_mask_t mask, uint8_t intensity)
{
    uint32_t R = 0, G = 0, B = 0;
    uint8_t bitmask = 0b10000000;
 
    color = rgb_set_intensity(color, intensity);
 
    do {
        R <<= 3;
        R |= color.R & bitmask ? 0b011 : 0b010;
        G <<= 3;
        G |= color.G & bitmask ? 0b011 : 0b010;
        B <<= 3;
        B |= color.B & bitmask ? 0b011 : 0b010;
    } while(bitmask >>= 1);
 
    if(mask.G) {
        *led++ = (uint8_t)(G >> 16);
        *led++ = (uint8_t)(G >> 8);
        *led++ = (uint8_t)G;
    } else
        led += 3;
 
    if(mask.R) {
        *led++ = (uint8_t)(R >> 16);
        *led++ = (uint8_t)(R >> 8);
        *led++ = (uint8_t)R;
    } else
        led += 3;
 
    if(mask.B) {
        *led++ = (uint8_t)(B >> 16);
        *led++ = (uint8_t)(B >> 8);
        *led   = (uint8_t)B;
    }
}
 
static inline rgb_color_t rgb_3bpp_unpack (uint8_t *led, uint8_t intensity)
{
    rgb_color_t color = {0};
 
    if(intensity) {
 
        uint32_t R = 0, G = 0, B = 0;
        uint8_t bitmask = 0b00000001;
 
        G = *led++ << 16;
        G |= *led++ << 8;
        G |= *led++;
        R = *led++ << 16;
        R |= *led++ << 8;
        R |= *led++;
        B = *led++ << 16;
        B |= *led++ << 8;
        B |= *led;
 
        do {
            if((R & 0b011) == 0b011)
               color.R |= bitmask;
            R >>= 3;
            if((G & 0b011) == 0b011)
               color.G |= bitmask;
            G >>= 3;
            if((B & 0b011) == 0b011)
               color.B |= bitmask;
            B >>= 3;
        } while(bitmask <<= 1);
 
        color = rgb_reset_intensity(color, intensity);
    }
 
    return color;
}
 
// RGB to/from 1 byte per pixel packed format
 
static inline void rgb_1bpp_assign (uint8_t *led, rgb_color_t color, rgb_color_mask_t mask)
{
    if(mask.G)
        *led++ = color.G;
    else
        led++;
 
    if(mask.R)
        *led++ = color.R;
    else
        led++;
 
    if(mask.B)
        *led = color.B;
}
 
static inline void  rgb_1bpp_pack (uint8_t *led, rgb_color_t color, rgb_color_mask_t mask, uint8_t intensity)
{
    color = rgb_set_intensity(color, intensity);
    rgb_1bpp_assign(led, color, mask);
}
 
static inline rgb_color_t rgb_1bpp_unpack (uint8_t *led, uint8_t intensity)
{
    rgb_color_t color = {0};
 
    if(intensity) {
 
        color.G = *led++;
        color.R = *led++; 
        color.B = *led; 
 
        color = rgb_reset_intensity(color, intensity);
    }
 
    return color;
}
 
//