Мой код кажется крушением поезда
Я новичок в программировании и подумал, что простым проектом будет создание счетчика боеприпасов. Я устраняю неполадки с этим кодом уже несколько часов и не могу понять, почему мой код пронизан ошибками. Ниже моя программа. Пожалуйста, взгляните на него и дайте мне знать, какую ошибку я сделал. Я опубликую отчет об ошибке под моей программой. Заранее извиняюсь за плохое программирование и надеюсь, что у меня еще есть надежда при должной опеке. Программа отлично работала, когда я запускал тест, используя только одну сохраненную функцию, "twentyBullets()". После того, как я добавил 30 дополнительных функций и создал цепочку условий if-else-if, программа начала сообщать о всевозможных ошибках.
/*
КОД ОБРАЩЕНИЯ С 7-СЕГМЕНТНЫМ ДИСПЛЕЕМ!
Приведенный ниже код обрабатывает 7-сегментный дисплей для цифрового счетчика боеприпасов.
А
___
Ф| |Б
ГАРАНТИРОВАННАЯ ПОБЕДА
Э|___|С
Д
Выше приведено назначение букв алфавита для различных сегментов
дисплей B07BMPPNQY. В проекте цифрового счетчика боеприпасов будут использоваться обычные выводы L3 и L4.
*/
// Показать объявление вывода.
// P_: где P указывает вывод вывода для сегмента дисплея, который должен быть освещен, за которым следует строчная буква
// который указывает, какой конкретный светодиод в сегменте должен светиться.
// десятка: Где десятка указывает разряд десятков на 7-сегментном дисплее.
// one: Где единица указывает позицию единицы на 7-сегментном дисплее.
инт Па = 0;
инт Пб = 1;
инт ПК = 2;
инт Pd = 3;
инт Пе = 4;
инт Пф = 5;
инт Пг = 6;
инт десять = 7;
инт один = 8;
боезапас = 10;
недействительная установка () {
// поместите сюда код установки для однократного запуска:
pinMode (Па, ВЫХОД);
pinMode(Pb, ВЫХОД);
pinMode (ПК, ВЫХОД);
pinMode(Pd, ВЫХОД);
pinMode(Pe, ВЫХОД);
pinMode(Pf, ВЫХОД);
pinMode(Pg, ВЫХОД);
pinMode(десять, ВЫВОД);
pinMode (один, ВЫХОД);
}
недействительный цикл () {
// поместите сюда ваш основной код для многократного запуска:
если (патроны == 1) {
однапуля();
}
иначе если (патроны == 2) {
двепули();
}
иначе если (патроны == 3) {
трипули();
}
иначе если (патроны == 4) {
четырепули();
}
иначе если (патроны == 5) {
пять пуль ( );
} }
иначе если (патроны == 6) {
шесть пуль ( ) ;
} }
иначе если (патроны == 7) {
семьПулей();
} }
иначе если (патроны == 8) {
восемь пуль ( );
} }
иначе если (патроны == 9) {
девять пуль ( );
} }
иначе если (патроны == 10) {
десять пуль ( );
} }
иначе если (патроны == 11) {
одиннадцатьПули ( );
} }
иначе если (патроны == 12) {
двенадцать пуль();
} }
иначе если (патроны == 13) {
тринадцатьПулей();
}
иначе если (патроны == 14) {
четырнадцатьПули();
}
иначе если (патроны == 15) {
пятнадцатьПули();
}
иначе если (патроны == 16) {
шестнадцатьПулей();
}
иначе если (патроны == 17) {
семнадцатьПули();
}
иначе если (патроны == 18) {
восемнадцатьПули();
}
иначе если (патроны == 19) {
девятнадцатьПули();
}
иначе если (патроны == 20) {
двадцать пуль();
}
иначе если (патроны == 21) {
двадцать одна пуля();
}
иначе если (патроны == 22) {
двадцать две пули();
}
иначе если (патроны == 23) {
двадцать три пули();
}
иначе если (патроны == 24) {
двадцать четыре пули();
}
иначе если (патроны == 25) {
двадцать пять пуль();
}
иначе если (патроны == 26) {
двадцать шесть пуль();
}
иначе если (патроны == 27) {
двадцать семь пуль();
}
иначе если (патроны == 28) {
двадцать восемь пуль();
}
иначе если (патроны == 29) {
двадцать девять пуль();
}
иначе если (патроны == 30){
тридцатьПули();
}
еще {
нулевые пули();
}
}
недействительными нулевыми пулями ()
//0
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать одну пулю ()
//1
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать две пули ()
//2
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать три пули ()
//6
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать четыре пули ()
//4
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать пять пуль ()
//5
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, ВЫСОКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать шесть пуль ()
//6
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, ВЫСОКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать семь пуль ()
//7
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать восемь пуль ()
//8
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота девять пуль ()
//9
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//0
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать десять пуль ()
//0
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота одиннадцатьПули()
//1
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота двенадцати пуль ()
//2
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать тринадцать пуль ()
//3
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота четырнадцать пуль ()
//4
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать пятнадцать пуль ()
//5
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, ВЫСОКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота шестнадцать пуль ()
//6
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, ВЫСОКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота семнадцатьПули ()
//7
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать восемнадцать пуль ()
//8
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
пустота девятнадцать пуль ()
//9
{ digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//1
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
}
аннулировать двадцать пуль ()
//0
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать двадцать одну пулю ()
//1
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать двадцать две пули ()
//2
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
пустота двадцать три пули ()
//3
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать двадцать четыре пули ()
//4
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, ВЫСОКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать двадцать пять пуль ()
//5
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, ВЫСОКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
пустота двадцать шесть пуль ()
//6
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, ВЫСОКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать двадцать семь пуль ()
//7
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать двадцать восемь пуль ()
//8
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
пустота двадцать девять пуль ()
//9
{ digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, ВЫСОКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
//2
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, ВЫСОКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
аннулировать тридцать пуль ()
//0
digitalWrite(один, НИЗКИЙ);
digitalWrite(десять, ВЫСОКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, НИЗКИЙ);
цифровая запись (Pf, НИЗКИЙ);
цифровая запись (Pg, ВЫСОКИЙ);
задержка (10);
//3
digitalWrite(один, ВЫСОКИЙ);
digitalWrite(десять, НИЗКИЙ);
цифровая запись (Па, НИЗКИЙ);
цифровая запись (Pb, НИЗКИЙ);
цифровая запись (ПК, НИЗКИЙ);
цифровая запись (Pd, НИЗКИЙ);
цифровая запись (Pe, ВЫСОКИЙ);
цифровая запись (Pf, ВЫСОКИЙ);
цифровая запись (Pg, НИЗКИЙ);
задержка (10);
}
ОТЧЕТ ОБ ОШИБКЕ:
/*
7-SEGMENT DISPLAY HANDLING CODE!
The below code handles the 7-segment display for the digital ammo counter.
A
___
F| |B
G---G
E|___|C
D
Above is the alphabet letter assignment for the different segments of
the B07BMPPNQY display. Digital ammo counter project will use common pins, L3 and L4.
*/
// Display pin declaration.
// P_: Where P indicates the pin output for the segment of the display to be illuminated followed by a lower case letter
// which indicates which specific led in the segment to illuminate.
// ten: Where ten indicates the ten's place on the 7 segment display.
// one: Where one indicates the one's place on the 7 segement display.
int Pa = 0;
int Pb = 1;
int Pc = 2;
int Pd = 3;
int Pe = 4;
int Pf = 5;
int Pg = 6;
int ten = 7;
int one = 8;
int ammo = 10;
void setup() {
// put your setup code here, to run once:
pinMode(Pa, OUTPUT);
pinMode(Pb, OUTPUT);
pinMode(Pc, OUTPUT);
pinMode(Pd, OUTPUT);
pinMode(Pe, OUTPUT);
pinMode(Pf, OUTPUT);
pinMode(Pg, OUTPUT);
pinMode(ten, OUTPUT);
pinMode(one, OUTPUT);
}
void loop(){
// put your main code here, to run repeatedly:
if (ammo == 1) {
oneBullet();
}
else if (ammo == 2) {
twoBullets();
}
else if (ammo == 3) {
threeBullets();
}
else if (ammo == 4) {
fourBullets();
}
else if (ammo == 5) {
fiveBullets();
}
else if (ammo == 6) {
sixBullets();
}
else if (ammo == 7) {
sevenBullets();
}
else if (ammo == 8) {
eightBullets();
}
else if (ammo == 9) {
nineBullets();
}
else if (ammo == 10) {
tenBullets();
}
else if (ammo == 11) {
elevenBullets();
}
else if (ammo == 12) {
twelveBullets();
}
else if (ammo == 13) {
thirteenBullets();
}
else if (ammo == 14) {
fourteenBullets();
}
else if (ammo == 15) {
fifteenBullets();
}
else if (ammo == 16) {
sixteenBullets();
}
else if (ammo == 17) {
seventeenBullets();
}
else if (ammo == 18) {
eighteenBullets();
}
else if (ammo == 19) {
nineteenBullets();
}
else if (ammo == 20) {
twentyBullets();
}
else if (ammo == 21) {
twentyoneBullets();
}
else if (ammo == 22) {
twentytwoBullets();
}
else if (ammo == 23) {
twentythreeBullets();
}
else if (ammo == 24) {
twentyfourBullets();
}
else if (ammo == 25) {
twentyfiveBullets();
}
else if (ammo == 26) {
twentysixBullets();
}
else if (ammo == 27) {
twentysevenBullets();
}
else if (ammo == 28) {
twentyeightBullets();
}
else if (ammo == 29) {
twentynineBullets();
}
else if (ammo == 30){
thirtyBullets();
}
else {
zeroBullets();
}
}
void zeroBullets()
//0
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void oneBullet()
//1
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void twoBullets()
//2
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void threeBullets()
//6
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void fourBullets()
//4
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void fiveBullets()
//5
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, HIGH);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void sixBullets()
//6
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, HIGH);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void sevenBullets()
//7
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void eightBullets()
//8
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void nineBullets()
//9
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
//0
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
}
void tenBullets()
//0
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void elevenBullets()
//1
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void twelveBullets()
//2
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void thirteenBullets()
//3
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void fourteenBullets()
//4
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void fifteenBullets()
//5
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, HIGH);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void sixteenBullets()
//6
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, HIGH);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void seventeenBullets()
//7
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void eighteenBullets()
//8
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void nineteenBullets()
//9
{ digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//1
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
}
void twentyBullets()
//0
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentyoneBullets()
//1
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentytwoBullets()
//2
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentythreeBullets()
//3
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentyfourBullets()
//4
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, HIGH);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentyfiveBullets()
//5
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, HIGH);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentysixBullets()
//6
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, HIGH);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentysevenBullets()
//7
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, HIGH);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentyeightBullets()
//8
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void twentynineBullets()
//9
{ digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, HIGH);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, LOW);
digitalWrite(Pg, LOW);
delay(10);
//2
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, HIGH);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
void thirtyBullets()
//0
digitalWrite(one, LOW);
digitalWrite(ten, HIGH);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, LOW);
digitalWrite(Pf, LOW);
digitalWrite(Pg, HIGH);
delay(10);
//3
digitalWrite(one, HIGH);
digitalWrite(ten, LOW);
digitalWrite(Pa, LOW);
digitalWrite(Pb, LOW);
digitalWrite(Pc, LOW);
digitalWrite(Pd, LOW);
digitalWrite(Pe, HIGH);
digitalWrite(Pf, HIGH);
digitalWrite(Pg, LOW);
delay(10);
}
@pvGuy, 👍15
Обсуждение4 ответа
Каскад ошибок вызван отсутствием открывающей фигурной скобки { в начале функции thirtyBullets(). Это приводит к тому, что имя функции не объявляется, а следующие вызовы функции digitalWrite() завершаются ошибкой. Вставка этой отсутствующей открывающей фигурной скобки должна исправить все ошибки (хотя я не могу проверить это, так как в настоящее время у меня нет под рукой компилятора).
Кроме того, ваш код можно сделать намного короче с помощью хитрости. В настоящее время вы используете одну функцию для каждого числа, где вы записываете соответствующие цифровые контакты. Итак, ситуация такова, что вам всегда нужно писать на одни и те же контакты, просто разные значения в зависимости от простого целого числа без знака. Поэтому я предлагаю вам определить шаблоны выводов для цифр в двумерном массиве. Тогда вы можете использовать только 1 функцию для вывода любого из них. Я приведу вам пример:
uint8_t led_pattern[10][7]= {
{0, 0, 0, 0, 0, 0, 1}, // шаблон для цифры 0
{1, 0, 0, 1, 1, 1, 1}, // шаблон для цифры 1
{0, 0, 1, 0, 0, 1, 0}, // шаблон для цифры 2
...
{0, 0, 0, 0, 1, 0, 0}}; // шаблон для цифры 9
void display_digit(uint8_t position, uint8_t digit){
digitalWrite(one, position); // Записывает низкий уровень (он же ноль) на первый вывод, когда позиция равна нулю, иначе высокий уровень
digitalWrite(ten, !position); // Записывает низкий уровень на десятый вывод, если позиция больше нуля, иначе высокий уровень
for(uint8_t i=0; i<7; i++){
digitalWrite(i, led_pattern[digit][i]);
}
delay(10);
}
void display_number(uint8_t number){
display_digit(0, number % 10);
display_digit(1, number / 10);
}
void loop(){
display_number(ammo);
}
Итак, что здесь происходит?
Сначала мы определяем шаблоны светодиодов в двумерном массиве. Его первый индекс — это цифра, которую мы хотим отобразить; его второй индекс - это номер светодиода, который нужно зажечь. В этом случае значение является состоянием соответствующего светодиода. Я написал 1 и 0, потому что он короткий. Вы также можете написать HIGH и LOW (поскольку они также определены только для 1 и 0). Таким образом, шаблон {1, 0, 0, 1, 1, 1, 1} означает, что только сегменты b и c выводят низкий уровень, поэтому включены.
Затем мы определяем функцию для отображения одной цифры. Он принимает положение цифры и фактическую цифру (от 0 до 9) в качестве параметров. Мы записываем два выхода для нашей позиции непосредственно с помощью переменной. Это очень короткий способ сделать это, и он не работает, когда у вас больше двух цифр. Если вы хотите однажды расширить свой счетчик, вы можете заменить эти две строки другой конструкцией (например, оператором case switch). Затем мы делаем цикл for от 0 до 6, чтобы пройти все цифры. В вашем случае вы используете номера контактов от 0 до 6, поэтому мы можем напрямую использовать i в качестве номера контакта. (Если вы хотите использовать другие контакты, вы можете сохранить эти контакты в массиве и ссылаться на значения в массиве с помощью i). На каждой итерации цикла for мы записываем значение соответствующей цифры и светодиода на соответствующий выходной контакт. После этого мы лишь немного задерживаемся и выходим из функции.
Для упрощения я также определил функцию display_number(), которая будет отображать полное число, последовательно отображая его цифры на соответствующих позициях. Если вы новичок, то можете не понять, какие расчеты я там сделал. Оператор по модулю % возвращает остаток целочисленного деления. Итак, если я возьму 23 % 10, это вернет 3 (целочисленное деление 23/10 равно 2, а остальное равно 3). Это дает нам первую (наименее значащую) цифру. Затем мы можем получить вторую цифру, просто выполнив целочисленное деление на 10, так как при этом будет вырезана часть после десятичной точки. Если вы хотите отображать числа больше 99 в один день, вы должны изменить обе функции, чтобы приспособиться к этому.
Обратите внимание, что я везде использовал uint8_t в качестве типа. Это всего лишь наименьший беззнаковый числовой тип (8-битный). Я использовал наименьшее, так как здесь не нужны большие числа, и это экономит немного памяти. Если вы хотите расширить отображение для отображения значений больше 255, вам нужно изменить тип параметра number в функции display_number() на больший тип, для пример unsigned int (16-битный).
Также обратите внимание, что я не тестировал этот код, так как в настоящее время у меня нет под рукой компилятора или Arduino.
Итак, теперь вы можете отобразить число на своей цифре с помощью всего одного вызова функции, и вам не нужно для этого почти 1000 строк кода.
Расширяя свой код, чтобы он мог делать больше вещей, чем отображать числа, вы можете легко добраться до точки, где использование delay() является плохой вещью, так как Arduino не может делать что-либо еще в это время. время. Затем вам нужно переписать свой код, чтобы избежать delay() и вместо этого использовать функцию millis(), чтобы разблокировать его. Для этого существует множество руководств, и я просто хотел упомянуть об этом.
О Боже! Я сильно корю себя за то, что забыл о такой скромной вещи, как "{"! Это причинило мне большие страдания. Я преклоняюсь перед вашими знаниями Arduino и благодарю вас не только за то, что вы нашли ошибку в моем коде, но и за то, что показали мне гораздо лучший способ пройти весь процесс! Примите мою самую искреннюю благодарность! Вау, я обязательно поковыряюсь в туториалах по Arduino! Надеюсь, когда-нибудь я стану таким же осведомленным в этом вопросе, как и вы!, @pvGuy
Спасибо, но хватит похвал. Мы все начинали с этого момента. Все дело в опыте обучения. Вы можете принять мой ответ как правильный, если считаете, что он правильный. И, может быть, вы захотите вернуться однажды и тоже ответить на вопрос самостоятельно. Мы всегда рады новым участникам :D, @chrisl
Хорошо сделано, предоставляя как узконаправленный ответ, так и руководство по использованию массивов для более элегантного решения проблемы. (проголосовало.) Я думаю, мы не будем пытаться провести новичка через декодирование двоичного кода с использованием битовой маскировки и сдвига..., @Duncan C
*поскольку у меня сейчас нет под рукой компилятора)* Я предлагаю https://godbolt.org/, обозреватель компиляторов Мэтта Годболта. В нем установлены GCC, Clang, MSVC и ICC, включая GCC для ARM и для AVR. С выделением цветом для сопоставления исходных строк с выходными строками asm. (И языки, включая C, C++, Rust, Go, Haskell, ...) Ваш код, скомпилированный как C для ARM cortex M3: https://godbolt.org/z/-K_muB, @Peter Cordes
Вы нашли ошибку, но как можно было найти ее проще?
Самый важный шаг — признать, что вы сделали что-то не так. Мы пока не знаем, что, но крайне маловероятно, что компилятор жалуется на правильный код. Так вот вопрос: что ты сделал не так?
Компилятор пожаловался на функцию "thirtyBullets". Он не жаловался на "twentynineBullets". Он не понимает, что есть функция «тридцатьпулек». Прежде всего, проверьте орфографию. Если бы вы по ошибке назвали функцию «thirrtyBullets», это многое бы объяснило. Но имя правильное.
Тогда вы видите, что компилятор жалуется на строку сразу после запуска функции. Трудно понять, на что жалуется компилятор, поэтому то, что вы сделали непосредственно перед этим, смутило его. Итак, теперь вы проверяете строку «void тридцатьBullets ()», все в порядке, следующую строку «digitalWrite (one, LOW);» выглядит нормально, но что-то здесь ДОЛЖНО быть неправильным, и именно здесь вы, надеюсь, разберетесь с отсутствующим "{".
Просто добавить к идее использования массива — поскольку C не заботится о пробелах, вы можете довольно легко отформатировать свои данные следующим образом:
uint8_t led_pattern[10][7]= {
{0, // шаблон для цифры 0
0, 0,
0,
0, 0,
0},
{0, // шаблон для цифры 1
0, 1,
0,
0, 1,
0},
{1, // шаблон для цифры 2
0, 1,
1,
1, 0,
1},
...
};
Это пример "хорошей привычки" создавать свой код в соответствии с вашими намерениями, а не инструктировать машину. Вы можете потратить на 50 % больше времени на то, чтобы ваш код был понятен, или на 500 % больше времени на его отладку. Как говорится,
Есть два способа разработки программного обеспечения: сделать его настолько простым, чтобы в нем явно не было ошибок, или настолько сложным, чтобы в нем не было очевидных ошибок.
Примечание. Приведенный выше код выдаст вам значения digitalOut в порядке, отличном от порядка ваших контактов (поэтому цикл for Крисла не будет работать). Вы можете просто вручную выполните 7 цифровых операций записи на правильные контакты при отображении digit.
digitalWrite( <pin number> , led_pattern[digit][ <led position> ]);
Ваш код на самом деле неплох. Существует не так много хороших способов сделать такое сопоставление выводов, и те немногие из них, которые есть, также имеют свои недостатки. Основной проблемой была отсутствующая скобка, которую я обнаружил, проверив функцию drawThirty, поскольку она упоминалась конкретно и имела каскадные ошибки, подразумевающие пропущенную точку с запятой или скобку.
Еще одно изменение заключается в том, что ваш код будет работать только на Arduino (так что все в порядке, но другая IDE может вас разозлить). C не ищет имена функций во всем файле, поэтому, если вы объявите/определите функцию после ее использования, произойдет ошибка. Arduino использует специальный препарсер, чтобы исправить это.
Правильный способ - объявить функцию следующим образом:
int returnAPieceOfData(byte x, char c, int i);//Теперь C знает, что он где-то существует, и не будет ошибаться.
void foo(){
//где-то здесь вам нужно returnAPieceOfData
}
int returnAPieceOfData(byte x, char c, int i){
//Теперь вы определяете функцию после ее использования, но без ошибок!
}
Обычно это приводит к созданию файла C, в котором все функции объявлены вверху, а затем приведенные ниже определения функций могут без проблем использовать их в любом порядке. Это также упрощает определение того, есть ли у файла функция, и если вы добавляете их в том же порядке, то где она находится.
Я упомяну потенциально полезный метод альтернативной реализации таблицы поиска массива для записи контактов. Вышеизложенное — очень хорошие предложения, особенно фигурные пробелы, но при таком подходе потребуется много дополнительной памяти, поскольку он использует полные байты на пиксель.
Если вы готовы принять формат, который несколько сложнее визуализировать, вы можете закодировать все пространство в один байт, как я покажу ниже. Вы также можете поместить номера выводов в массив, чтобы можно использовать цикл FOR.
По сути, у вас есть два варианта написания такой системы. Вы можете пойти на сложность кода, как это было в вашем примере, или вы можете пойти на сложность памяти/данных, что я показываю здесь. Недостатки ЭТОГО метода заключаются в том, что данные несколько запутаны и их трудно изменить (поскольку они закодированы и их довольно много), а также в том, что для хранения этих данных требуется дополнительная память.
void drawAllSegments(byte ammo_ct){
byte hi=ammo_ct/10;
byte lo=ammo_ct%10;
drawLowSegments(lo);
drawHighSegments(hi);
}
byte lpinNums[]={apin,bpin,cpin,dpin,epin,fpin,gpin};//пины для отображения 0s
byte hpinNums[]={apin,bpin,cpin,dpin,epin,fpin,gpin};//пины для 10-секундного отображения
byte numbers[]={0b00111111,0b01111001,...};
//Форматировать "числа" как 0bXGFEDCBA, где X — безразлично
//(его значение никогда не используется и может быть либо 0, либо 1)
//Мой пример может быть неправильным. Я думаю, что это отрицательная логика, но, кроме того, могла быть и ошибка.
void drawLowSegments(byte ammo_ct){
digitalWrite(one, HIGH);//настраиваем выбор дисплея
digitalWrite(ten, LOW);
for (byte i=0;i<7;i++){//затем рисуем!
byte state=(numbers[ammo_ct]>>i)&0x01;//распаковываем состояние этого сегмента
digitalWrite(lpinNums[i],state);
}
}
void drawHighSegments(byte ammo_ct){
digitalWrite(one, HIGH);//настраиваем выбор дисплея
digitalWrite(ten, LOW);
for (byte i=0;i<7;i++){//затем рисуем!
byte state=(numbers[ammo_ct]>>i)&0x01;//распаковываем состояние этого сегмента
digitalWrite(hpinNums[i],state);
}
}
Преимущество этого подхода заключается в том, что код такой же компактный, как и система массивов, но использует 1/8 ОЗУ для этого массива. Я не думаю, что вы делаете что-то, что использует много оперативной памяти, но все же рекомендуется минимизировать ее, где это возможно. В этом случае он также значительно расширяется, поскольку вы можете вместить больше чисел, прежде чем у вас закончится ОЗУ.
Вы также можете переключиться на PROGMEM, но читать это в некотором смысле немного странно, и в первую очередь легко забыть прочитать это (что приводит к чтению произвольной ОЗУ). В этом случае он должен быть достаточно мал, чтобы в дальнейшем такая оптимизация не требовалась.
Последнее замечание: если вы когда-либо будете делать что-то, для чего байт слишком мал, вы можете использовать большие числа вплоть до uint32_t, что составляет 32 бита полезных пикселей, или потенциально uint64_t, что составляет 64 бита, но может не поддерживаться на Arduino (я никогда не пробовал последнюю).
- Как решить проблему «avrdude: stk500_recv(): programmer is not responding»?
- Ошибка "collect2.exe: error: ld returned 1 exit status"
- Поддерживают ли чипы ATMega 328/2560 JTAG-программатор и аппаратный отладчик?
- Proteus - Как отладить недопустимый код операции?
- ошибка: expected primary-expression before '(' token
- Как выполнить отладку на чипе с помощью Arduino?
- Использование последовательного плоттера с Visual Studio Code
- Простой ЖК-таймер обратного отсчета
То, как это было отформатировано, полностью испортило копирование/вставку моей программы и мой отчет об ошибках. Если вы хотите помочь мне и вам нужно увидеть что-то, что больше похоже на мою настоящую программу и/или отчет об ошибках, я могу организовать отправку любого документа по электронной почте., @pvGuy
проголосуйте за проверку формата вашего опубликованного кода ... так много людей просто не заботятся о том, читаем ли код .... поставьте три обратных кавычки
`в строке над вашим кодом и три обратных кавычки в строке после ваш код, @jsotolaвы также можете выбрать весь код и нажать кнопку
{}, @jsotolaЯ отформатировал код для вас. +1 за заботу, @chrisl
Всем большое спасибо! С этого момента я буду помнить об исправлениях форматирования и благодарю вас, добрый человек, за то, что вы взяли на себя смелость отформатировать мой код для меня., @pvGuy
Не расстраивайтесь из-за отсутствия фигурной скобки. Это приводит к тому, что большинство компиляторов «сходят с ума», генерируя целую кучу очень запутанных сообщений об ошибках, и их очень трудно отследить. Я программирую на C и C-подобных языках более 30 лет, и эта точная проблема до сих пор время от времени кусает меня., @Duncan C
Хаха спасибо! Да, я полагаю, что все мы время от времени становимся жертвами простой оплошности. С большим опытом, я уверен, что смогу быстрее замечать такие ошибки. Я просто рад, что сообщество такое хорошее! Должна сказать, я не ожидала такой поддержки! Это фантастика, и я надеюсь, что тоже буду чем-то полезен следующему поколению начинающих энтузиастов электроники., @pvGuy
Помогает то, что вы предоставили полное описание вашей проблемы. Многие начинающие постеры публикуют расплывчатые вопросы «Я пробовал <xyy>… но это не работает», а затем требуется утомительная игра из 20 вопросов, чтобы понять, что на самом деле означает «это не работает»., @Duncan C
Хотя я знаю, что проверка кода — это не то, о чем просят, я настоятельно рекомендую вам пересмотреть свой подход. Код копирования/вставки должен быть немедленным красным флажком, указывающим на то, что вам нужно подходить к этому более разумно. Основным предложением, которое вы можете решить как новичок, будет метод, который печатает заданную цифру (и тогда ваша числовая логика становится логикой цифра + цифра). Если вы работаете с раздутым и увеличенным кодом, который у вас есть сейчас, любое изменение или ошибка будут занимать гораздо больше времени, чем следовало бы. Что произойдет, если завтра у вас будет до 99 пуль?, @Flater
Вот несколько советов, которые я даю всем своим ученикам: компиляторы компилируют синтаксически правильные программы, отлавливают и сообщают об основных ошибках, но *они бесполезны в учете ошибок, которые они уже видели.* Одна простая ошибка, например, недостающая фигурная скобка . , часто может вызвать целый каскад сообщений об ошибках, которые кажутся не связанными с исходной ошибкой. Исправьте первую ошибку (или 2, если вы заметили, что 2-я настоящая) и перекомпилируйте. Вы довольно быстро обнаружите одну ошибку с «кучей сообщений об ошибках» и сэкономите много времени, пытаясь проанализировать следующие правильные фрагменты кода., @JRobert
Лучший совет, который я могу дать, — после компиляции кода (а лично я никогда не терплю никаких предупреждений) научиться пользоваться отладчиком. Это ваш лучший друг во всем мире. Установите «точки останова», запустите свой код, и он остановится, когда встретит точки останова, после чего вы сможете проверить стек вызовов, прочитать и даже изменить значение переменных и многое другое. Это, безусловно, лучший способ получить представление о том, что делает ваш код., @Mawg says reinstate Monica