Битовые маски будем создовать чуть позже. Для начала давайте попробуем вывести картинку 8х8, для этого нужно создать одномерный массив состоящий из 8 байт по 8 бит - это у нас будет что-то вроде видео-памяти.
Как вы понимаете индикация динамическая. А значит катоды будут включаться по очереди.
Выводить будем так:
Выводим байт B10000001 подсвечиваем на некоторое время 1 катод, затем гасим катод, выводим следуючий байт B01000010, подсвечиваем 2 катод, затем гасим и т.д. В общем это прмерно точно так же как и с часами
оставьте название функции как было Draw - тогда ошибка пропадет.
Вы зачем столько одномерных массивов наплодили? Именно для того, что бы не плодить массивы и более удобно с ними работать существуют многомерные массивы. Засуньте все ваши буквы в один двумерный массив mask[][8] - именно для этого он и предназначен.
И такой вопрос: зачем как вы думаете придумали функции??? для того, чтобы не плодить одни и теже куски кода! А вы наплодили разных функций с одним и тем же кодом. А на что вам видео-память, если вы ей не пользуетесь??? О движении строки пока вам еще рано говорить, вы еще не научились выводить по нормальному символы...
И так. Мы остановились на том, что у нас есть функция вывода на экран Draw(), есть видео-память v_mem[8] и битовая маска mask[][8]. Для чего вы пытаетесь вывести битовую маску сразу на экран??? у нас же есть видео-мапять! при изменении в этой памяти данных будет изменяться картинка на экране. Значит для того чтобы вывести на экран крест или ромб нужно написать функцию, которая будет присваивать массиву v_mem[8] один из элементов массива mask[][8]. По просту говоря эта функция должна заполнять видео-память массивом креста или ромба.
Не подставить а ПРИСВОИТЬ , сделать равным один массив другому, не нужно исправлять объявленный byte v_mem[8], нужно где-нибудь в loop присвоить массив mask[0] массиву v_mem!
Вы не верно присваиваете, вы пытаетесь записать в битовую маску память, а надо наоборот в память записать битовую маску. У нас пока только два массива а битовой маске, поэтому пока ??? будет 0 или 1.
Зачем вы засунули в функцию Draw какойто цикл? Оставьте эту функцию в покое и не изменяйте ее, она выполняет свою задачу как надо, не ломайте функцию, она закончена и такой останется навсегда.
byte anods[8] = {49, 11, 8, 13, 51, 7, 2, 5}; byte catods[8] = {12, 3, 4, 53, 6, 52, 10, 9}; int dir=8; 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); } byte line[8] = { B11010111, //0 B00010001,//1 B01100111,//2 B01110101,//3 B10110001,//4 B11110100,//5 B11110110,//6 B01010001,//7 }; void loop() { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(line, i)); digitalWrite (catods[1],1); }что делаю не так???
Битовые маски будем создовать чуть позже. Для начала давайте попробуем вывести картинку 8х8, для этого нужно создать одномерный массив состоящий из 8 байт по 8 бит - это у нас будет что-то вроде видео-памяти.
Как вы понимаете индикация динамическая. А значит катоды будут включаться по очереди.
byte v_mem[8] = { B10000001; B01000010; B00100100; B00011000; B00011000; B00100100; B01000010; B10000001; }Выводить будем так:
Выводим байт B10000001 подсвечиваем на некоторое время 1 катод, затем гасим катод, выводим следуючий байт B01000010, подсвечиваем 2 катод, затем гасим и т.д. В общем это прмерно точно так же как и с часами
byte anods[8] = {49, 11, 8, 13, 51, 7, 2, 5}; byte catods[8] = {12, 3, 4, 53, 6, 52, 10, 9}; int dir=8; 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); } void loop() { byte v_mem[8] = { B10000001; B01000010; B00100100; B00011000; B00011000; B00100100; B01000010; B10000001; } for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem, i)); digitalWrite (catods[1],1); delay(1); }массив не принимается
1. Объявите его глобально
2. Вы не указали номер элемента массива bitRead(v_mem[1], i));
byte anods[8] = {49, 11, 8, 13, 51, 7, 2, 5}; byte catods[8] = {12, 3, 4, 53, 6, 52, 10, 9}; int dir=8; 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); } byte v_mem[8] = { B10000000, B01000010, B00100100, B00011000, B00011111, B00100100, B01000010, B10000001 }; void loop() { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], v_mem[5]); digitalWrite (catods[1],1); delay(1); }горит вся 2 строка
а куда bitRead делся?
byte anods[8] = {49, 11, 8, 13, 51, 7, 2, 5}; byte catods[8] = {12, 3, 4, 53, 6, 52, 10, 9}; int dir=8; 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); } byte v_mem[8] = { B10000000, B01000010, B00100100, B00011000, B00011111, B00100100, B01000010, B10000001 }; void loop() { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[i], i)); digitalWrite (catods[1],1); delay(1); digitalWrite (catods[1],0); }вся строка кроме крайнего символа
а почему здесь: bitRead(v_mem[i], i)); стоит i ??? , вы же только первый катод подсвечиваете, а значит только первый байт должен выводиться.
убрал поставил 1
Каждый байт из нашей памяти должен соответствовать только одному катоду. Тогда должно гореть 2 точки
И так для каждого катода
byte anods[8] = {49, 11, 8, 13, 51, 7, 2, 5}; byte catods[8] = {12, 3, 4, 53, 6, 52, 10, 9}; int dir=8; 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); } byte v_mem[8] = { B10000001, //0 B01000010,//1 B00100100, B11111000, B00011111, B00100100, B01000010, B10000001 }; void loop() { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[0], i)); digitalWrite (catods[0],1); delay(1); digitalWrite (catods[0],0); for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[1], i)); digitalWrite (catods[1],1); delay(1); digitalWrite (catods[1],0); for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[2], i)); digitalWrite (catods[2],1); delay(1); digitalWrite (catods[2],0); for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[3], i)); digitalWrite (catods[3],1); delay(1); digitalWrite (catods[3],0); //////// for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[4], i)); digitalWrite (catods[4],1); delay(1); digitalWrite (catods[4],0); for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[5], i)); digitalWrite (catods[5],1); delay(1); digitalWrite (catods[5],0); for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[6], i)); digitalWrite (catods[6],1); delay(1); digitalWrite (catods[6],0); for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(v_mem[7], i)); digitalWrite (catods[7],1); delay(1); digitalWrite (catods[7],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=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); } byte v_mem[8] = { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 }; void loop() { for(byte j = 0; j < 8; j++) { 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=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); } byte v_mem[8] = { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 }; void loop() { Draw(); } void Draw(){ for(byte j = 0; j < 8; j++) { 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 массив ???
все ясно .спасиб за помощь. еще не сталкивался никогда с таким. завтра буду пробовать пустить бегущую строук.
А вот теперь можно создать битовую маску состоящую из двумерного массива:
const byte mask[][8] = { { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 } , { B00011000, B00100100, B01000010, B10000001, B10000001, B01000010, B00100100, B00011000 } };это пример из двух картинок крестик и ромбик
а каким образом на 2 массив переходим ??? что поменять в коде
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); } byte a[8] = { B00001110, B00010010, B00100010, B01000010, B01111110, B01000010, B01000010, B01000010 }; byte b[8] = { B01111100, B01000010, B01000010, B01111100, B01000010, B01000010, B01000010, B01111100 }; byte r[8] = { B01111110, B01000000, B01000000, B01000000, B01000000, B01000000, B01000000, B01000000 }; const byte mask[][8] = { { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 } , { B00011000, B00100100, B01000010, B10000001, B10000001, B01000010, B00100100, B00011000 } }; void loop() { int var = 0; while(var < 100){ B(); var++; } int varA=1; while(varA<100){ A(); varA++; } int varr=1; while(varr<100){ R(); varr++; } } void A(){ for(byte j = 0; j < 8; j++) { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(a[j], i)); digitalWrite (catods[j], 1); delay(1); digitalWrite (catods[j], 0); } } void B() { for(byte j = 0; j < 8; j++) { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(b[j], i)); digitalWrite (catods[j], 1); delay(1); digitalWrite (catods[j], 0); } } void R()//r { for(byte j = 0; j < 8; j++) { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(r[j], i)); digitalWrite (catods[j], 1); delay(1); digitalWrite (catods[j], 0); } } void mask() { for(byte j = 0; j < 8; j++) { for(byte i = 0; i < 8; i++) digitalWrite(anods[i], bitRead(mask[j], 2)); digitalWrite (catods[j], 1); delay(1); digitalWrite (catods[j], 0); } }какото косяк в void mask
и как завтавить символ смезаться справа на лево
byte a[8] = {
B00001110,
B00010010,
B00100010,
B01000010,
B01111110,
B01000010,
B01000010,
B01000010
};
получается нужно заставить в массиве единицы двигаться на 1 позицию влево за проход??? или надо писать массив для каждого положения знака???
Вы зачем столько одномерных массивов наплодили? Именно для того, что бы не плодить массивы и более удобно с ними работать существуют многомерные массивы. Засуньте все ваши буквы в один двумерный массив mask[][8] - именно для этого он и предназначен.
И такой вопрос: зачем как вы думаете придумали функции??? для того, чтобы не плодить одни и теже куски кода! А вы наплодили разных функций с одним и тем же кодом. А на что вам видео-память, если вы ей не пользуетесь??? О движении строки пока вам еще рано говорить, вы еще не научились выводить по нормальному символы...
И так. Мы остановились на том, что у нас есть функция вывода на экран Draw(), есть видео-память v_mem[8] и битовая маска mask[][8]. Для чего вы пытаетесь вывести битовую маску сразу на экран??? у нас же есть видео-мапять! при изменении в этой памяти данных будет изменяться картинка на экране. Значит для того чтобы вывести на экран крест или ромб нужно написать функцию, которая будет присваивать массиву v_mem[8] один из элементов массива mask[][8]. По просту говоря эта функция должна заполнять видео-память массивом креста или ромба.
const byte mask[2][8] = {
{
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
}
,
{
B00011000,
B00100100,
B01000010,
B10000001,
B10000001,
B01000010,
B00100100,
B00011000
}
};
это 2 массива по 8 символов - правильно???
Что значит не получается? почитайте про массивы и как присвоить один массив другому.
const byte mask[2][8] = {
{
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
}
,
{
B00011000,
B00100100,
B01000010,
B10000001,
B10000001,
B01000010,
B00100100,
B00011000
}
};
это 2 массива в 1 по 8 символов - правильно???
да, только не символов, а байт, в нашем случае линий.
и как я могу их использовать. мне нужно привязать их к byte v_mem[8] на сколько я понял
Нужно один из массивов записать в память
Нужно присвоить один массив (mask[0]) другому (v_mem)
в byte v_mem[8] = {
B10000001,
B01000010,
B00100100,
B00011000,
B00011000,
B00100100,
B01000010,
B10000001
}; подставить значение одноги из массивов byte mask ?
Не подставить а ПРИСВОИТЬ , сделать равным один массив другому, не нужно исправлять объявленный byte v_mem[8], нужно где-нибудь в loop присвоить массив mask[0] массиву v_mem!
типа как в этом примере??? for(int i = 0; i < 8; i++){
arr1[i] = arr2[i];
}
да, оно самое и так как мы в дальнейшем будем использавать сдвиг нам как раз подходит именно цикл.
for(int i = 0; i < 8; i++){
mask[????][i] = v_mem[i];
}
так както??? только что вместо ???
не могу их прировнять . наверное из за того что один многоуровневый а второй нет
Вы не верно присваиваете, вы пытаетесь записать в битовую маску память, а надо наоборот в память записать битовую маску. У нас пока только два массива а битовой маске, поэтому пока ??? будет 0 или 1.
{
for(int i = 0; i < 8; i++)
{
v_mem[i] = mask[0][i];
}
так ???
и что делать дальше после того как прировняли?
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[8] = { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 }; void loop() { { for(int i = 0; i < 8; i++) { v_mem[i] = mask[1][i];// меняем от 0-2 и меняются фигуры } { 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); } } }так все работает
Теперь нужно вынести в отдельную функцию заполнение видео-памяти, которая будет принимать в качестве аргумента номер массива.
const byte mask[!!!!3!!!][8] то что между восклиувтельными знаками???
вообще ниче не понял
Функции
функция должна принимать один параметр - номер массива (да, это и есть номер массива !!!3!!!) и заполнять видеопамять выбранным массивом.
нам надо менять это число от носительно какогото значения???
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; 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, B00111100, B01111110, B11111111, B11111111, B01111110, B00111100, B00011000 } }; byte v_mem[8] = { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 }; void loop() { ++dir; if(dir>2) dir=0; delay(500); { for(int i = 0; i < 8; i++) { v_mem[i] = mask[dir][i]; } { 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); } } }все фигуры по очереди появляются
Не понял, что значит менять относительно значения?
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; int dar =0; 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, B00111100, B01111110, B11111111, B11111111, B01111110, B00111100, B00011000 } }; byte v_mem[8] = { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 }; void loop() { dir=dir+1; if(dir>2) dir=0; { for(int i = 0; i < 8; i++) { v_mem[i] = mask[dir][i]; } { Draw(); } } delay(1000); } void Draw() { int var = 0; while(var < 20){ var++; 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); } } } }или так
Не понял, что значит менять относительно значения?
наверное не то спросил я просто думал что они завязаны на что то например на еще какую велечину массива но это окащалось тока предположение
Зачем вы засунули в функцию 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); } }ok оставлю. просто когда цикл я могу по очереди выводить элементы массива.счас уберу. что делатьт дальше
Дадно, как писать функции вы так и не поняли, хотя я вам дал ссылку, уж не знаю в чем проблема ... разберетесь позже.
Идикация у нас динамическая, поэтому и речи ни о каких задержках delay(500); и быть не может.
прочитал про функцию. но не понял какая у нас должна быть там с умножнгтнм как пример
что должно быть на экране после пояления функции( я про матрицу)
Можете описать что происходит в коде ниже?
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; byte v_mem[8] = { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 }; const byte mask[3][8] = { { B11111111, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B11111111 } , { B10000001, B01000010, B00100100, B00011000, B00011000, B00100100, B01000010, B10000001 } , { B00011000, B00111100, B01111110, B11111111, B11111111, B01111110, B00111100, B00011000 } }; 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==3) dir=0; time = millis() + 500; } for(int i=0;i<8;i++) v_mem[i] = mask[dir][i]; 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); } } }