Arduino.ru

 назначаем порты ставим переменные dir(я их делаю чтоб сразу во всем коде задержку менять а не тыркатся ну и для подобных вещей ставлю)

7 строка насколько понимаю это выражение служит для хранения информации(чисел вроде)

потом идут два массива

в void setup назначаются наши пины ны выходы

void loop 

if(millis()>time) если количество секунд с начала выполнения программы больше time (сохраненного значения- правда не пойму откуда оно берется) то dir увеличивается на единицу 

if(dir==3) dir=0;   если dir = 3 то то дир станет равно 0

time = millis() + 500; сохраненное значение равно времени вып программы +500

for(int i=0;i<8;i++) v_mem[i] = mask[dir][i]; запускаем оператор и приравниваем наши массивы(насколько понимаю значение i идет от 0-8)

Draw запускает его в конце.

void Draw()
80 {
81 for(byte j = 0; j < 8; j++)  получаем значение от 0 до 8
82 {
83 for(byte f = 0; f < 2; f++) тут от 0 до 2
84 {
85 for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i)); запускае программу на экран 
 86 digitalWrite (catods[j], 1); зажигаем катод
87 delay(1);
88 digitalWrite (catods[j], 0); гасим
89 } 
90 }
91

этот код делает тоже что я делал зацикливая тока по другому 

Изначально time = 0, time это переменная типа unsigned long, правильнее было бы при объявлении сразу записать в нее верное значение:

unsigned long time = millis() + 500;

но я это упустил, если хотите то добавьте, тогда не будет провускаться первая фигура при включении.

И так, мы научились выводить разные символы из битовой маски.

Теперь сделаем отступление.  Попробуем вывести на экран не элемент двумерного массива, а одномерный массив состоящий из 20 байт со сдвигом.

вот массив:

const byte mask[20] = 
{
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

есть идеи как это сделать?

Этот код работает правильно без задержек, так как если вы будите вставлять задержки (как в вашем коде) у вас будет останавливаться индикация.

не меняя код нету . мож разбить его на части???

Естественно меняя код

byte anods[8] = {
  49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {
  12, 3, 4, 53, 6, 52, 10, 9};
int dir=10;
int dir2=2;

void setup()
{
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

/*
const byte mask[3][8] = 
{
{
B11111111,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B11111111
}
  ,
{
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
}
,
{
B00011000,
B00100100,
B01000010,
B10000001,
B10000001,
B01000010,
B00100100,
B00011000
	  }
	};

*/


byte v_mem[20] = 

{
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
	};

const byte mask[20] = 
{
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void loop()
{
{
for(int i = 0; i < 8; i++)
{
 v_mem[i] = mask[i];// меняем от 0-2 и меняются фигуры
 }

{
  Draw();
}
}
}


void Draw()
{
  for(byte j = 0; j < 20; j++)
  {for(byte f = 0; f < 8; f++)
    {
    for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
    digitalWrite (catods[j], 1);
    delay(1);
    digitalWrite (catods[j], 0);
    }
  }
}

какая то хрень 

 А зачем вы увеличели память? у вас что дисплей стал больше?

Короче так:

byte anods[8] = {
  49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {
  12, 3, 4, 53, 6, 52, 10, 9};
int dir=0;
int dir2=2;
unsigned long time = millis() + 200;

byte v_mem[8];

const byte mask[20] = 
{
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void setup()
{
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

void loop()
{
  if(millis()>time)
  {
    dir++;
    if(dir==20) dir=0;
    time = millis() + 200;
  }

  for(int i=0;i<8;i++) v_mem[i] = mask[i+dir];

  Draw();
}


void Draw()
{
  for(byte j = 0; j < 8; j++)
  {
    for(byte f = 0; f < 2; f++)
    {
      for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
      digitalWrite (catods[j], 1);
      delay(1);
      digitalWrite (catods[j], 0);
    }
  }
}

должно выводиться слово ХАЙ! , но оно может выводиться в зеркальном виде, тогда надо поменять порядок заполнения массива памяти:

for(int i=0;i<8;i++) v_mem[7-i] = mask[i+dir];

или двигаться в не том напрвлении, тогда надо поменять направление:

dir--;
if(dir<0) dir=19;

все есть тока x уже целая появляется и перед началом пробежки сыпится изображение

 Теперь память можно просто объявить так

byte v_mem[8];

Это наверное не Х а крест, попробуйте еще раз код перекопировать из #109 сообщения.

попробовал сыптся  после Й в любую сторону 

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

Не понимаю.

www.youtube.com/watch 

посмотри видео 

Код можно посмотреть?

byte anods[8] = {
  49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {
  12, 3, 4, 53, 6, 52, 10, 9};
int dir=0;
int dir2=2;
unsigned long time = millis() + 200;

byte v_mem[8];

const byte mask[20] = 
{
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void setup()
{
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

void loop()
{
  if(millis()>time)
  {
    dir--;
    if(dir<0) dir=19;
    time = millis() + 200;
  }

  for(int i=0;i<8;i++) v_mem[i] = mask[i+dir];

  Draw();
}


void Draw()
{
  for(byte j = 0; j < 8; j++)
  {
    for(byte f = 0; f < 2; f++)
    {
      for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
      digitalWrite (catods[j], 1);
      delay(1);
      digitalWrite (catods[j], 0);
    }
  }
}

мож первые 2 строки в массиве??? 

После того как заканчивается вывод массива надо очистить память:

    if(dir<0)
    {
      dir=19;
      for(int i=0;i<8;i++) v_mem[i] = 0;
    }

byte anods[8] = {
  49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {
  12, 3, 4, 53, 6, 52, 10, 9};
int dir=0;
int dir2=2;
unsigned long time = millis() + 200;

byte v_mem[8];

const byte mask[20] = 
{
  B01111011,
 B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000100,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void setup()
{
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

void loop()
{
  if(millis()>time)
  {
    dir--;
    if(dir<0) dir=19;
    time = millis() + 1000;
  }

  for(int i=0;i<8;i++) v_mem[i] = mask[i+dir];

  Draw();
}


void Draw()
{
  for(byte j = 0; j < 8; j++)
  {
    for(byte f = 0; f < 2; f++)
    {
      for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
      digitalWrite (catods[j], 1);
      delay(1);
      digitalWrite (catods[j], 0);
      
      if(dir<0)
{
  dir=19; ///!!!!!!!!!!!!!!!  cюда ???
  for(int i=0;i<8;i++) v_mem[i] = 0;
}
    }
  }
}

Мы же вроде договорились, что не будем больше трогать эту функцию! В примере куда это надо вставить есть номер строки.

byte anods[8] = {
  49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {
  12, 3, 4, 53, 6, 52, 10, 9};
int dir=0;
int dir2=2;
unsigned long time = millis() + 200;

byte v_mem[8];

const byte mask[20] = 
{
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void setup()
{
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

void loop()
{
  if(millis()>time)
  {
    dir--;
    if(dir<0) dir=19;
    time = millis() + 200;
  }

  for(int i=0;i<8;i++) v_mem[i] = mask[i+dir];
  
  if(dir<0)
{
  dir=19;
  for(int i=0;i<8;i++) v_mem[i] = 0;
}

  Draw();
  
  
  
}


void Draw()
{
  for(byte j = 0; j < 8; j++)
  {
    for(byte f = 0; f < 2; f++)
    {
      for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
      digitalWrite (catods[j], 1);
      delay(1);
      digitalWrite (catods[j], 0);
    }
  }
}

вставил в 51 результат не изменился 

Я вот понять не могу вам номера строки не видно?

byte anods[8] = {
  49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {
  12, 3, 4, 53, 6, 52, 10, 9};
int dir=0;
int dir2=2;
unsigned long time = millis() + 200;

byte v_mem[8];

const byte mask[20] = 
{
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void setup()
{
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

void loop()
{
  if(millis()>time)
  {
    dir--;
    if(dir<0)
    {
      dir=19;
      for(int i=0;i<8;i++) v_mem[i] = 0;
    }
    time = millis() + 200;
  }

  for(int i=0;i<8;i++) v_mem[i] = mask[i+dir];

  Draw();
}


void Draw()
{
  for(byte j = 0; j < 8; j++)
  {
    for(byte f = 0; f < 2; f++)
    {
      for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
      digitalWrite (catods[j], 1);
      delay(1);
      digitalWrite (catods[j], 0);
    }
  }
}

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

А ясно, помимо стирания памяти у нас при присваивании массива в память мы выходим за пределы нашего массива. Есть два варианта:
1. Не давать сумме i+dir становиться больше 19.
2. Увеличить массив на 8 пустых байт.

 1 вариант

  for(int i=0;i<8;i++) 
  {
    if(i+dir < 20){
      v_mem[i] = mask[i+dir];
    }
    else{
      v_mem[i] = 0;
    }
  }

 или так тоже самое

for(int i=0;i<8;i++) if(i+dir < 20) v_mem[i] = mask[i+dir]; else v_mem[i] = 0;

увеличил на 8 вначале и 8 вконце мусор всеравно появляется

покажите код

for(int i=0;i<8;i++) if(i+dir < 20) v_mem[i] = mask[i+dir]; else v_mem[i] = 0;

мусор пропал!!! спасиб

Вы скорее всего (я так предпологаю) не только массив увеличили, а еще и dir=19; изименили на dir=35; о чем я вам не говорил... если бы вы просто добавили в массив 8 нулевых байт, то мусор бы пропал.

совершенно верно. ониб заняли его место. но я увеличил  поэтому и не помогло 

Но первый вариант более грамотный и верный чем второй.

переделаю с первым. счас попробовал его все работало тоже 

спасибо за помощь!"!!!! 

Дохрена нового узнал!!!!

Хоть понял что такое массивы а то 100 раз читал и все никак догнать не мог как их назначать !

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

Ну и можно добавить константу len - это размер массива

byte anods[8] = {49, 11, 8, 13, 51, 7, 2, 5};
byte catods[8] = {12, 3, 4, 53, 6, 52, 10, 9};
unsigned long time = millis() + 200;
byte v_mem[8];
const byte len = 20;
int dir = len - 1;
const byte mask[len] = {
  B01111011,
  B01111011,
  B00000000,
  B01111111,
  B00010000,
  B10001000,
  B00000010,
  B01111111,
  B00000000,
  B00011111,
  B00101000,
  B01001000,
  B00101000,
  B00011111,
  B00000000,
  B01100011,
  B00010100,
  B00001000,
  B00010100,
  B01100011,
};

void setup(){
  for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT);
  for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT);
}

void loop(){
  if(millis()>time){
    dir--;
    if(dir < 0){
      dir = len - 1;
      for(int i = 0; i < 8; i++) v_mem[i] = 0;
    }
    time = millis() + 200;
  }

  for(int i = 0; i < 8;i++) if(i+dir < 20) v_mem[i] = mask[i+dir]; 
  else v_mem[i] = 0;

  Draw();
}


void Draw(){
  for(byte j = 0; j < 8; j++){
    for(byte f = 0; f < 2; f++){
      for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i));
      digitalWrite (catods[j], 1);
      delay(1);
      digitalWrite (catods[j], 0);
    }
  }
}

решил добавить еще 2 таких экранчика всего получется 3 и разрешение 8 на 24 .

для того чтоб работали нужно поменять некоторые значения кода ???

byte anods[8] = { ./// с 8 на 24
49, 11, 8, 13, 51, 7, 2, 5}; // добавить еще 16 портов
byte catods[8] = {
12, 3, 4, 53, 6, 52, 10, 9};
int dir=10;
int dir2=2;

void setup()
{
for(byte i = 0; i < 8; i++)pinMode(anods[i], OUTPUT); //+16
for(byte i = 0; i < 8; i++)pinMode(catods[i], OUTPUT); //+16
}

/*
const byte mask[3][8] =
{
{
B11111111,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B11111111
}
,
{
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
}
,
{
B00011000,
B00100100,
B01000010,
B10000001,
B10000001,
B01000010,
B00100100,
B00011000
}
};

*/

byte v_mem[20] =

{
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
};

const byte mask[20] =
{
B01111011,
B01111011,
B00000000,
B01111111,
B00010000,
B10001000,
B00000010,
B01111111,
B00000000,
B00011111,
B00101000,
B01001000,
B00101000,
B00011111,
B00000000,
B01100011,
B00010100,
B00001000,
B00010100,
B01100011,
};

void loop()
{
{
for(int i = 0; i < 8; i++) // i<24 ?
{
v_mem[i] = mask[i];// меняем от 0-2 и меняются фигуры
}

{
Draw();
}
}
}

void Draw()
{
for(byte j = 0; j < 20; j++)
{for(byte f = 0; f < 8; f++) //24 ???
{
for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[j], i)); // 24 ?
digitalWrite (catods[j], 1);
delay(1);
digitalWrite (catods[j], 0);
}
}
}

 правильно мыслю????

нет

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

Не надо их синхронизировать, надо просто правильно подключить - аноды надо параллелить, то есть их будет также 8 штук, а катодов станет 24. Нужно увеличить память до 24 байт и в функции Draw нужно только заменить j < 8 на j < 24.

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

все понял про что вы. мы минусом будем включать строки а плюс пойдет по темже 8 проводам одновременно во все экраны. честно говоря я и не подумал об этом.

завтра буду пробовать. а если добовить массив что поменяется в коде.

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

Вообще правильнее было бы сделать 8 катодов и 24 анода, так как в этом случае нужно всего 8 транзисторов.

так и сделаю подключу через два регистра через 1 катоды через второй аноды.  

какаято бредятина через регистры. максимум чего добился это столбик идет слева направо и наоборот



//Пин подключен к ST_CP входу 74HC595
int latchPin = 8;
//Пин подключен к SH_CP входу 74HC595
int clockPin = 9;
//Пин подключен к DS входу 74HC595
int dataPin = 10;
int del = 2;
int del2 =100;
// anod
byte anod[9]=
{ B00000000, // анод 0
B01000000, // 1-
 B00000010, // 2
  B00000100, // 3-
  B00000001, // 4-
  B00001000, // 5-
  B10000000, // 6-
  B00100000, // 7-
 B00010000, // 8-
  };
  
  byte catod[9]=
{ B00000000, // анод 0
B01000000, // 1-
 B00000010, // 2
  B00000100, // 3-
  B00000001, // 4-
  B00001000, // 5-
  B10000000, // 6-
  B00100000, // 7-
 B00010000, // 8-
  };


 
void setup() {
  //устанавливаем режим OUTPUT
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
 
void loop()

{
 for(byte i = 0; i<9; i++)// с лева на право
  //for(byte i = 0; i<9; i++) //с права на лево
  {
  
    // устанавливаем синхронизацию "защелки" на LOW
   digitalWrite(latchPin, LOW);
    // передаем отсчет для вывода на зеленые светодиоды
  //  shiftOut(dataPin, clockPin, MSBFIRST, B00000000); //2
    shiftOut(dataPin, clockPin, MSBFIRST, anod[i]); //1
   // shiftOut(dataPin, clockPin, MSBFIRST, catod[B11111111]); //1
        //"защелкиваем" регистр, тем самым устанавливая значения на выходах
    digitalWrite(latchPin, HIGH);
    // пауза перед следующей итерацией
    delay(del);
 //   shiftOut(dataPin, clockPin, MSBFIRST, anod[0]); //1
//shiftOut(dataPin, clockPin, MSBFIRST, catod[0]);
  }
 }

 

Для 16 на 8. Получается 16 катодов и ведеопамять на 16 столбцов????