#include <FastLED.h>
#include "Global.h"

uint32_t rocketShip[64] = {
  0x00000000, 0x00000000, 0x00000000, 0x00ff0000, 0x00ff0000, 0x00000000, 0x00000000, 0x00000000, 
	0x00000000, 0x00000000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00000000, 0x00000000, 
	0x00000000, 0x00ff0000, 0x00ff0000, 0x006596e7, 0x006596e7, 0x00ff0000, 0x00ff0000, 0x00000000, 
	0x00ff0000, 0x00ff0000, 0x00ff0000, 0x000060ff, 0x000060ff, 0x00ff0000, 0x00ff0000, 0x00ff0000, 
	0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 
	0x00000000, 0x00000000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00000000, 0x00000000, 
	0x00000000, 0x00000000, 0x00000000, 0x00ff0000, 0x00ff0000, 0x00000000, 0x00000000, 0x00000000, 
	0x00000000, 0x00000000, 0x00000000, 0x00ffd200, 0x00ffd200, 0x00000000, 0x00000000, 0x00000000
};

// Objects
GameObject rocketShipObj{8, 8, 10, 10, rocketShip};

void setup() {
  Serial.begin(115200);
  matrix.init();
  buttons.init();
  buttons.moveObject(&rocketShipObj, 0); // draw the initial position
}

void loop() {
  // Global time
  systemTime = millis();

  // Buttons
  buttons.update();
  buttons.moveObject(&rocketShipObj, 50);
}

TINF_WiSe21_V4.ino

diagram.json

#ifndef GLOBAL_H
#define GLOBAL_H

// *** Setup ***
// --------------------------------------------------
#include <FastLED.h>

#define MATRIX_WIDTH    64
#define MATRIX_HEIGHT   32
#define NUM_PANELS      8
#define NUM_LEDS        (MATRIX_WIDTH * MATRIX_HEIGHT)
#define STRIP_LEDS      (NUM_LEDS / NUM_PANELS)
#define LED1_PIN        6
#define LED2_PIN        7
#define LED3_PIN        8
#define LED4_PIN        9
#define LED5_PIN        10
#define LED6_PIN        11
#define LED7_PIN        12
#define LED8_PIN        13
#define COLOR_ORDER     GRB
#define CHIPSET         WS2811
#define BRIGHTNESS      200

CRGB leds[NUM_LEDS];
uint8_t dirtyPanels = -1;

struct GameObject {
  byte width, height;
  int16_t x, y;
  uint32_t * pixelArray;
};

enum Direction {
  UP = 1 << 0,
  LEFT = 1 << 1,
  DOWN = 1 << 2,
  RIGHT = 1 << 3
};

// *** Timer ***
// --------------------------------------------------
unsigned long systemTime = 0;

// *** Matrix ***
// --------------------------------------------------
struct Matrix {
  void init() {
    // Multiple matrices by sutaburosu
    FastLED.addLeds<CHIPSET, LED1_PIN, COLOR_ORDER>(leds + 0 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED2_PIN, COLOR_ORDER>(leds + 1 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED3_PIN, COLOR_ORDER>(leds + 2 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED4_PIN, COLOR_ORDER>(leds + 3 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED5_PIN, COLOR_ORDER>(leds + 4 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED6_PIN, COLOR_ORDER>(leds + 5 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED7_PIN, COLOR_ORDER>(leds + 6 * STRIP_LEDS, STRIP_LEDS);
    FastLED.addLeds<CHIPSET, LED8_PIN, COLOR_ORDER>(leds + 7 * STRIP_LEDS, STRIP_LEDS);
    FastLED.setCorrection(UncorrectedColor);
    FastLED.setTemperature(UncorrectedTemperature);
    FastLED.setDither(DISABLE_DITHER);
    FastLED.setBrightness(BRIGHTNESS);
  }

  int16_t xy(int16_t x, int16_t y) {
    if (x >= 0 && x < MATRIX_WIDTH && y >= 0 && y < MATRIX_HEIGHT) {
      return x + (y * MATRIX_WIDTH);
    } else {
      return -1;
    }
  }

  // mark the panels covering a range of coordinates as dirty
  void markXYDirty(int16_t minX, byte width, int16_t minY, byte height) {
    int16_t maxX = minX + width - 1;
    int16_t maxY = minY + height - 1;
    // bail out early if the sprite is entirely off screen
    if (minX >= MATRIX_WIDTH || maxX < 0) return;
    if (minY >= MATRIX_HEIGHT || maxY < 0) return;
    // clamp Y axis to valid coordinates
    if (minY < 0) minY = 0;
    if (maxY >= MATRIX_HEIGHT) maxY = MATRIX_HEIGHT - 1;
    // derive the span panels dirtied by this rectangle
    int8_t minPanel = minY / (MATRIX_HEIGHT / NUM_PANELS);
    int8_t maxPanel = maxY / (MATRIX_HEIGHT / NUM_PANELS);
    // and mark each of those panels as dirty
    uint8_t bitSet = 1 << minPanel;
    for (uint8_t panel = minPanel; panel <= maxPanel; panel++) {
      dirtyPanels |= bitSet;
      bitSet <<= 1;
    }
  }

  void clear() {
    FastLED.clear();
  }

  // Refresh only the panels that were changed in the
  // previous OR the current frame.
  void show() {
    static uint8_t previousDirty = 0;
    // merge both frames' dirty panels
    uint8_t totalDirty = previousDirty | dirtyPanels;
    // remember which panels we touched this frame
    previousDirty = dirtyPanels;
    // clear the current panels ready for the next frame
    dirtyPanels = 0;

    uint8_t panel = 0;
    while (totalDirty && panel < NUM_PANELS) {
      if (totalDirty & 1)
        FastLED[panel].showLeds(BRIGHTNESS);
      totalDirty >>= 1;
      panel++;
    }
  }

  void drawGraphics(uint32_t * graphicsArray, byte width, byte height, int16_t xCoord, int16_t yCoord) {
    for (int h = 0; h < height; h++) {
      for (int w = 0; w < width; w++) {
        int16_t xyPos = xy(xCoord + w, yCoord + h);
        if (xyPos >= 0)
          leds[xyPos] = *graphicsArray;
        graphicsArray++;
      }
    }
    // mark the whole area of the sprite as dirty
    markXYDirty(xCoord, width, yCoord, height);
  }
};
Matrix matrix;

// *** Buttons ***
// --------------------------------------------------
struct Buttons {
  uint8_t buttons = 0;
  uint8_t buttonsHistory = 0;

  void init() {
    for (int i = 2; i < 6; i++) {
      pinMode(i, INPUT_PULLUP);
    }
  }

  void update() {
    uint8_t bitSet = 1;
    buttons = 0;
    for (int i = 0; i < 4; i++) {
      if (!digitalRead(i + 2))
        buttons |= bitSet;
      bitSet <<= 1;
    }
  }

  int pressed(int buttonReadInterval) {
    static unsigned long timestamp;
    if (systemTime - timestamp >= buttonReadInterval) {
      timestamp = systemTime;
      buttonsHistory = buttons;
      return buttons;
    }
    return 0;
  }

  void print() {
    Serial.println(buttons, BIN);
  }

  void moveObject(GameObject * object, byte interval) {
    byte buttonPressed = pressed(interval);

    if (buttonPressed & UP)    object->y--;
    if (buttonPressed & LEFT)  object->x--;
    if (buttonPressed & DOWN)  object->y++;
    if (buttonPressed & RIGHT) object->x++;

    if (buttonPressed > 0 || interval == 0) {
      matrix.clear();
      matrix.drawGraphics(object->pixelArray, 8, 8, object->x, object->y);
      matrix.show();
    }
  }
};
Buttons buttons;

#endif

Global.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
FastLED
# ---
