zurück

8x8 LED-Dot-Matrix II.

28.03.2019

Mit dieser Matrix hatte ich schon erste Experimente gemacht, nun kommen einige Neuerungen hinzu.

Verwendete Bauteile

Aufbau

(siehe "8x8 LED-Dot-Matrix")

Ex. 1: Scrolling

Damit man Zeichen über die Matrix laufen lassen kann, wird hier die Library MaxMatrix verwendet.
Der erste Sketch lässt ein einziges Zeichen (Smily) über die Matrix scollen:

Video: Smiley scrollt über die 8x8-LED-Matrix
#include <MaxMatrix.h>

#define PIN_DIN 12
#define PIN_CLK 11
#define PIN_CS  10

#define NUM_DEVICES 1

MaxMatrix ledMatrix(PIN_DIN, PIN_CS, PIN_CLK, NUM_DEVICES);

char smiley[] = {8, 8,
    B00111100,
    B01000010,
    B10010101,
    B10100001,
    B10100001,
    B10010101,
    B01000010,
    B00111100
};

void setup()
{
    ledMatrix.init();
    ledMatrix.setIntensity(8);  // led matrix intensity: 0-15
}

void loop()
{
    ledMatrix.clear();
    ledMatrix.writeSprite(8, 0, smiley);

    for (byte i=0; i<16; i++) {
        ledMatrix.shiftLeft(false, false);
        delay(150);
    }
}

Ex. 2: Text-Scrolling

Im zweiten Experiment lassen wir einen Text über den Display laufen:

Video: Ein Text scrollt über die 8x8-LED-Matrix
#include <MaxMatrix.h>
#include <avr/pgmspace.h>

PROGMEM const unsigned char CH[] = {
    3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
    1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
    3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
    5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
    4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
    5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
    5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
    1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
    3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
    3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
    5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
    5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
    2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
    4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
    2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
    4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
    4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
    3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
    4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
    4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
    4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
    4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
    4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
    4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
    4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
    4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
    2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
    2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
    3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
    3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
    3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
    4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
    5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
    4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
    4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
    4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
    4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
    4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
    4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
    4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
    4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
    3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
    4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
    4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
    4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
    5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
    5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
    4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
    4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
    4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
    4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
    4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
    5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
    4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
    5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
    5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
    5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
    5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
    4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
    2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
    4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
    2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
    3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
    4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
    2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
    4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
    4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
    4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
    4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
    4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
    3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
    4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
    4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
    3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
    4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
    4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
    3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
    5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
    4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
    4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
    4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
    4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
    4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
    4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
    3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
    4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
    5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
    5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
    5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
    4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
    3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
    3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
    1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
    3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
    4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

#define PIN_DIN 12
#define PIN_CLK 11
#define PIN_CS  10

#define NUM_DEVICES 1

MaxMatrix ledMatrix(PIN_DIN, PIN_CS, PIN_CLK, NUM_DEVICES);

byte buffer[10];
char text[] = "elektro.turanis.de   ";

void setup()
{
    ledMatrix.init();
    ledMatrix.setIntensity(8);  // led matrix intensity: 0-15
}

void loop()
{
    // (text, scrolling speed)
    printStringWithShift(text, 150);
}

// Display=the extracted characters with scrolling
void printCharWithShift(char c, int shift_speed)
{
    if (c<32) {
        return;
    }
    c -= 32;
    memcpy_P(buffer, CH + 7 * c, 7);
    ledMatrix.writeSprite(32, 0, buffer);
    ledMatrix.setColumn(32 + buffer[0], 0);
    for (byte i=0; i<buffer[0]+1; i++)
    {
        delay(shift_speed);
        ledMatrix.shiftLeft(false, false);
    }
}

// Extract the characters from the text string
void printStringWithShift(char* s, int shift_speed)
{
    while (*s != 0) {
        printCharWithShift(*s, shift_speed);
        s++;
    }
}

Ex. 3: Scrolling mit Bluetooth

Im dritten Versuch wird per Bluetooth (Aufbau siehe: "Arduino und Bluetooth") ein Text an den Arduino übermittelt und dann als Scroll-Text auf der LED-Matrix dargestellt.

Video: Scroll-Text wird per Bluetooth auf die 8x8-LED-Matrix übertragen.
#include <MaxMatrix.h>
#include <avr/pgmspace.h>

PROGMEM const unsigned char CH[] = {
    3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
    1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
    3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
    5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
    4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
    5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
    5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
    1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
    3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
    3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
    5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
    5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
    2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
    4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
    2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
    4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
    4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
    3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
    4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
    4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
    4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
    4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
    4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
    4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
    4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
    4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
    2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
    2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
    3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
    3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
    3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
    4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
    5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
    4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
    4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
    4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
    4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
    4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
    4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
    4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
    4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
    3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
    4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
    4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
    4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
    5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
    5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
    4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
    4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
    4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
    4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
    4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
    5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
    4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
    5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
    5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
    5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
    5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
    4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
    2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
    4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
    2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
    3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
    4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
    2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
    4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
    4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
    4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
    4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
    4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
    3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
    4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
    4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
    3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
    4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
    4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
    3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
    5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
    4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
    4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
    4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
    4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
    4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
    4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
    3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
    4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
    5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
    5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
    5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
    4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
    3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
    3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
    1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
    3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
    4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

#define PIN_DIN 12
#define PIN_CLK 11
#define PIN_CS  10

#define NUM_DEVICES 1
#define MAX_TEXT_LENGTH 30

MaxMatrix ledMatrix(PIN_DIN, PIN_CS, PIN_CLK, NUM_DEVICES);

byte charBuffer[10], charCount = 0;
char textBuffer[MAX_TEXT_LENGTH] = "";

void setup()
{
    Serial.begin(9600);
    ledMatrix.init();
    ledMatrix.setIntensity(8);  // led matrix intensity: 0-15
}

void loop()
{
    if(Serial.available()) {
        textBuffer[charCount++] = Serial.read();
    } else {
        printStringWithShift(textBuffer, 100);
            for (byte i=0; i<MAX_TEXT_LENGTH; i++) {
            textBuffer[i] = 0;
        }
        charCount = 0;
    }
}

void printCharWithShift(char c, int shiftSpeed)
{
    if (c < 32) {
        return;
    }
    c -= 32;
    memcpy_P(charBuffer, CH + 7 * c, 7);
    ledMatrix.writeSprite(32, 0, charBuffer);
    ledMatrix.setColumn(32 + charBuffer[0], 0);
    for (byte i=0; i<charBuffer[0]+1; i++) {
    delay(shiftSpeed);
    ledMatrix.shiftLeft(false, false);
    }
}

void printStringWithShift(char* s, int shiftSpeed)
{
    while (*s != 0) {
        printCharWithShift(*s, shiftSpeed);
        s++;
    }
}

Spiel "Flappy LED"

Video: Demo des Spiels "Flappy LED".

Hier habe ich das Spiel "Flappy Bird" als vereinfachtes LED-Spiel nachgebaut:

Aufbau

Aufbau des Spiels ”Flappy LED”

Sketch

/**
 * How to play:
 * Goal of the game is to maneuver your flappy LED through holes in walls
 * which are appearing in front of you. If you collide with the ceiling,
 * the floor or one of the walls, the game is over.
 * You achieve one point for each wall you pass.
 */

#include <LedControl.h>

#define PIN_BUTTON  2
#define PIN_CS     10
#define PIN_CLK    11
#define PIN_DIN    12
#define ADDR 0

#define GAME_STATE_RUNNING 1
#define GAME_STATE_END     2

#define FIELD_WIDTH  8
#define FIELD_HEIGHT 8
#define FIELD_SIZE   FIELD_WIDTH*FIELD_HEIGHT
#define BIRD_SPEED   200  // delay in ms

const byte endScreen[] = {B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001};
const byte obstacleTypes[] = {B11000011, B10001111, B11000111, B11100011, B10011111, B11001111, B11100111, B11110011};

LedControl ledMatrix = LedControl(PIN_DIN, PIN_CLK, PIN_CS, 1);
bool buttonState;
byte birdPos, obstacles[8], gameState, nextObstacle;
unsigned long currentMillis, lastBirdAction, lastLevelAction;
int levelSpeed, gameScore;

void setup()
{
  randomSeed(analogRead(0));
  pinMode(PIN_BUTTON, INPUT);
  ledMatrix.shutdown(ADDR, false);
  ledMatrix.setIntensity(ADDR, 8);
  ledMatrix.clearDisplay(ADDR);
  Serial.begin(9600);
  initGame();
}

void loop()
{
  switch (gameState) {
    case GAME_STATE_RUNNING:
      for (byte row = 0; row < FIELD_WIDTH; row++) {
        if (row == 2) {
          ledMatrix.setRow(ADDR, row, obstacles[row] | birdPos);
        } else {
          ledMatrix.setRow(ADDR, row, obstacles[row]);
        }
      }
      if (birdPos <= 0 || birdPos >= 255) {
        endGame();
        break;
      }
      currentMillis = millis();
      processObstacles();
      if (currentMillis - lastBirdAction > BIRD_SPEED) {
        setBirdPos(true);
      }
      if (isButtonPressed()) {
        setBirdPos(false);
      }
      break;
    case GAME_STATE_END:
      if (isButtonPressed()) {
        initGame();
      }
      break;
  }
}

void initGame()
{
  buttonState = false;
  lastBirdAction = millis();
  lastLevelAction = millis();
  levelSpeed = 500;
  birdPos = B00001000;
  nextObstacle = 1;
  gameState = GAME_STATE_RUNNING;
  gameScore = 0;
  ledMatrix.clearDisplay(ADDR);
  for (byte i = 0; i < 8; i++) {
    obstacles[i] = B00000000;
  }
}

void endGame()
{
  gameState = GAME_STATE_END;
  Serial.println("Game over! You score = " + String(gameScore));
  for (byte row = 0; row < 8; row++) {
    ledMatrix.setRow(ADDR, row, endScreen[row]);
  }
  delay(1000);
}

void setBirdPos(bool leftShift)
{
  if (leftShift) {
    birdPos <<= 1;
  } else {
    birdPos >>= 1;
  }
  for (byte i = 0; i < 8; i++) {
    if (bitRead(birdPos, i) == 1 && bitRead(obstacles[2], i) == 1) {
      endGame();
      return;
    }
  }
  lastBirdAction = currentMillis;
}

void processObstacles()
{
  if (currentMillis - lastLevelAction <= levelSpeed) {
    return;
  }
  for (byte i = 1; i < FIELD_WIDTH; i++) {
    obstacles[i - 1] = obstacles[i];
  }
  if (nextObstacle <= 0) {
    obstacles[FIELD_WIDTH - 1] = obstacleTypes[random(sizeof(obstacleTypes))];
    nextObstacle = 3;
    if (levelSpeed > 50) {
      levelSpeed -= 20;
    }
  } else {
    obstacles[FIELD_WIDTH - 1] = B00000000;
    nextObstacle--;
  }

  if (bitRead(obstacles[2], 0) == 0 && bitRead(obstacles[1], 0) == 1) {
    gameScore++;
  }

  lastLevelAction = currentMillis;
}

bool isButtonPressed()
{
  if (!buttonState) {
    if (digitalRead(PIN_BUTTON) == LOW) {
      buttonState = true;
      return true;
    }
  } else {
    if (digitalRead(PIN_BUTTON) == HIGH) {
      buttonState = false;
    }
  }
  return false;
}