Домашняя система орошения на arduino с 7-сегментным дисплеем

Arduino Uno: 7-сегментный индикатор

Если вы научились пользоваться «световой шкалой», то следующий шаг в освоении нового компонента «7-сегментный индикатор» дастся вам легко.

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

Важная отличительная черта — у индикатора имеются общие ножки для катода (ножки 3 и 8). Всего их две и они равноценны. Это удобно, вам не нужно будет от каждого катода вести отдельный провод на землю. Достаточно выбрать один из общих катодов и от неё соединиться с GND. Аноды у всех отдельные.

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

На 7-сегментный индикатор распространяются те же правила, что и на стандартные светодиоды — у каждого должен быть свой резистор. Поэтому для опытов приготовьте 8 резисторов.

Схематично можно изобразить следующим образом.

Принципиальная схема

Собираем на макетной плате. Соединяем провода по порядку, начиная с первой ножки, которая идёт на второй порт. На землю идёт восьмая ножка индикатора.

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

int led5 = 5;

Если мы хотим помигать цифрой 1, то нам надо использовать светодиоды 4 и 6, которые идут на порты 4 и 6 платы микроконтроллера.

int led4 = 4;
int led6 = 6;

Если мы захотим вывести цифру 5, то понадобится работать с пятью светодиодами, цифру 8 — уже семь светодиодов. При сложных проектах работать с таким количеством становится затруднительно. Придётся каждый раз смотреть на схему, что вспомнить, какие светодиоды нужно включить для отображения каждой цифры.

Но можно пойти другим путём. А поможет нам единица информации — байт. Байт в своём двоичном представлении состоит из 8 бит. Каждый бит может принимать значения 0 или 1. А наш светодиодный индикатор как раз и состоит из восьми светодиодов. Таким образом мы можем представить цифру на индикаторе в виде набора байт, где единица будет отвечать за включённый диод, а ноль — за выключенный диод.

Число в двоичном виде записывается следующим образом:

0b00000000

Первые два символа 0b дают понять, что речь идёт о двоичном счёте. Все нули означают, что все светодиоды будут выключены.

У нас задействованы порты от 2 по 9. Второй порт записывается в самую правую позицию. Чтобы его включить, поставим единицу.

0b00000001

Можно самостоятельно включать по отдельности каждый диод, перемещая единицу в представленном байте. Поняв принцип, можно, например, заметить, что за точку отвечает четвёртый бит справа. Если мы его не будем использовать, то он всегда будет равен 0. За чёрточку посередине индикатора отвечает самый последний байт (или первый слева).

Комбинируя набор нулей и единиц, можно создать нужные нам цифры. Например, цифра 0 будет представлена как 0b01110111.

Давайте напишем пример вывода цифры 0.

#define FIRST_SEGMENT_PIN 2
#define SEGMENT_COUNT 8 byte number0 = 0b01110111; void setup() { for (int i = 0; i < SEGMENT_COUNT; ++i) pinMode(i + FIRST_SEGMENT_PIN, OUTPUT); } void loop() { int mask = number0; // для каждого из 7 сегментов индикатора определяем: // должен ли он быть включён. // Для этого считываем бит, соответствующий текущему // сегменту «i». Истина — он установлен (1), ложь — нет (0) for (int i = 0; i < SEGMENT_COUNT; ++i) { boolean enableSegment = bitRead(mask, i); // включаем/выключаем сегмент на основе полученного значения digitalWrite(i + FIRST_SEGMENT_PIN, enableSegment); } }

Код немного избыточен, переменная mask здесь лишняя, но она нам пригодится в следующем примере.

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

Затем также в цикле проходим через все светодиоды и узнаём, комбинацию бит с помощью метода bitRead(). Полученная информация помогает нам подсветить нужные светодиоды и получить цифру 0 на выходе.

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

byte number0 = 0b01110111;
byte number1 = 0b00010100;
byte number2 = 0b10110011;
… и так далее

Но мы пойдём другим путём. Все эти значения мы поместим в массив. И будем вытаскивать по индексу. А индексом для примера нам послужит метод millis. С его помощью мы можем получить число секунд, прошедших с запуска скетча, но выводить будем только последнюю цифру прошедших секунд.

#define FIRST_SEGMENT_PIN 2
#define SEGMENT_COUNT 8 // Всего цифр 10, поэтому в массиве 10 чисел.
byte numberSegments[10] = { 0b01110111, 0b00010100, 0b10110011, 0b10110110, 0b11010100, 0b11100110, 0b11100111, 0b00110100, 0b11110111, 0b11110110,
}; void setup()
{ for (int i = 0; i < SEGMENT_COUNT; ++i) pinMode(i + FIRST_SEGMENT_PIN, OUTPUT); } void loop() { // определяем число, которое следует отобразить. // Пусть им будет номер текущей секунды, зацикленный на десятке int number = (millis() / 1000) % 10; // получаем код из массива, в котором содержится полученная цифра int mask = numberSegments[number]; // для каждого из 7 сегментов индикатора for (int i = 0; i < SEGMENT_COUNT; ++i) { // определяем: должен ли он быть включён. boolean enableSegment = bitRead(mask, i); // включаем/выключаем сегмент на основе полученного значения digitalWrite(i + FIRST_SEGMENT_PIN, enableSegment); } }

Запустив пример, мы получим реальный секундомер. За точность не ручаюсь, но для простых задач подойдёт.

На видео некоторые цифры отображаются коряво, видимо из-за особенностей записи. В реальности все цифры работают как положено.

Позже я добавил на плату ещё один светодиод, который загорался при значении 0. При других значениях он был выключен.

// Перед циклом for
if(number == 0) { digitalWrite(ledPin, HIGH);
}else{ digitalWrite(ledPin, LOW); }

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

http://amperka.ru/product/74hc595-shift-out-register
http://amperka.ru/product/cd4026-segment-driver

Реклама

Источник: http://developer.alexanderklimov.ru/arduino/7segment_display.php

Программирование Arduino урок 12 — семисегментный индикатор часть 1

Доброго времени суток! После моего затяжного и вынужденного перерыва, продолжим освоение курса «Программирование Ардуино». В одном из наших предыдущих уроков, мы уже работали с последовательностью светодиодов, теперь пора переходить к следующему этапу обучения. Темой сегодняшней статьи будет – 7-сегментный индикатор.

Знакомство с 7-сегментным индикатором будет состоять из двух частей. В первой части мы поверхностно «пробежимся» по теоретической составляющей, поработаем с «железом» и напишем простенькие программки.

Прошлый раз мы работали с последовательностью из 8 светодиодов, сегодня их также будет 8 (7 – светодиодных полосок и 1 точка). В отличии от предыдущей последовательности, элементы этого набора не выстроенные в ряд (друг за дружкой), а расположены в определённом порядке. Благодаря чему используя лишь один компонент можно вывести 10 цифр (от 0 до 9).

Еще одно существенное отличие, что выделяет данный индикатор на фоне простых светодиодов. У него общий катод (вернее две равноценные ножки 3 и 8, на который заведен катод). Достаточно всего лишь соединить один из катодов с землей (GND). Аноды у всех элементов индикатора индивидуальные.

Небольшое отступление. Все выше сказанное относится к 7-сегментным индикаторам с общим катодом. Однако существуют индикаторы с общим анодом. Подключение таких индикаторов имеет существенные отличия, поэтому прошу не путать «грешное с праведным». Необходимо четко понимать, какой именно тип семисегментника у вас в руках!

Кроме отличий между простыми светодиодами и 7-сегментными индикаторами, есть и общие черты.

Например: индикаторы, как и светодиоды, можно смонтировать в ряд (последовательность) для отображения двух-, трёх-, четырехзначных чисел (разрядов).

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

Надеюсь, вы не забыли об необходимости использования токоограничивающих резисторов при подключении светодиодов. Это же относится и к индикаторам: на каждый элемент индикатора должен быть подключен свой резистор. 8 элементов ( 7 + 1) – 8 резисторов.

У меня под рукой оказался семисегментник с маркировкой 5161AS (общий катод). Распиновка контактов:

Принципиальная схема

Как говорил ранее, для того, чтобы включить сегмент «А» подключим к любому общему контакту (3 или 8) «землю», а на вывод 7 подадим 5В питания. Если индикатор с общим анодом, то на анод подаём 5В, а на вывод сегмента «землю»!

Соберём тестовый стенд. Соединяем провода по порядку, начиная с первой ножки, которая идёт на 2-й вывод платы Ардуино. Землю подключим к 8 выводу индикатора.

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

Для проверки индикатора запустим написанную программу. Выберем элемент «А» и помигаем им.


Теперь помигаем цифрой 2. Для этого включим еще несколько элементов.

Чтобы вывести одну цифру, нужно написать n-число строчек кода. Затруднительно, не находите.

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

Таблица соответствия.

Если у дисплея общий анод, то 1 нужно заменить на 0, а 0 – на 1!

Столбец hex – представление цифры в байтовом виде (более детально поговорим об этом во второй части).

Число в двоичной системе счисления записывается следующим образом: 0b00000000. 0b – двоичная система. Нули означают, что все светодиоды выключены.

При подключении мы задействовали выводы с 2 по 9. Чтобы включить 2 вывод записываем в него единицу = 0b00000001. За точку отвечает четвёртый бит справа. За чёрточку посередине индикатора отвечает самый последний бит.

Давайте напишем пример вывода цифры 0.

Для уменьшения количества набранных строк воспользуемся циклом, который позволяет «перебрать» все 8 бит. Переменной Enable_segment присваивается значение считываемого бита. После этого текущий вывод устанавливается в соответствующий режим (наличия или отсутствия сигнала).

Примечание: функция bitRead() считывает состояние указанного бита и возвращает значение состояния (0 или 1). bitRead(x, n) где, x — число, бит которого необходимо считать; n — номер бита, состояние которого необходимо считать. Нумерация начинается с младшего значащего бита (крайнего правого) с номером 0.

И в завершении первой части напишем небольшой счетчик.

lesson_14_0

На этом всё! Продолжении следует!

Источник: http://mozgochiny.ru/electronics-2/programmirovanie-arduino-urok-12-semisegmentnyiy-indikator-chast-1/

Автоматический полив растений arduino

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

Для создания системы полива нам понадобиться:

  • Обрабатывающее устройство — по старой традиции у нас за него будет arduino uno
  • Датчик влажности почвы — модуль arduino
  • Помпа(Водяной насос) — водяной насос так же можно купить в Китае или сделать самому. По скольку напряжение помпы у меня 12 вольт включать буду с помощью реле.
  • Другие важные мелочи — шланг меленького диаметра, емкость для воды, провода, источник питания.

Сразу что бы не питать иллюзий скажу, подключать к водопроводу все это дело мы не будем. Что бы избежать нештатных ситуаций, для простоты и удобства будем использовать резервуар(емкость с водой). Из резервуара воду будет качать насос(помпа), небольшой мощности будет достаточно, я буду использовать самодельную помпу с питанием 12 вольт.

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

Исходя из этого приспосабливают свободный конец шланга от помпы.

 2. Датчик влажности почвы

Датчик влажности почвы измеряет влажность и выводит аналоговым сигналом от 0 до 1023 либо цифровым(0 или 1). Мы будем использовать аналоговый сигнал для большего контроля меняющейся влажности. Значение 0 это максимум влажности, 1023 максимум сухой.

Мы будем использовать значение 200 — достаточная влажность, значение 600 — критическая сухость. Пороги влажности и сухости при необходимости можно изменить в скетче arduino. Сам датчик состоит из двух частей: щуп(опускается в землю) и компаратор. Записывается датчик от 3.

Читайте также:  Драйвер для ардуино uno: где скачать, процесс установки

3 до 5 вольт, можно использовать встроенный разъем arduino.

Схема компаратора на LM393:

Данные получаются по сигнальному проводу a0 и подключается следующим образом:

3. Практическая реализация

Логика работы: раз в секунду(можно сделать более долгие промежутки) arduino получает значение влажности с датчика.

При получении значения больше 550 и если помпа не работала ближайшие 15 минут arduino включает реле(к которому подключен насос) на время time_work.

Задержка 15 минут между поливами сделана для того что бы влага успела впитаться в почву и помпа перекачала больше воды чем надо.

Переменная time_work устанавливает время работы помпы, это время за которое ваш насос успеет выкачать нужное количество воды вашему растению.
После полива устанавливается задержка 15 минут для работы помпы, при этом arduino продолжает следить за влажностью. А дальше все циклично. Со временем сделаю датчик уровня воды, что бы помпа не включалась если в резервуаре мало воды и выдавалась индикация.

Схема подключения:

Собственно сам код:

int minv = 600;//малая влажность
int maxv = 220;//полный полив
int normv = 500;//чуть влажная
int value = 0;//полученное значение
int last_value = 0;//последнее значимое изменение
int value_sdvig =50;//значимое изменение int ralay = 6; //пин реле
int time_work = 10;//время работы помпы в сек
int analogPin = A0;//пин датчика

//Переменные таймаута
int second = 0; // секунды
int time_off = 0; // счетчик оставшегося времени

int pause_time = 15; // время отдыха после полива в минутах

void setup() { // put your setup code here, to run once: Serial.begin(9600); pinMode(ralay,HIGH);//настройка реле digitalWrite(ralay, HIGH);

}

void poliv() { int time_tmp; time_tmp=time_work; digitalWrite(ralay, LOW); while(time_tmp>0 && value>normv){// ждем истечения времени time_work или нормальной влажности почвы delay(1000); value=analogRead(analogPin);//обновляем значение влажности time_tmp—; } digitalWrite(ralay, HIGH); second=0; // сбрасываем секунды на ноль time_off=pause_time;// устанавливаем задержку между поливами

}

void loop() { // put your main code here, to run repeatedly: value=analogRead(analogPin); if (value>(last_value+value_sdvig)||value(minv-value_sdvig)) && time_off критическая влажность — 50 и не было недавних поливов // временные функции что бы не играться с таймерами if (second>59) { second=0; if (time_off>0) time_off—; } delay(1000);//пауза 1 сек second++; }

На сегодня всё, спасибо всем за внимание! Ждем ваших комментариев.

poliv.7z

Источник: https://radio-blogs.ru/blog/arduino/avtomaticheskiy-poliv-rasteniy-arduino

Взаимодействие Arduino с семисегментным индикатором

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

Если вашему приложению на Arduino необходимо отображать только цифры, подумайте об использовании семисегментного индикатора. Семисегментный индикатор имеет семь светодиодов, расположенных в форме восьмерки. Он прост в использовании и экономичен в плане стоимости. На рисунке ниже показан типовой семисегментный индикатор.

Семисегментный индикатор

Семисегментные индикаторы бывают двух типов: с общим анодом и общим катодом. Внутренняя структура обоих типов почти одинакова. Разница заключается в полярности светодиодов и общем выводе.

В семисегментном индикаторе с общим катодом (такой мы использовали в экспериментах) катоды всех семи светодиодов и светодиода точки подключены к выводам 3 и 8.

Чтобы использовать такой индикатор, нам необходимо подключить корпус к выводам 3 и 8 и подать +5В на другие выводы, чтобы отдельные светодиоды загорелись. Следующей схеме показана внутренняя структура семисегментного индикатора с общим катодом:

Семисегментный индикатор с общим катодом

Индикатор с общим анодом является полной противоположностью.

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

На следующей диаграмме показана внутренняя структура семисегментного индикатора с общим анодом:

Семисегментный индикатор с общим анодом

Сем сегментов обозначены как a-g, а точка как «dp», как показано на рисунке ниже:

Структура семисегментного индикатора

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

Включение сегментов индикатора для отображения цифр

Цифраgfedcbaabcdefgabcdefg
0x3F 0x7E вкл вкл вкл вкл вкл вкл выкл
1 0x06 0x30 выкл вкл вкл выкл выкл выкл выкл
2 0x5B 0x6D вкл вкл выкл вкл вкл выкл вкл
3 0x4F 0x79 вкл вкл вкл вкл выкл выкл вкл
4 0x66 0x33 выкл вкл вкл выкл выкл вкл вкл
5 0x6D 0x5B вкл выкл вкл вкл выкл вкл вкл
6 0x7D 0x5F вкл выкл вкл вкл вкл вкл вкл
7 0x07 0x70 вкл вкл вкл выкл выкл выкл выкл
8 0x7F 0x7F вкл вкл вкл вкл вкл вкл вкл
9 0x6F 0x7B вкл вкл вкл вкл выкл вкл вкл
A 0x77 0x77 вкл вкл вкл выкл вкл вкл вкл
B 0x7C 0x1F выкл выкл вкл вкл вкл вкл вкл
C 0x39 0x4E вкл выкл выкл вкл вкл вкл выкл
D 0x5E 0x3D выкл вкл вкл вкл вкл выкл вкл
E 0x79 0x4F вкл выкл выкл вкл вкл вкл вкл
F 0x71 0x47 вкл выкл выкл выкл вкл вкл вкл

Эксперимент 1

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

Необходимые комплектующие

  • 1 x семисегментный индикатор (общий катод);
  • 1 x Arduino MEGA 2560
  • 1 x макетная плата;
  • перемычки.

Схема соединений

В этой схеме выводы семисегментного индикатора подключены к контактам 2-9 платы Arduino, как показано в таблице ниже. Общие выводы (3 и 8) подключены к GND, а dp остается неподключенным, так как точка не используется в этом эксперименте.

Выводы семисегментного индикатораВыводы ArduinoЦвет провода
1(e) 6 оранжевый
2(d) 5 белый
3,8(COM) GND
c 4 желтый
5(dp)
6(b) 3 красный
7(a) 2 синий
9(f) 7 зеленовато-голубой
10(g) 8 зеленый

Схема подключения семисегментного индикатора к Arduino

Код

void setup() { // определить режимы работы выводов pinMode(2,OUTPUT); pinMode(3,OUTPUT); pinMode(4,OUTPUT); pinMode(5,OUTPUT); pinMode(6,OUTPUT); pinMode(7,OUTPUT); pinMode(8,OUTPUT); } void loop() { // цикл для включения светодиодов сегментов индикатора for(int i=2; i

Источник: https://radioprog.ru/post/223

Arduino и тройной 7-сегментный дисплей на SPI

Мы уже научились управлять одинарным и двойным 7-сегментником (и даже ими одновременно) по SPI. Таким образом, двигаясь step-by-step, мы подобрались к тройному 7-сегментному дисплею.

Здесь нас ожидает принципиально новый способ получения «картинки» на дисплее — нам придется делать своеобразную развертку. Стоит называть это динамической индикацией.

Тройной 7-сегментный дисплей

Если бы тройной 7-сегментник имел по 9 ног для каждой цифры, как одинарный и двойной, у него бы было 27 ног.

Это слишком много, поэтому разработчики решили оставить только 11, соединив катоды одинаковых сегменов трех цифр вместе и оставив болтаться три анода отдельно.

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

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

Собираем схему

Мы будем передавать коды с процессора на ноги светящихся сегментов по SPI, и поэтому центральной частью схемы снова становятся сдвиговые регистры 74HC595, которые мы уже хорошо обскакали. Помним, что нам нужно подключить 11 ног, из них 3 анодные и 8 — катодные.

 Катодные ноги отвечают за то, какая цифра будет показываться, а анодные — где эта цифра будет показываться. Логично использовать один сдвиговый регистр целиком для управления катодными ногами, а три вывода другой микросхемы — для управления анодными.

Принципиальная схема нашего изобразительного устройства будет такова:Если вы внимательно разбирались с предыдущими схемами подключения регистров 74HC595, то у вас не должно возникнуть проблем.

В кратце:

  1. красный провод — +5В;
  2. черный провод — земля;
  3. желтый провод — клок;
  4. оранжевые провода — последовательные данные (проходят через правый регистр «насквозь»);
  5. коричневый провод — защелкивание регистров;
  6. зеленые провода — параллельные данные для анодов 7-сегментника;
  7. синие и серые (рисовал — не подумал) — параллельные данные для катодов 7-сегментника.

На схеме параллельные данные для анодов у меня берутся с ног 2, 3 и 4 (QC, QD и QE), но вы можете использовать любые другие, для этого вам придется изменить код — пересчитать посылаемые байты. А сделал я так, потому что мне было удобнее припаять провода именно к этим ногам:Вообще с лицевой стороны получилось довольно симпатично:Пустой левый сокет является «system reserved» — я впаял его для дальнейшего расширения функционала, а сейчас он останется пустым.

Первый тест

Схемотехника собранного устройства определяет следующий порядок передачи информации по SPI: первым передается байт, отвечающий за то, какая цифра будет показываться (назову его катодным байтом), а вторым передается байт, отвечающий за позицию цифры (назову его анодным байтом).

Катодный байт во время сеанса SPI-передачи проползает сквозь правый (см. схему) регистр и заползает в левый. Анодный байт заползает в правый регистр, да там и остается. В результате показываются циферки, и все радуются.

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

static uint8_t digit[16] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E};

Тут у нас лежат коды цифр от 0 до F. Выкинем ABCDF (они нафиг не нужны) и добавим в конце под десятым номером пустышку (она понадобится нам, когда мы будем отображать двузначные и однозначные числа). Не забываем сменить объявляемый размер массива:

static uint8_t digit[11] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xFF};
В качестве анодного байта просто зафигачим 0xFF — чтобы на всех анодах были единицы, и зажигались одинаковые циферки. Стряпаем код:// подключаем библиотеку SPI
#include
// провод CS подсоединяем к 8-му пину Arduinoenum { reg = 8 };

void setup()

{

// инициализируем SPI

  SPI.begin();
// настраиваем 8-й пин как выход 
  pinMode(reg, OUTPUT);}

// храним в массиве все цифры

static uint8_t digit[11] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xFF};

void loop()

{

  for (int i=0;ithinkingTime){
      //вычисляем элемент последовательности Фибоначчи номер n      
      f=fnn+fn;
      //элементу номер n-2 присваиваем значение элемента n-1
      fnn=fn;
      //элементу номер n-1 присваиваем значение элемента n
      fn=f;
      //запоминаем время 
      timerPrev=timer;
      //увеличиваем время «раздумий»
      thinkingTime+=f;
      //если f дорос до 1000, возвращаем все как было
      if (f>1000){f=0;fn=1;fnn=0;thinkingTime=1000;}
  }
  //выводим число
  output(f);
}Наслаждаемся:

Далее по теме Arduino и SPI

Arduino: управление 7-сегментным дисплеем по SPIArduino + SPI + 7-segment: добавляем фичиArduino и часовой 7-сегментный дисплейArduino: бегающая точка на светодиодной матрицеArduino: используем всю мощь двухцветной матрицы

Источник: http://greenoakst.blogspot.com/2012/01/arduino-7-spi.html

Arduino и 7-ми сегментный дисплей и счетчик обратного времени

Проект основан на 7-ми сегментном двойном дисплее и плате Arduino Diecimila.

Реализован счетчик от 20. Когда счетчик завершает работу, загорается светодиод на 13 пине. В проекте не использовано никакого дополнительного оборудования. Для реализации счетчика на двух дисплеях вам понадобится 9 пинов на плате.

Необходимы детали для проекта

Для проекта вам понадобится следующее:

  • Плата Arduino (какая -не принципиально);
  • Двойной 7-ми сегментный дисплей или два отдельных 7-ми сегментных дисплея;
  • 2 резистора (номинал зависит от вашего дисплея);
  • Макетная плата;
  • Около 50 см провода.

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

Что такое мультиплексинг?

Мультиплексинг — это управление большим количеством светодиодов с помощью нескольких пинов.

Если два или больше 7-сегментных дисплея подключить совместно, примером того, что они отобразят будет: 00, 11, 22, 33, 44, 55, 66, 77, 88, 99.

В данном случае мы контролируем каждую землю (GND) отдельно и получаем мультиплексинг.

Мы будем включать дисплеи каждые 0.5 миллисекунды, что обеспечит управление каждым отдельно.

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

В данном примере мы будем управлять двумя семисегментными дисплеями с помощью 9 пинов. Без мультиплексинга нам пришлось бы использовать в данном случае 14 пинов.

Читайте также:  Амперметр arduino: пример реализации устройства

Подключение 7-ми сегментного двойного дисплея

Проект не самый простой. Для реализации вам понадобятся базовые знания в электронике.

Для начала вам надо правильно распаять коннекторы на задней части дисплея. Можно это реализовать и на макетной плате. Дальше уже можно подключать дисплей к Arduino следующим образом:

Segment A к пину 7

Segment B к пину 8

Segment C к пину 4

Segment D к пину 3

Segment E к пину 2

Segment F к пину 6

Segment G к пину 5

Gnd1 через резистор к пину 11

Gnd2 через резистор к пину 9

Программирование Arduino

Пришло время написания программы.

Снизу ссылки на скачивание двух программ. В одной реализован счетчик от двадцати к 0, во второй пробегает надпись Arduino.

Основные пояснения вынесены в коде. Общая структура следующая:

Сначала происходит инициализация пинов и переменных.

В теле функции Void Setup всем пинам присваивается значение Output — работа в режимы передачи данных на выход.

Также там куча циклов For Loop, которые используются, когда светодиоды включены.

Источник: http://arduino-diy.com/arduino-7-mi-segmentnyy-displey-i-schetchik-obratnogo-vremeni

4-разрядный 7-сегментный индикатор и Arduino

В сегодняшней статье поговорим о 7-сегментных индикаторах и о том, как их «подружить» с Ардуино. Есть несколько вариантов. Самый простой, безусловно, это зайти на arduino-kit.com.ua/seriynyy-displey-opensegment-20-mm-zelenyy.

html и купить готовый индикатор с интегрированным шилдом (это платка согласования так называется), но мы не ищем лёгких путей, поэтому пойдем путем чуть более сложным. Новички – не пугайтесь, эта статья, как и предыдущие мои статьи (arduino-kit.com.ua/arduino-i-labview-ili-vizualizacija-dannyh.html и arduino-kit.com.

ua/chasy-ds1302-dlya-rduino-uno.html) именно для вас. Пусть гуру пишут для таких же умудренных опытом гуру, а я новичок – пишу для новичков.

Почему именно 7-сегментный индикатор? Ведь существует столько всяких экранов, с большим количеством символов, строк, разнообразных диагоналей и разрешений, черно-белых и цветных, самые доступные из которых стоят пару долларов… А тут: «старенький», до безобразия простой, но требующий огромного количества пинов 7-сегментный индикатор, но все-таки преимущество есть и у этого «старичка». Дело в том, что пользуясь приведенными здесь скетчами можно оживить не только индикатор с высотой цифр 14 мм, но и более серьезные (правда уже самодельные) проекты, и метровые цифры в данном случае далеко не предел. Жителям столиц это может быть не так интересно, а вот население Новокацапетовки или Нижней Кедровки очень порадуется, если на клубе или сельсовете появятся часы, которые еще могут и дату отображать, и температуру, а о создателе этих часов будут говорить очень долго. Но, подобные часы тема отдельной статьи: будет желание у посетителейarduino-kit.com.ua/ – напишу. Всё выше написанное можно считать вступлением. Как и прошлая моя статья эта будет состоять из частей, на этот раз из двух. В первой части мы просто «по управляем» индикатором, а во второй – попробуем приспособить его для чего-то хоть немного полезного. Итак, продолжим:

Часть первая. Экспериментально – познавательная

За основу данного проекта взят нам уже хорошо знакомый по предыдущим статьям ARDUINO UNO. Напомню, что приобрести его легче всего можно здесь: arduino-kit.com.ua/uno-r3-new.html или здесь:arduino-kit.com.ua/arduino-leonardo-original-italiya-new-rev3.html , кроме этого понадобится 4-разрядный, 7-сегментный индикатор.

У меня, в частности GNQ-5641BG-11. Почему именно этот? Да просто потому, что лет 5 назад купил его по ошибке, идти менять было лень, вот он и валялся все это время, ожидая своего часа. Думаю, что подойдет любой с общим анодом (и с общим катодом можно, но придется данные массива и остальные значения портов инвертировать – т.е.

менять на обратные), лишь бы не был слишком мощным, чтобы не сжечь Ардуинку. Кроме этого – 4 токоограничивающих резистора, примерно 100 Ом каждый и кусок шлейфа (мне хватило 10 см) на 12 пин (жил) можно «оторвать» от более широкого, что я и сделал. А можно вообще отдельными проводочками подпаяться, проблем не будет.

Еще понадобятся штыри на плату (11 шт.) хотя, если аккуратно можно и без них. Эскиз индикатора можно увидеть на рисунке 1, а его схему на рисунке 2. Также отмечу, что на каждый сегментик этого индикатора лучше подавать не более 2.1В (ограничивается 100-Омными резисторами), и в этом случае он будет потреблять не более 20 мА.

В случае, если загорится цифра «8» потребление не превысит 7х20=140 мА, что вполне допустимо для выходов Ардуино. Любознательный читатель задаст вопрос: «Но ведь 4 разряда по 140 мА это уже 4х140=560 мА, а это уже многовато!» Отвечу – останется 140. Каким образом? Читайте дальше! Расположение пинов на индикаторе видно на рисунке 3.

А подключение делаем согласно таблице 1.

 Рис. 1 — Эскиз индикатора

Рис. 2 — Схема индикатора

Рис. 3 — Расположение пинов

Таблица 1

Пин Ардуино Уно Пин индикатора Примечание
1 5 Сегмент G
2 10 Сегмент F
3 1 Сегмент E
4 2 Сегмент D
5 4 Сегмент C
6 7 Сегмент B
7 11 Сегмент A
8 12 Общий анод сегмента № 1, подключать через резистор 100 Ом.
9 9 Общий анод сегмента № 2, подключать через резистор 100 Ом.
10 8 Общий анод сегмента № 3, подключать через резистор 100 Ом.
11 6 Общий анод сегмента № 6, подключать через резистор 100 Ом.

Заливаем простенький скетч, который представляет собой простенькую «считалочку» от 0 до 9:

sketch-6-1.txt 

А теперь немного пояснений. DDRD это регистр порта D (DDRB – соответственно порта В) за «страшным» словом «регистр» всего лишь «спряталась» функция, которая указывает, будет порт своим пином читать что-то (принимать информацию), либо наоборот туда можно будет что-то писать (отдавать информацию).

В данном случае строчка DDRD=B11111111; указывает, что все пины порта D выходные, т.е. информация из них будет выходить. Буквочка «В» обозначает, что в регистр записано двоичное (бинарное) число. Нетерпеливый читатель тут же спросит: «А десятичное можно!?!». Спешу успокоить – можно, но об этом чуть позже.

Если бы мы хотели половину порта задействовать на вход, а половину на выход можно было бы указать так: DDRD=B11110000; единицы показывают те пины, которые будут отдавать информацию, а нули – те, которые будут эту самую информацию принимать. Основное удобство регистра заключено еще и в том, что не надо прописывать 8 раз все пины, т.е.

мы экономим в программе 7 строк. А теперь разберем следующую строку:

PORTB=B001000; // устанавливаем высокий уровень 11 пина порта В

PORTB это регистр данных порта В, т.е. записав в него какое-либо число мы указываем на каком пине порта будет единица, а на каком – ноль.

В добавление к комментарию скажу, если взять Ардуино Уно таким образом, чтобы видеть контроллер и цифровые пины были сверху — будет понятна запись в регистр, т.е. какой «ноль» (или «единица»)отвечает за какой пин, т.е.

крайний правый ноль порта В отвечает за 8-й пин, а крайний левый – за 13-й (у которого встроенные светодиод). Для порта D соответственно правый за пин 0, левый за пин 7.

Надеюсь после таких развёрнутых пояснений все понятно, а раз понятно предлагаю вернуться к известной нам и горячо любимой с детства десятичной системе счисления. И еще – скетч в 25 строк вроде и небольшой, но для новичка все-таки несколько громоздок. Будем уменьшать.

Заливаем еще более простой скетч, та же самая «считалочка»: 

sketch-6-2.txt 

Работу скетча можно посмотреть на Видео 1.

Всего 11 строчек! Вот это по-нашему, «по-новичковски»! Прошу обратить внимание вместо двоичных чисел в регистры записаны десятичные. Естественно, для десятичных чисел никаких букв впереди не нужно. Думаю, не лишним будет свести все числа в таблицы.Таблица 2. Соответствие отображаемого знака данным порта

Знак Общий анод Общий катод
Двоичная система Десятичная система Двоичная система Десятичная система
«0» 00000011 3 11111100 252
«1» 10011111 159 01100000 96
«2» 00100101 37 11011010 218
«3» 00001101 13 11110010 242
«4» 10011001 153 01100110 102
«5» 01001001 73 10110110 182
«6» 01000001 65 10111110 190
«7» 00011111 31 11100000 224
«8» 00000001 1 11111110 254
«9» 00001001 9 11110110 246

Таблица 3. Соответствие отображаемого разряда данным порта

Разряд Общий анод Общий катод
Двоичная система Десятичная система Двоичная система Десятичная система
1 001000 8 110111 55
10 000100 4 111011 59
100 000010 2 111101 61
1000 000001 1 111110 62

Внимание! Данные таблиц 2 и 3 справедливы только при распайке согласно таблице 1.

А теперь зальем скетч со «считалочкой» от 0 до 9999: 
sketch-6-3.txt  Рис. 4 — Считалочка

Работу скетча можно посмотреть на Видео 2

В этом скетче комментариев больше, чем самого кода. Вопросов возникнуть не должно…. Кроме одного, что это за «цикл мерцания» такой, что, собственно говоря, там мерцает и для чего? А еще переменная для этого какая-то…

А все дело в том, что одноименные сегменты всех четырех разрядов у нас соединены в одной точке. А1, А2, А3 и А4 имеют общий катод; А1, В1,…..G1 общий анод. Так, что подав одновременно на 4 разрядный индикатор «1234» мы получим «8888» и очень удивимся по этому поводу. Чтобы этого не произошло нужно сначала зажечь «1» в своем разряде, потом отключить её, зажечь «2» в своем и т.д. Если делать это очень быстро, то мерцание цифр сольётся, как кадры на киноплёнке и глаз его практически не будет замечать. А максимальное значение переменной мерцания в данном случае управляет скоростью смены цифр на индикаторе. Кстати, именно благодаря этому «мерцанию» и максимальное потребление тока всего 140 мА, вместо 560. А теперь предлагаю перейти к чему-то более полезному.

Часть вторая. Хоть немного полезная

В этой части мы выведем символы с персонального компьютера на 7-сегментный индикатор при помощи ARDUINO MEGA.

Почему вдруг возникла идея «поменять лошадей на переправе»? Причин две: первая – до этого в своих статьях я ни разу не рассматривал ARDUINO MEGA; и вторая – в ARDUINO UNO я так и не разобрался, как мне динамически менять местами СОМ порт и порт D. Но я новичок – мне простительно.

Приобрести данный контроллер, естественно можно здесь: arduino-kit.com.ua/arduino-mega-2560-adk-new.html . Для реализации задуманного пришлось взять паяльник и перепаять шлейф со стороны Ардуино, а также написать новый скетч. Как перепаян шлейф можно посмотреть на Рисунке 5.

Все дело в том, что ARDUINO MEGA и ARDUINO UNO имеют разную распиновку портов, да и в Меге портов гораздо больше. Соответствие использованных пинов видно из Таблицы 4.

 Рис. 5 — Новая распайка шлейфа

Таблица 4

Пин Уно Порт Уно Пин Мега Порт Мега
1 D 23 A
2 D 24 A
3 D 25 A
4 D 26 A
5 D 27 A
6 D 28 A
7 D 29 A
8 B 37 C
9 B 36 C
10 B 35 C
11 B 34 C

Внимание! Данная таблица справедлива только для данного проекта!

Также следует обратить внимание, что порт С у Ардуино Мега «начинается» с 37 пина и далее по убывающей, а порт А – с 22 пина и далее по возрастающей.

 Рис. 6 — Общий вид

Небольшие особенности реализации: выводить будем 4 символа. Символы должны быть цифрами. Если ввели «1234» и увидим «1234», если ввели «123456» все равно увидим «1234», если ввели «йцук», «фыва1234», «отиог485909оапоьм» — не увидим ничего. Если ввели «рр2345мм» увидим « 23» т.е. небольшая, встроенная «защита от дурака».

Собственно скетч:

sketch-6-4.txt 

А как работает данная программа можно посмотреть на Видео 3

 

Обзор подготовил Павел Сергеев

Источник: https://arduino-kit.com.ua/4-razryadnyy-7-segmentnyy-indikator-i-arduino.html

Самодельный 7-сегментный индикатор. Подключение к arduino

Все началось с того, что мне понадобился большой 7-сегментный индикатор, для вывода цифр… Была идея, оборудовать гараж ультразвуковыми дальномерами, сделать аналог парктроника, только расстояние до препятствия(в данном случае автомобиль) должно было выводиться на стене.

До дальней стены, на которую должно было крепиться информационное табло, примерно, метров 5, поэтому выводить циферки планировалось на больших светодиодных индикаторах.

Сам проект «гаражного парктроника» пришлось закрыть из-за недостатка финансирования и судебных разбирательств со стороны крупных мафиозных кланов, которые в тайне, от всего мира, владеют империей по продажам парктроников. Шутка.

Проекту не суждено сбыться, поскольку гараж оказался меньше, чем я рассчитывал и пригоден только для хранения велосипедов и другого мусора, который обычно и хранят в гаражах. Машина просто-напросто не влезла по длине. Но нет повода для печали, ведь уже есть некоторые наработки – они пригодятся в будущих девайсах. Про одну такую наработку, я и хочу сегодня рассказать. Это самодельный 7-сегментный индикатор, который в несколько раз больше, покупных аналогов.

Читайте также:  Ардуино симулятор: подборка лучших программ

7-сегментный индикатор своими руками

Идея 7-сегментного индикатора очень простая – для каждого сегмента можно приспособить несколько светодиодов, в данном случае я использовал по три штуки на сегмент. Если индикатор нужен крупнее, то можно взять большее количество светодиодов.

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

Ниже приведена схема, по которой я собрал экспериментальный индикатор. А так же, если кто-нибудь захочет повторить, прикладываю исходник схемы – скачать. Открыть схему можно в программе Sprint Layout.

Чтобы индикатор получился более эстетически красивым, я вытравил плату и припаял светодиоды с резисторами на получившуюся заготовку. А так же напечатал корпус на 3D-принтере. Правда, с печатью немного «накосячил», поторопившись, и корпус получился не самого лучшего качества – сильно видны слои.

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

Подключение 7-сегментного индикатора к arduino

Как уже писал выше, индикатор можно подключать как напрямую к ардуино, так и с помощью сдвигового регистра. Я решил использовать сдвиговый регистр 74HC595, он позволит сэкономить пины arduino. Вместо семи, будет задействовано только три. Ниже приведена схема подключения индикатора, сдвигового регистра и ардуино.

Скетч для управления 7-сегментным индикатором

Остается только написать прошивку, для управления индикатором. Тут все предельно просто – создаем байтовый массив, для всех необходимых цифр, где каждый бит задает положение сегмента: включен или выключен. И для примера, запустим цикл, в котором каждую секунду по очереди будет отображаться нужная цифра от 0 до 9.

//Пин подключен к SH_CP входу 74HC595 int clockPin = 13; //Пин подключен к ST_CP входу 74HC595 int latchPin = 12; //Пин подключен к DS входу 74HC595 int dataPin = 11; // массив цифр byte numbers_array[10] = { B00111111, B00110000, B01101101, B01111001, // 0 1 2 3 B01110010, B01011011, B01011111, B00110001, // 4 5 6 7 B01111111, B01111011 // 8 9 }; // функция для включения нужной цифры void showNumber(int number){ // зажигаем нужные сегменты digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, MSBFIRST, numbers_array[number]); digitalWrite(latchPin, HIGH); } void setup() { //устанавливаем режим OUTPUT pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } void loop() { // по очереди зажигаем цифры от 0 до 9 for(int i=0; i

Источник: https://vk-book.ru/samodelnyj-7-segmentnyj-indikator-podklyuchenie-k-arduino/

Модуль многоразрядного 7-ми сегментного индикатора на базе микросхемы MAX72xx, подключение к Arduino и работа с библиотечными функциями

На этот раз, в статье будет рассмотрен один из интереснейших модулей, а именно — многоразрядный семисегментный индикатор на базе микросхемы MAX7219. Почему многоразрядный? Ответ прост — количество разрядов это и есть количество цифр, которое может отобразить модуль.

Например, на фото ниже, показаны три вида многоразрядных индикаторов, слева направо — 4-х разрядный, 6-ти разрядный, 8-ми разрядный. Причем первый является 4-х разрядным индикатором часового типа.

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

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

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

Кстати, как уже было сказано — LED матрицы 8х8 тоже работают на базе драйвера MAX7219, и кому интересно то добро пожаловать в статьи:

Итак, начнем… Думаю что про многоразрядность было дано хорошее описание, а вот почему семисегментный? Ответ тоже не так уж и сложен — потому что для формирования символа или отображения цифры используется семь светодиодов, проиндексированных буквами A, B, C, D, E, F, G, таблица ниже показывает как это обозначено:

Как видно из таблицы, есть также и восьмой светодиод — DP. Полностью закодировать символ или цифру можно в 1 байте, устанавливая или сбрасывая определенный бит, как это показано с примером кодирования символа J. В примере установлены биты B, C, D, E, что позволяет отобразить заданный символ на семисегментном индикаторе.

От теории к практике — подключим 8-ми разрядный модуль к плате Arduino Uno по указанной ниже схеме:

Для отображения символов используется несколько функций из подключаемой библиотеки LedControl.h. Разберем каждую из этих функций по порядку, начнем с функции setDigit(). 

Прототип объявления функции для отображения числа и передаваемые функции аргументы:

setDigit(int addr, int digit, byte value, boolean dp);

Где — 

        int addr — адрес модуля на шине SPI для которого вызывается функция, если модуль один — то этот параметр равен 0 (по умолчанию адресация устройств на шине SPI начинается с нуля)

        int digit — порядковый номер разряда в модуле индикации, по умолчанию для многоразрядных индикаторов нумерация разрядов начинается с крайнего правого разряда, соответственно номер крайнего правого разряда равен 0, а номер крайнего левого разряда в нашем случае равен 7

        byte value — значение(число от 0 до 9) которое нужно отобразить в разряде номер которого указан в параметре int digit

        boolean dp — этот параметр отвечает за отображение точки у разряда номер которого указан в параметре int digit. Если параметр равен true  то  точка отобразится, если false то точка не отобразится.

Прототип объявления функции для отображения символа и передаваемые функции аргументы:

setChar(int addr, int digit, char value, boolean dp);

        int addr —  адрес модуля на шине SPI  для которого вызывается функция, если модуль один — то этот параметр равен 0  (по умолчанию адресация устройств на шине SPI   начинается с нуля)

        int digit —  порядковый номер разряда в модуле индикации, по умолчанию для многоразрядных индикаторов нумерация разрядов начинается с крайнего правого разряда, соответственно номер крайнего правого разряда равен  0,  а номер крайнего левого разряда в нашем случае равен  7

        char value — символ, который должен отобразиться в разряде номер которого задан параметром int digit

        boolean dp —  этот параметр отвечает за отображение точки у разряда номер которого указан в параметре  int digit.  Если параметр равен  true   то  точка отобразится, если  false  то точка не отобразится.

Отдельным моментом стоит упомянуть, что функция setChar() может отобразить только ограниченный набор символов, таких как:

  • 0 1 2 3 4 5 6 7 8 9 цифра отображается как символ
  • A a символ отобразится в верхнем регистре  
  • B b символ отобразится в нижнем регистре
  • С с символ отобразится в нижнем регистре
  • D d символ отобразится в нижнем регистре
  • E e символ отобразится в верхнем регистре
  • F f символ отобразится в верхнем регистре
  • H h символ отобразится в нижнем регистре
  • L l символ отобразится в верхнем регистре
  • P p символ отобразится в верхнем регистре
  • — знак «минус»
  • . , отображение точки
  • символ подчеркивания
  • установить символ пробела

В тестовом скетче можно поставить задачу такого плана:

  1.  Отобразить поочередно цифры от 1 до 8 без точки
  2.  Заполнить цифрами от 1 до 8 все разряды модуля индикации, плюс отобразить все точки указаных разрядов
  3.  Отрисовать поразрядно массив с заранее закодированными в двоичном коде символами, в результате должно получиться «Arduino rules!!!» 

Из-за ограниченного набора символов функция setChar() не подходит для тестового скетча, так как она не сможет нормально отрисовать фразу указанную в пункте 3. Вместо этой функции мы будем использовать функцию setRow(). Итак…  функция setRow() уже была нами испытана в в статьях про изучение Led матриц 8х8, давайте вновь опишем прототип вызова и параметры данной функции.

Прототип объявления функции setRow() и передаваемые функции аргументы:

setRow(int addr, int row, byte value);

Где — 

        int addr —  адрес модуля на шине SPI  для которого вызывается функция, если модуль один — то этот параметр равен 0  (по умолчанию адресация устройств на шине SPI   начинается с нуля)

        int row — порядковый номер разряда в модуле индикации, по умолчанию для многоразрядных индикаторов нумерация разрядов начинается с крайнего правого разряда, соответственно номер крайнего правого разряда равен  0,  а номер крайнего левого разряда в нашем случае равен  7

        byte value — значение в двоичном формате(пример B00000000, также возможна альтернатива в десятичном и шестнадцатиричном), которым закодирован необходимый символ. Таблица кодирования символов поможет правильно закодировать нужный символ.          

Ну и в завершение статьи тестовый скетч и видео, как это работает:

#include «LedControl.h» /*  * Подключаем библиотеку LedControl.h  * и создаём объект класса LedControl  * при этом, 7-ми сегметный дисплей с драйвером MAX72xx  * должен быть подключен к плате Arduino следующим образом:  * Arduino[Pin 5V] -> Display Module MAX72xx[VCC]  * Arduino[PinGND] -> Display Module MAX72xx[GND]  * Arduino[Pin 12] -> Display Module MAX72xx[DIN]  * Arduino[Pin 11] -> Display Module MAX72xx[CLK]  * Arduino[Pin 10] -> Display Module MAX72xx[LOAD/CS]  *  */ LedControl lc = LedControl(12, 11, 10, 1); //Массив с закодированными символами, //Фраза «Arduino ruLES!!!» byte ar[15] =               {                 B01110111,    //A                 B00000101,    //r                 B00111101,    //d                 B00011100,    //u                 B00010000,    //i                 B00010101,    //n                 B00011101,    //o                 B00000101,    //r                 B00011100,    //u                 B00001100,    //l                 B01001111,    //E                 B01011011,    //S                 B10110000,    //!                 B10110000,    //!                 B10110000     //!               }; void setup() {   //Устройство(7-ми сегментный дисплей) выводим из спящего режима   lc.shutdown(0, false);   //Установить яркость дисплея на 8   //Всего возможных режимов яркости от 0 до 15   lc.setIntensity(0,8);   //Очистить дисплей   lc.clearDisplay(0); } void loop() {   //Простейший перебор чисел от 1 до 8 по разрядам   for(int i = 0, j = 7; i < 8, j >= 0; i++, j—)   {     lc.setDigit(0, j, byte(i + 1), false);     delay(400);     lc.clearDisplay(0);   }   //Перебор чисел без очистки экрана   for(int i = 0, j = 7; i < 8, j >= 0; i++, j—)   {     lc.setDigit(0, j, byte(i + 1), true);     delay(400);   }   lc.clearDisplay(0);   //Отрисовка фразы «Arduino ruLES!!!»   int n = 0;   for(int i = 0; i < 2; i ++)   {     for(int j = 7; j >= 0; j —)     {       if(n > 6 && !(i % 2))       {         continue;       }       else       {         lc.setRow(0, j, ar[n]);         delay(400);         n ++;       }         }     lc.clearDisplay(0);   }   delay(400);   lc.clearDisplay(0); }

Источник: http://arduino.on.kg/modul-mnogorazryadnogo-7-mi-segmentnogo-indikatora-na-baze-mikroshemy-MAX72xx-rassmatrivaem-podklyuchenie-k-Arduino

Ссылка на основную публикацию