rgb_matrix.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                         - Yggdrasil -                           *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/attributes.hpp>
#include <cpp/common/types.hpp>
#include <cpp/common/utils.hpp>
 
#include <array>
 
namespace bsp::ygg::prph {
 
    class RGBMatrix {
    private:
        constexpr static inline u8 NumLEDs = 9;     
 
    public:
        RGBMatrix() = delete;
 
        static bool init() {
            RGBA8 color = {0};
            for(u8 i = 0; i <= NumLEDs; i++){
                setLed(i, color);
            }
            return true;
        }
 
        static void enable() {
            bsp::SPIA::setMode(bsp::drv::SPIMode::_3);
            SK9822_EN = 1;
            flush();
        }
 
        static void disable() {
            SK9822_EN = 0;
        }
 
        static void clear() {
            RGBA8 color = {0};
            for(u8 i = 0; i <= NumLEDs; i++){
                setLed(i, color);
            }
        }
 
 
        static void setLed(u8 index, RGBA8 color) {
            if (index >= 0 && index < NumLEDs){
                RGBMatrix::s_LEDs[index * 4 + 0] = (0xE0 | color.a);
                RGBMatrix::s_LEDs[index * 4 + 1] = color.b;
                RGBMatrix::s_LEDs[index * 4 + 2] = color.g;
                RGBMatrix::s_LEDs[index * 4 + 3] = color.r;
            }
        }
 
        static void setLedMasked(u16 enableMask, RGBA8 color) {
            for(u16 index = 0; index < NumLEDs; index++){
                if(((enableMask >> index) & 0b1) == 0b1){
                    setLed(index, color);
                } else {
                    setLed(index, { 0x0000'0000 });
                }
            }
        }
 
        static void dice(u8 number, RGBA8 color) {
            clear();
 
            switch (number) {
                case 1: setLedMasked(0b000'010'000, color); break;
                case 2: setLedMasked(0b001'000'100, color); break;
                case 3: setLedMasked(0b001'010'100, color); break;
                case 4: setLedMasked(0b101'000'101, color); break;
                case 5: setLedMasked(0b101'010'101, color); break;
                case 6: setLedMasked(0b101'101'101, color); break;
            }
        }
 
        static void flush(){
             sendStartFrame();
             bsp::SPIA::write(RGBMatrix::s_LEDs);
             sendEndFrame();
         }
 
    private:
        static inline std::array<u8, NumLEDs * 4> s_LEDs;
 
        static inline void sendStartFrame() {
            bsp::SPIA::write<std::array<u8, 4>>({ 0x00, 0x00, 0x00, 0x00 });
        }
 
        static inline void sendEndFrame() {
            bsp::SPIA::write<std::array<u8, 4>>({ 0xFF, 0xFF, 0xFF, 0xFF });
        }
 
    };
 
}