Arduino.ru

Это я понимаю(строки в таком случае будут по очереди мигать, а тут мигают все вместе). Непонятно почему с IF'ами(которые дают не явную задержку), или с прямым указанием задержки delayMicroseconds(1); все работает нормально, а если задержку извлекать из массива, или умножать SV на 10, то начинает мигать.

Тоже мигает:(

Ну вот смотрите, как работает ULN? точно так же - или GND или Z-состояние, согласны? так вот и здесь тоже самое.

Ну а так что-нибудь изменилось?

#define TEST { \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {1, 0, 0, 0, 0, 0, 0, 1}  \
 }

byte rows[8] = {9, 3, 2, 12, A1, 11, 7, 6};        
byte cols[8] = {A0, 4, A2, 5, 10, A3, 8, 13};
bool mem[8][8] = TEST;

void setup()
{
  for(int i = 0; i < 8; i++) pinMode(cols[i], OUTPUT);
}

void loop()
{
  Display();
}

void Display() 
{
  int SV = 0;
  static byte row;
  for (byte col = 0; col < 8; col++) {
    digitalWrite(cols[col], mem[row][col]);
    SV += mem[row][col];
  } 

  pinMode(rows[row], 1);
  delayMicroseconds(SV+1);
  pinMode(rows[row], 0);
  delayMicroseconds(10-(SV+1));
  row++;
  if(row == 8) row = 0;
}

вы код прям отсюда копируете?

Согласен. Но у ULN это по "by design", но ведь это не означает что это "обязательно нужен Z". С digitalWrite работать будет?

P.S. Я понимаю что проблема не в этом, просто "режет глаз" :)

Вот теперь не мигает:) Да, код копирую прямо от сюда через кнопку справа.

Так это дело не в коде, а в вас, а точнее в вашем зрении, у разных людей это воспринимается по разному, кто видит это мерцание, а кто-то нет. И когда взгляд отводите получаются шлейфы, да? Тут выход один - увеличивать частоту кадров, отказавшись от digitalWrite и pinMode  и напрямую управлять регистрами портов.

Можно и с digitalWrite, но логика другая будет, в моем случае если поставить ULN, то нужно будет просто заменить pinMode на digitalWrite, поэтому этим способом и пользуюсь - он более логичен. А тот что описан здесь по-моему называется через ж..пу.

А в чем это "другая логика" будет проявлятся? В том что HIGH/LOW будет инвертирован? Или еще что-то что я не углядел? Если "да", то чем замена pinMode->digitalWrite легче чем замена HIGH->LOW?  (на крайняк можно и digitalWrite(!HIGH) сделать, обойтись вставкой одного симола. На крайняк, дефайн объявить и его менять (имхо самое "то", выносить такие вещи в конфиг).

Не, конечно "дело привычки". Лично мне что-то включать с помощью pinMode кажется намного более алогичным, чем использовать для этого digitalWrite (пусть и инвертированный). Но "доказать" это логически я, конечно, не смогу. Хотя.... вот если смотреть на код с точки зрения "требуемый уровень подготовки для понимания", то pinMode не каждый новичек поймет. а "Z-состояние" вообще в коматоз может вогнать (а если вспомнить страшное слово ВЫСОКОИМПЕДАНСНОЕ, то ваще... ;)  . Воспримут это как "магия".

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

Напрямую в лоб, так думаю должно и ярко светить и не мигать.

#define TEST { \
     {1, 1, 1, 1, 1, 1, 1, 1}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {1, 0, 0, 0, 0, 0, 0, 1}  \
 }
        
bool mem[8][8] = TEST;

void setup()
{
  byte cols[8] = {A0, 4, A2, 5, 10, A3, 8, 13};
  for(int i = 0; i < 8; i++) pinMode(cols[i], OUTPUT);
}

void loop()
{
  Display();
}

void Display() 
{ 
  static byte row;
  if(mem[row][0]) PORTC|=1<<0; else PORTC&=~(1<<0); // A0
  if(mem[row][1]) PORTD|=1<<4; else PORTD&=~(1<<4); // 4
  if(mem[row][2]) PORTC|=1<<2; else PORTC&=~(1<<2); // A2
  if(mem[row][3]) PORTD|=1<<5; else PORTD&=~(1<<5); // 5
  if(mem[row][4]) PORTB|=1<<2; else PORTB&=~(1<<2); // 10
  if(mem[row][5]) PORTC|=1<<3; else PORTC&=~(1<<3); // A3
  if(mem[row][6]) PORTB|=1<<0; else PORTB&=~(1<<0); // 8
  if(mem[row][7]) PORTB|=1<<5; else PORTB&=~(1<<5); // 13

  int SV = 0;
  for(int i = 0; i < 8; i++) SV += mem[row][i];
  
  switch(row) 
  {
    case 0: DDRB|=1<<1; break; // 9
    case 1: DDRD|=1<<3; break; // 3
    case 2: DDRD|=1<<2; break; // 2
    case 3: DDRB|=1<<4; break; // 12
    case 4: DDRC|=1<<1; break; // A1
    case 5: DDRB|=1<<3; break; // 11
    case 6: DDRD|=1<<7; break; // 7
    case 7: DDRD|=1<<6; break; // 6 
  }
  delayMicroseconds(SV+1);
  
  switch(row) 
  {    
    case 0: DDRB&=~(1<<1); break; // 9
    case 1: DDRD&=~(1<<3); break; // 3
    case 2: DDRD&=~(1<<2); break; // 2
    case 3: DDRB&=~(1<<4); break; // 12
    case 4: DDRC&=~(1<<1); break; // A1
    case 5: DDRB&=~(1<<3); break; // 11
    case 6: DDRD&=~(1<<7); break; // 7
    case 7: DDRB&=~(1<<6); break; // 6
  }
  delayMicroseconds(10-(SV+1));
  
  row++;
  if(row == 8) row = 0;
}

Так почему во мне? Я ж говорю, что с IF'ами-то не мигает, а тут такое мигание как будто в скетче есть такой код

void loop()
{
  Display();
Delay(10)
}

#define TEST { \
     {1, 1, 1, 1, 1, 1, 1, 1}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {0, 0, 0, 0, 0, 0, 0, 0}, \
     {1, 0, 0, 0, 0, 0, 0, 1}  \
 }
        
bool mem[8][8] = TEST;

void setup()
{
  byte cols[8] = {A0, 4, A2, 5, 10, A3, 8, 13};
  for(int i = 0; i < 8; i++) pinMode(cols[i], OUTPUT);
}

void loop()
{
  Display();
}

void Display() 
{ 
  static byte row;
  if(mem[row][0]) PORTC|=1<<0; else PORTC&=~(1<<0); // A0
  if(mem[row][1]) PORTD|=1<<4; else PORTD&=~(1<<4); // 4
  if(mem[row][2]) PORTC|=1<<2; else PORTC&=~(1<<2); // A2
  if(mem[row][3]) PORTD|=1<<5; else PORTD&=~(1<<5); // 5
  if(mem[row][4]) PORTB|=1<<2; else PORTB&=~(1<<2); // 10
  if(mem[row][5]) PORTC|=1<<3; else PORTC&=~(1<<3); // A3
  if(mem[row][6]) PORTB|=1<<0; else PORTB&=~(1<<0); // 8
  if(mem[row][7]) PORTB|=1<<5; else PORTB&=~(1<<5); // 13

  int SV = 0;
  for(int i = 0; i < 8; i++) SV += mem[row][i];
  
  switch(row) 
  {
    case 0: DDRB|=1<<1; break; // 9
    case 1: DDRD|=1<<3; break; // 3
    case 2: DDRD|=1<<2; break; // 2
    case 3: DDRB|=1<<4; break; // 12
    case 4: DDRC|=1<<1; break; // A1
    case 5: DDRB|=1<<3; break; // 11
    case 6: DDRD|=1<<7; break; // 7
    case 7: DDRD|=1<<6; break; // 6 
  }
  delayMicroseconds(SV+1);
  
  switch(row) 
  {    
    case 0: DDRB&=~(1<<1); break; // 9
    case 1: DDRD&=~(1<<3); break; // 3
    case 2: DDRD&=~(1<<2); break; // 2
    case 3: DDRB&=~(1<<4); break; // 12
    case 4: DDRC&=~(1<<1); break; // A1
    case 5: DDRB&=~(1<<3); break; // 11
    case 6: DDRD&=~(1<<7); break; // 7
    case 7: DDRB&=~(1<<6); break; // 6
  }
  delayMicroseconds(10-(SV+1));
  
  row++;
  if(row == 8) row = 0;
}

А так верхняя строчка светит тускло, нижние угловые светодиоды светят ярко, а диоды между ними чуть по тусклее.

Так а вы посмотрите на TEST, первая строка и должна вся светиться, подредактируйте как надо, а равномерное свечение можете только вы сделать, просто изменяйте расчет задержек SV*2+1, 18-(SV*2+1) так как нам матрицу не видно. То есть вам нужно сделать такой расчет, что бы 1 светодиод в линии светился с такой же яркостью как и 8. А то что 8 светодиодов в одной линии светятся тускло это нормально, это и есть та самая плата за отказ от ULN.

Ну да, на TEST смотрела. Верхняя строчка вопросов не вызывает, а вот c нижней не понятно:

>нижние угловые светодиоды светят ярко, а диоды между ними чуть по тусклее

Ну а если тест таким сделать, то что происходит?

#define TEST { \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}, \
     {1, 0, 0, 0, 0, 0, 0, 1}  \
 }

А так нижние ярко горят, а остальные тускло.

Тут напрашиваются варианты:

1. Неправильно подключили или "плохой контакт".
2. Максим где-то очепятался когда переводил пины дуины в "прямую запись в порт" (самая низкая вероятность.
3. Сами диоды разного качества (хотя если это "готовая матрица", то должны быть одинаковыми)
4. Вы смотрите на матрицу под углом. Для нижнего ряда угол зрения больше (более вертикально на них смотрите) - и они кажутся ярче.

Ну это ладно, у меня через IF нормально работает. У меня другой вопрос назрел: на компьютере из программы, в отдельном потоке, в дуиду передаются строковые данные типа "0001100000111000011110000001100000011000000110000111111001111110" для отрисовки таймера на матрице. Так вот, как мне отправить другую строку,  но так, чтобы эта строка не спуталась со строкой таймера? Т.е. как разграничить строки?

Попытка подключить матрицу. http://arduino.ru/forum/obshchii/led-matrix-8x8-zazhech-opredelennye-svetodiody

Библиотека загружена

Загрузка кода 

/*
 * Show messages on an 8x8 led matrix,
 * scrolling from right to left.
 *
 * Uses FrequencyTimer2 library to
 * constantly run an interrupt routine
 * at a specified frequency. This
 * refreshes the display without the
 * main loop having to do anything.
 *
 */

#include <FrequencyTimer2.h>

#define SPACE { \
    {0, 0, 0, 0, 0, 0, 0, 0},  \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0} \
}

#define H { \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}  \
}

#define E  { \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}  \
}

#define L { \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 1, 1, 1, 1, 1, 1, 0}  \
}

#define O { \
    {0, 0, 0, 1, 1, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 1, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 0, 1, 0}, \
    {0, 0, 1, 0, 0, 1, 0, 0}, \
    {0, 0, 0, 1, 1, 0, 0, 0}  \
}

byte col = 0;
byte leds[8][8];

// pin[xx] on led matrix connected to nn on Arduino (-1 is dummy to make array start at pos 1)
int pins[17]= {-1, 5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};

// col[xx] of leds = pin yy on led matrix
int cols[8] = {pins[13], pins[3], pins[4], pins[10], pins[06], pins[11], pins[15], pins[16]};

// row[xx] of leds = pin yy on led matrix
int rows[8] = {pins[9], pins[14], pins[8], pins[12], pins[1], pins[7], pins[2], pins[5]};

const int numPatterns = 6;
byte patterns[numPatterns][8][8] = {
  H,E,L,L,O,SPACE
};

int pattern = 0;

void setup() {
  // sets the pins as output
  for (int i = 1; i <= 16; i++) {
    pinMode(pins[i], OUTPUT);
  }

  // set up cols and rows
  for (int i = 1; i <= 8; i++) {
    digitalWrite(cols[i - 1], LOW);
  }

  for (int i = 1; i <= 8; i++) {
    digitalWrite(rows[i - 1], LOW);
  }

  clearLeds();

  // Turn off toggling of pin 11
  FrequencyTimer2::disable();
  // Set refresh rate (interrupt timeout period)
  FrequencyTimer2::setPeriod(2000);
  // Set interrupt routine to be called
  FrequencyTimer2::setOnOverflow(display);

  setPattern(pattern);
}

void loop() {
    pattern = ++pattern % numPatterns;
    slidePattern(pattern, 60);
}

void clearLeds() {
  // Clear display array
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      leds[i][j] = 0;
    }
  }
}

void setPattern(int pattern) {
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      leds[i][j] = patterns[pattern][i][j];
    }
  }
}

void slidePattern(int pattern, int del) {
  for (int l = 0; l < 8; l++) {
    for (int i = 0; i < 7; i++) {
      for (int j = 0; j < 8; j++) {
        leds[j][i] = leds[j][i+1];
      }
    }
    for (int j = 0; j < 8; j++) {
      leds[j][7] = patterns[pattern][j][0 + l];
    }
    delay(del);
  }
}

// Interrupt routine
void display() {
  digitalWrite(cols[col], LOW);  // Turn whole previous column off
  col++;
  if (col == 8) {
    col = 0;
  }
  for (int row = 0; row < 8; row++) {
    if (leds[col][7 - row] == 1) {
      digitalWrite(rows[row], LOW);  // Turn on this led
    }
    else {
      digitalWrite(rows[row], HIGH); // Turn off this led
    }
  }
  digitalWrite(cols[col], HIGH); // Turn whole column on at once (for equal lighting times)

при проверке выдет:

Ошибка один - не надо напрямую подключать системные заголовочные файлы, если только точно не известно зачем именно это делается и что вызовет.

В данном случае неплохо бы прописать #include <arduino.h>

Ошибка два - английским по белому написано, что в последней строке не хватает закрывающей фигурной скобки.

Читать, что именно пишет компилятор - оно иногда полезно бывает -)

аноды и катоды в такой матрице симетричны по нагрузке. В чем смысл катоды подключать к дарлингтонам в то время как аноды подключены к МК напрямую? Если ток через одну линейку предполагается более 20ма то и аноды надо ключами подключать

Они не симеричны по нагрузке. Это динамическая индикация. А почему разберитесь сами. Гугл в помощь.

если у вас нет времени - не отвечайте, кто то другой развеет мои заблуждения

динамическая суть индикации никак не влияет на необходимость соблюдать ограничения по току на выходах МК

возьмем для упрощения ситуацию когда включен один светодиод (или когда включены все) - ток будет протекать от минуса через uln и далее к плюсу через выход мк. Ток протекающий через uln будет равнятся току через МК

смысл усиливать нижнее плечо, если верхнее имеет тот же ток?

В даташите на Мк нет различия по максимальному току на плюс или минус.

в вашей схеме вы предполагаете, что ток на минус МК не потянет, а на плюс потянет - ошибка

Вы видимо скопировали uln из схемы включения семисегиентного индикатора с общим катодом - там есть ассиметрия - например три цифры будет три провода на минус и 7 на плюс и такое включение имеет смысл. С матрицей ассиметрии нет - 8 на 8

Прежде чем делать такие безапелляционные щзаявления, иногда невредно включить головной мозг -)

hint: Динамическая индикация по столбцам. Какие, откуда и куда текут токи, когда включен столбец целиком?

если по столбцам тогда вы правы, тогда четкая ассиметрия на катоды

Так ведь головной мозг, мы тоже включаем, обычно, в режиме динамической индикации :) Частично :) 

На самом деле, тоже регулярно попадая глазами на эту картинку  хочу завопить про "попалим выходы", но славо богу пока успевел перепроверить и вверх тему покрутить почитать. А через месяцок забывается и опять ловлю себя на порыве "предупредить" :) pattern matching срабатывает

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

спасибо за поддержку) вот и меня немного переклинило)

как прочитал про столбцы все понял - слово столбцы стало ключем доступа к основной части головного мозга)

А как сделать чтобы матрицы менялись?

А в чём смысл подключать к дарлингтонам, если можно подключить к MAX72хх?

http://2150692.ru/faq/114-led-matrix-8x8

и не надо заморачиваться динамической индикацией с кучей выводов.

Когда я там писал последний комментарий, то ещё не вникал в скетч, а потом понял, что там каждая точка добавляется обновлением всего кадра, хотя её можно добавлять обновлением строки:

unsigned char disp2[16][2] = {
  0x05, 0x40,  // рисунок сердца по строкам (адрес строки, данные)
  0x04, 0x40,
  0x03, 0x80,
  0x02, 0x80,
  0x01, 0x40,
  0x01, 0x60,
  0x02, 0x90,
  0x03, 0x88,
  0x04, 0x44,
  0x05, 0x44,
  0x06, 0x08,
  0x07, 0x10,
  0x08, 0x20,
  0x08, 0x60,
  0x07, 0x90,
  0x06, 0x88,  // рисунок сердца по строкам (адрес строки, данные)
};