Мастерство управления матрицей 8×8 LED с MAX7219: бегущая строка и Bluetooth-управление с Android

В этом уроке Arduino мы научимся управлять матрицей 8×8 LED с помощью драйвера MAX7219 и платы Arduino. Вы можете посмотреть следующее видео или прочитать письменное руководство ниже для получения более подробной информации.

Обзор

Мы сделаем три примера: в первом объясним базовый принцип работы MAX7219, во втором рассмотрим, как работает бегущая строка на матрице 8×8 LED, а в третьем будем управлять ими через Bluetooth и специальное Android-приложение.

MAX7219

Рассмотрим драйвер MAX7219 подробнее. Эта микросхема способна управлять 64 отдельными светодиодами, используя только 3 провода для связи с Arduino. Более того, мы можем соединять в цепочку несколько драйверов и матриц и по-прежнему использовать те же 3 провода.

64 светодиода управляются 16 выводами микросхемы. Как это возможно? Максимальное количество светодиодов, которые могут светиться одновременно, составляет восемь. Светодиоды расположены в виде набора из 8 строк и 8 столбцов. MAX7219 активирует каждый столбец на очень короткий период времени и одновременно управляет каждой строкой. Благодаря быстрому переключению столбцов и строк человеческий глаз воспринимает это как непрерывное свечение.

Обратите внимание, как внутренне расположены выводы обычной матрицы 8×8 LED. Если вы строите матрицу самостоятельно, это нужно учесть.

Также обратите внимание, что обычная плата расширения для MAX7219 поставляется с резистором между 5В и выводом №18 микросхемы. Резистор используется для установки яркости или тока, текущего через светодиоды.

В следующей таблице из даташита микросхемы показано значение резистора, который следует использовать в зависимости от прямого падения напряжения на наших светодиодах.

Схема подключения

Теперь подключим модуль матрицы 8×8 LED к плате Arduino. Вот схема подключения:

Выводы VCC и GND модуля подключаются к выводам 5V и GND Arduino, а три других вывода — DIN, CLK и CS — к любым цифровым выводам Arduino. Если мы хотим подключить более одного модуля, просто соединяем выходные выводы предыдущей платы расширения с входными выводами нового модуля. На самом деле эти выводы все одинаковы, за исключением того, что вывод DOUT предыдущей платы подключается к выводу DIN новой платы.

Компоненты, необходимые для этого урока Arduino, можно найти по ссылкам ниже:

Модуль точечной матрицы 8×8 LED MAX7219…..
Bluetooth-модуль HC-05 ………………………
Плата Arduino ……………………………………..
Безпаечная макетная плата и перемычки …………………

Базовый код Arduino для MAX7219

После подключения модулей мы готовы рассмотреть код Arduino первого примера. Мы будем использовать библиотеку MaxMatrix, которую можно скачать с GitHub.

/* 8x8 LED Matrix MAX7219 Example 01 by Dejan Nedelkovski, www.HowToMechatronics.com Based on the following library: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#include <MaxMatrix.h>
int DIN = 7;
int CLK = 6;
int CS = 5;
int maxInUse = 1;
MaxMatrix m(DIN, CS, CLK, maxInUse);
char A[] = {4, 8, B01111110, B00010001, B00010001, B01111110, };
char B[] = {4, 8, B01111111, B01001001, B01001001, B00110110, };
char smile01[] = {8, 8, B00111100, B01000010, B10010101, B10100001, B10100001, B10010101, B01000010, B00111100 };
char smile02[] = {8, 8, B00111100, B01000010, B10010101, B10010001, B10010001, B10010101, B01000010, B00111100 };
char smile03[] = {8, 8, B00111100, B01000010, B10100101, B10010001, B10010001, B10100101, B01000010, B00111100 };
void setup() {
  m.init();
  m.setIntensity(8);
}
void loop() {
  m.setDot(6,2,true); delay(1000);
  m.setDot(6,3,true); delay(1000);
  m.clear();
  for (int i=0; i<8; i++){
    m.setDot(i,i,true); delay(300);
  }
  m.clear();
  m.writeSprite(2, 0, A); delay(1000);
  m.writeSprite(2, 0, B); delay(1000);
  m.writeSprite(0, 0, smile01); delay(1000);
  m.writeSprite(0, 0, smile02); delay(1000);
  m.writeSprite(0, 0, smile03); delay(1000);
  for (int i=0; i<8; i++){
    m.shiftLeft(false,false); delay(300);
  }
  m.clear();
}Язык кода: Arduino (arduino)

Описание: Сначала подключаем библиотеку MaxMatrix.h, определяем выводы, к которым подключен модуль, задаем количество используемых модулей и создаем объект MaxMatrix.

Для отображения символов нужно определить их в массиве символов или байтов. Здесь приведено несколько примеров. Можно заметить, как биты формируют символы, которые на самом деле являются нулями и единицами. В данном случае они повернуты на 90 градусов, но пример библиотеки рекомендует использовать их именно так, чтобы позже было проще реализовать пользовательскую функцию shiftLeft для прокрутки текста.

В разделе setup просто инициализируем модуль и устанавливаем яркость светодиодов. В разделе loop, используя функцию setDot(), мы можем зажечь любой отдельный светодиод в позиции X, Y или Row/Column, а с помощью функции clear() — очистить дисплей.

Для отображения предопределенных символов используем функцию writeSprite(), где первые два аргумента — это позиция X и Y левого верхнего угла символа. В конце, используя функцию shiftLeft(), сдвигаем или прокручиваем символ влево.

Код Arduino для бегущей строки на матрице 8×8 LED

Теперь рассмотрим пример бегущей строки и посмотрим, чем он отличается. Описание кода находится ниже.

/* 8x8 LED Matrix MAX7219 Scrolling Text Example Based on the following library: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#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, // ^
  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
  3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // s
  4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // t
  5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // u
  5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // v
  5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // w
  4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // x
  3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // y
  3, 8, B00001000, B00110110, B01000001, 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, // ~
};
int DIN = 7;
int CLK = 6;
int CS = 5;
int maxInUse = 2;
MaxMatrix m(DIN, CS, CLK, maxInUse);
byte buffer[10];
char text[]= "HowToMechatronics.com ";
void setup() {
  m.init();
  m.setIntensity(15);
}
void loop() {
  printStringWithShift(text, 100);
}
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i = 0; i < buffer[0] + 1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}Язык кода: Arduino (arduino)

Описание: Здесь нам нужно подключить дополнительную библиотеку для PROGMEM — модификатора переменной, используемого для хранения данных во флеш-памяти вместо SRAM. Когда у нас есть большая база статических переменных, как в данном случае — определение букв и символов, лучше хранить их во флеш-памяти, потому что она намного больше — 32 КБ, по сравнению с 2 КБ SRAM.

Далее, с помощью символьного массива, определяем бегущий текст, а в разделе loop пользовательская функция printStringWithShift выводит бегущий текст на LED-матрицу со скоростью прокрутки, заданной в миллисекундах вторым аргументом. Первое, что делает эта пользовательская функция — извлекает символы из текстовой строки, а затем отображает эти прокручиваемые символы на LED-матрице.

Android-приложение для управления матрицей 8×8 LED через Bluetooth

Теперь, когда мы научились работать с MAX7219, можем сделать третий пример — практический проект Arduino, где мы создадим собственное Android-приложение для управления LED-матрицей через Bluetooth. Прежде чем продолжить, я рекомендую ознакомиться с моими подробными уроками по использованию Bluetooth-модуля HC-05 и созданию собственного Android-приложения с помощью онлайн-приложения MIT App Inventor.

Вот код Arduino, теперь посмотрим на изменения по сравнению с предыдущим примером.

/* 8x8 LED Matrix MAX7219 Scrolling Text Android Control via Bluetooth by Dejan Nedelkovski, www.HowToMechatronics.com Based on the following library: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#include <MaxMatrix.h>
#include <SoftwareSerial.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = { /* ... тот же массив символов ... */ };
int dIn = 7;
int clk = 6;
int cs = 5;
int maxInUse = 2;
MaxMatrix m(dIn, cs, clk, maxInUse);
SoftwareSerial Bluetooth(8, 7);
byte buffer[10];
char incomebyte;
int scrollSpeed = 100;
char text[100] = "HowToMechatronics.com ";
int brightness = 15;
int count = 0;
char indicator;
void setup() {
  m.init();
  m.setIntensity(brightness);
  Bluetooth.begin(38400);
}
void loop() {
  printStringWithShift(text, scrollSpeed);
  if (Bluetooth.available()) {
    indicator = Bluetooth.read();
    if (indicator == '1') {
      for (int i = 0; i < 100; i++) {
        text[i] = 0;
        m.clear();
      }
      while (Bluetooth.available()) {
        incomebyte = Bluetooth.read();
        text[count] = incomebyte;
        count++;
      }
      count = 0;
    } else if (indicator == '2') {
      String sS = Bluetooth.readString();
      scrollSpeed = 150 - sS.toInt();
    } else if (indicator == '3') {
      String sB = Bluetooth.readString();
      brightness = sB.toInt();
      m.setIntensity(brightness);
    }
  }
}
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i = 0; i < buffer[0] + 1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}
void printString(char* s) {
  int col = 0;
  while (*s != 0) {
    if (*s < 32) continue;
    char c = *s - 32;
    memcpy_P(buffer, CH + 7 * c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;
  }
}Язык кода: Arduino (arduino)

Описание: Сначала подключаем библиотеку SoftwareSerial.h для Bluetooth-связи и определяем переменные, необходимые для программы. В разделе setup инициализируем Bluetooth на скорости 38400 бит/с по умолчанию. Установил начальный текст сообщения «HowToMechatronics.com» со скоростью прокрутки 100 миллисекунд.

Далее, в разделе loop, с помощью функции Bluetooth.available() проверяем, есть ли входящие данные от последовательного порта. Если да, с помощью функции Bluetooth.read() начинаем читать последовательный порт, по одному байту за итерацию. Первый входящий байт всегда будет сохранен в переменную «indicator», и в зависимости от него выбираем, будем ли менять текст сообщения, скорость прокрутки или яркость LED-матрицы.

Если посмотреть на блоки кода Android-приложения, можно заметить, что при нажатии кнопки «Send» сначала отправляется индикационный байт, в данном случае «1», что означает, что мы хотим изменить текст сообщения. На стороне Arduino мы очищаем весь символьный массив и также очищаем дисплей LED-матрицы. Затем в цикле «while» считываем остальные данные в последовательном порту — это сообщение, введенное в текстовом поле Android-приложения.

Если индикатор равен «2», это значит, что мы изменили положение ползунка скорости прокрутки. Считываем его новое значение с помощью функции Bluetooth.readString() и регулируем скорость прокрутки. Точно так же регулируем яркость светодиодов.

Здесь можно скачать Android-приложение:

AndrodApp for Arduino 8x8 LED Matrix Control

1 file(s) 1.48 MB Download Мастерство управления матрицей 8×8 LED с MAX7219: бегущая строка и Bluetooth-управление с Android

AndrodApp for Arduino 8×8 LED Matrix Control .aia file

1 file(s) 34.06 KB Download

Это практически всё для этого урока. Если у вас есть вопросы, можете использовать раздел комментариев ниже.