Arduino.ru

Ваш ник указывает на вашу проблему.

Конкретнее если не затруднит. 

либо не хватает питания, либо нужно ставить преобразователь уровня сигнала от ЕСП (3.3в) к матрице(5в)

Плохой контакт. 

спасибо за ответ.

спасибо за ответ.

это исключено.

Подача питания на MAX'ы происходит одновременно с подачей питания на ESP, или с какой-то разницей? Я просто сталкивался пару раз с глюками, когда команда на инициализацию максов в самом начале старта МК не всегда прокатывала, и приводило это именно к случайным глюкам.

Решил повторной инициализацией через какое-то время после первой. Так сказать, контрольной. С некоторой задержкой между ними.

При плохом монтаже, плохом питании, плохих контактах любая импульсная наводка может сбить инициализацию модулей. После этого часть сегментов, всегда с момента наводки до конца перестают отображать информацию. Пока просто жму ресет. Надо попробовать вставить инициализацию модуля раз в секунду. Может поможет.    

Нет. Сам удивился, и долго игрался именно задержками. То помогало, то нет. Или скажем помогало на столе, но вылезало в машине по холодку периодически. Посему плюнул, и сделал повторный инит. Проблема ушла.

ибо в букваре Logic High Input Voltage VIH 3.5V (min)

Здравствуйте, товарищи.

Ситуация такая.

Хочу передавать данные на MAX7219 через shiftOut, без библиотек.

До этого делал часы на 74HC595, там все понятно и всё работает.

В документации на мах вычитал что нужно передавать 16 байт для каждой матрицы, адрес + данные, вроде все понятно.

1.Опускаю chipselect

2. Передаю адрес потом данные через shiftOut, все это в цикле for крутиться 8 раз.

3. Поднимаю chipselect

Данные это двухмерный массив, первый параметр массива определяет какую цифру я хочу отправить в матрицу (состоит из 8 байт), второй указывает на сам конкретный байт который shiftOut отправляет на матрицу, вроде всё верно.

4 таких цикла for вызываются друг за другом, то есть сначала передается 16 байт для первой матрицы, потом для второй (данные проталкиваются дальше как по 595 сдвиговым регистрам) потом для третьей и четвертой.

В результате на экране белиберда...

Железо

1. Ардуино уно

2. Экран их 4х модулей с матрицами 8х8

Сижу туплю уже неделю, вроде все возможные варианты перебрал...

Дайте наводку, что не так то?

Спасибо всем.

Вот сам скетч

#include "Fonts_8x8.h"
// #include <CyberLib.h>

#define csPin  9
#define clockPin 10
#define dataPin 11



int MatrixQty = 4; // Количество матриц
int r;


void setup() {

  pinMode(dataPin, OUTPUT);
  pinMode(csPin, OUTPUT);
  pinMode(clockPin, OUTPUT);

  // Настройка драйверов
  for (int i = 1; i < MatrixQty ; i++) init_matrix(9, 0);  // Decode Mode
  delay(100);
  for (int i = 1; i < MatrixQty ; i++) init_matrix(10, 0); // Яркость
  delay(100);
  for (int i = 1; i < MatrixQty ; i++) init_matrix(11, 7); // Scan Limit количество строк, 8 строк
  delay(100);
  for (int i = 1; i < MatrixQty ; i++) init_matrix(12, 1); // Shutdown
  delay(100);
  for (int i = 1; i < MatrixQty ; i++) init_matrix(15, 0); // Display Test
  delay(100);
  // Serial.begin(9600);
}

void loop() {

  // Требуется заполнить все матрицы (каждую своим) массивом байт (цифрой)

  static unsigned long delay_time2; // Каждые N секунд обновляем матрицы
  if ((millis() - delay_time2) > 3000) {

    delay_time2 = millis();

    r = r + 1;
    if (r > 10) r = 0;

    // for (int d = 0; d < 8; d++) send_matrix(d + 1, digit_array_3[r][d]); // Передать адрес строки и данные строки, повторить 8 раз для всех строк (1й модуль)
    send_matrix();
  }
}


// void send_matrix(int addr, int vol) {
void send_matrix() {
  // В MAX7219 нумерация аресов регистров строк начинается с 1
  // Отправить 16 байт адрес + данные
  // Открыть Cs, передать адрес, предать байт, повторить 8 раз
  // Отправка для первой матрицы
  digitalWrite(csPin, LOW);
  for (int a = 0; a < 7; a++) {
    shiftOut(dataPin, clockPin, MSBFIRST, a + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[1][a]);
  }
  //digitalWrite(csPin, HIGH);

  // Отправка для второй матрицы
  //digitalWrite(csPin, LOW);
  for (int b = 0; b < 7; b++) {
    shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[2][b]);
  }
  //digitalWrite(csPin, HIGH);

  // Отправка для третьей матрицы
  //digitalWrite(csPin, LOW);
  for (int c = 0; c < 7; c++) {
    shiftOut(dataPin, clockPin, MSBFIRST, c + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[3][c]);
  }
  //digitalWrite(csPin, HIGH);

  // Отправка для четвертой матрицы
  //digitalWrite(csPin, LOW);
  for (int d = 0; d < 7; d++) {
    shiftOut(dataPin, clockPin, MSBFIRST, d + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[4][d]);
  }
  digitalWrite(csPin, HIGH);

  // Это выводит одинаковые цифры на всех матрицах и то с артефактами
  //  digitalWrite(csPin, LOW);
  //  shiftOut(dataPin, clockPin, MSBFIRST, addr);
  //  shiftOut(dataPin, clockPin, MSBFIRST, vol);
  //  digitalWrite(csPin, HIGH);

  // Это по сути тот же shiftOut
  //  digitalWrite(csPin, LOW);
  //  for (int i = 0; i < 8; i++)  { // Передаем адрес
  //    digitalWrite(dataPin, !!(addr & (1 << (7 - i)))); // Выставить 0 или 1 на datapin (в зависимости от байта)
  //    digitalWrite(clockPin, HIGH);
  //    digitalWrite(clockPin, LOW);
  //  }
  //
  //  for (int i = 0; i < 8; i++)  { // Передаем байт данных
  //    digitalWrite(dataPin, !!(vol & (1 << (7 - i)))); // Выставить 0 или 1 (в зависимости от байта)
  //    digitalWrite(clockPin, HIGH);
  //    digitalWrite(clockPin, LOW);
  //  }
  //  digitalWrite(csPin, HIGH);
}

void init_matrix(int addr, int vol) {

  // В MAX7219 нумерация аресов регистров строк начинается с 1
  digitalWrite(csPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, addr);
  shiftOut(dataPin, clockPin, MSBFIRST, vol);
  digitalWrite(csPin, HIGH);
}

В чем выражается билеберда?

Должны быть цифры, а получаются хаотичные пиксели, статичные. Отдаленно конечно что то напоминает, но точно не цифры.

Причем если использовать вот эту конструкцию (см.ниже), то цифры корректно (почти) выводятся, но этот массив байтов последовательно заполняет все матрицы, но мне же нужно в каждую матрицу записать свой массив что бы каждая матрица показывала разные цифры.

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

const byte digit_array_3[14][8] // Двухмерный массив символов. Цифры №3  7х7 пикселей (электронные)
{
  {B00000000, B11111100, B11001100, B11001100, B11001100, B11001100, B11001100, B11111100},     // 0
  {B00000000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000},  // 1
  {B00000000, B11111100, B00001100, B00001100, B11111100, B11000000, B11000000, B11111100},     // 2
  {B00000000, B11111100, B00001100, B00001100, B00111100, B00001100, B00001100, B11111100},    // 3
  {B00000000, B11001100, B11001100, B11001100, B11111100, B00001100, B00001100, B00001100},   // 4
  {B00000000, B11111100, B11000000, B11000000, B11111100, B00001100, B00001100, B11111100},    // 5
  {B00000000, B11111100, B11000000, B11000000, B11111100, B11001100, B11001100, B11111100},    // 6
  {B00000000, B11111100, B11001100, B11001100, B00001100, B00001100, B00001100, B00001100},  // 7
  {B00000000, B11111100, B11001100, B11001100, B01111000, B11001100, B11001100, B11111100},    // 8
  {B00000000, B11111100, B11001100, B11001100, B11111100, B00001100, B00001100, B11111100},    // 9
};

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

Попробуйте не выдумывать, а поднимать и опускать защелку после каждого байта, как в примере:

  for (int b = 0; b < 7; b++) {
   digitalWrite(csPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[2][b]);
    digitalWrite(csPin, HIGH);
  }

Спасибо за совет.

Если дергать защелку внутри циклов, то корректно отображается только последняя правая матрица (загрузка происходит через нее).

Остальные матрицы так же отображают тоже что и первая но с артефактами, как буд то потерялись некоторые байты.

На этом фото верно отображается только 0, хотя отправляются числа 1320.

А это те самые 4 цикла for которые последовательно выводят разные массивы.

ну я ж говорил, что не помню, как 7219 работает :)

Значит надо пропихивать данные сразу во все 4 матрицы

замените все ваши 4 цикла одним

for (int b = 0; b < 7; b++) {
 digitalWrite(csPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
  shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[1][b]);

  shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
  shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[3][b]);
 
  shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
  shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[2][b]);
  
  shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
  shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[0][b]);
  digitalWrite(csPin, HIGH);
}

должно вывести либо 1320 или 0231, в зависимости от тотго, как соединены матрицы. Пробуйте

Нашел в одном описании вот это.

24 — DOUT. Последовательный вывод данных. На этом выводе появляются принятые на входе DIN данные c задержкой в 16 с половиной тактов. Почему именно 16.5, а не 16 или 17? Потому что в SPI первая половина такта (после переднего фронта для MODE 0) — чтение, вторая половина такта (задний фронт для режима MODE 0) — сдвиг, а данные появятся на выходе только после сдвига. С помощью DOUT можно каскадно соединить несколько драйверов, при этом выход (DOUT) первого драйвера подключается ко входу (DIN) второго драйвера, выход второго — ко входу третьего и т.д.

Всё получилось!

Блин! Вот я лошара!

Как я сам то до этого не додумался... И ведь была у меня мысль что нужно загонять всё сразу, как с теми же 595.

Спасибо большое!

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

Поэтому отправлять нужно не два байта за раз - они всегда будут приниматься первой матрицей, а набор байтов для всех четырех матриц сразу. Если нужно вывести строку только в одной, то подаваться должно примерно так

{0x01, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} - это для вывода в первую строку первой матрицы

{0x00, 0x00, 0x00, 0x00, 0x05, 0x25, 0x00, 0x00} - это для вывода в пятую строку третьей матрицы

{0x01, 0x25, 0x01, 0x56, 0x01, 0x89, 0x01, 0x88} - это для вывода в первые строки всех матриц

И да, в цикле

for (int b = 0; b < 7; b++) {
 digitalWrite(csPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, b + 1);
  shiftOut(dataPin, clockPin, MSBFIRST, digit_array_3[2][b]);
  digitalWrite(csPin, HIGH);
}

должно быть все-таки

for (int b = 0; b <= 7; b++) 

Таки в матрицах по восемь строк, индекс последней - как раз 7 ))

Про поворот картинки да, это реализовано во многих библиотеках, но у меня заработало без поворота, модули на smd микросхемах.

Если несколько модулей, то нужно заганять последовательно адрес+данные сразу для всех модулей и только потом защелкивать.

Если дергать защелку 8 раз внутри цикла при передаче данных на каждый модуль то фигня выходит. 

Короче говоря эти драйвера по способу загрузки очень похожи на 595 сдвиговые регистры, только тут добавляется еще 1байт с адресом строки.

Сейчас всё заработало вот с таким циклом кстати обратите внимание, цикл стартует с 0 и до 8, а адресность строк в регистре начинается с 1, по этому к адресу плюсуем 1.

for (int a = 0; a < 8; a++) {

    // Отправка для первой матрицы
    digitalWrite(csPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, a + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_1[1][a]);

    // Отправка для второй матрицы
    shiftOut(dataPin, clockPin, MSBFIRST, a + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_1[3][a]);

    // Отправка для третьей матрицы
    shiftOut(dataPin, clockPin, MSBFIRST, a + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_1[2][a]);

    // Отправка для четвертой матрицы
    shiftOut(dataPin, clockPin, MSBFIRST, a + 1);
    shiftOut(dataPin, clockPin, MSBFIRST, digit_array_1[0][a]);
    digitalWrite(csPin, HIGH);
  }
}

Еще раз большое спасибо за советы и подсказки.