Старый добрый семисегментный индикатор17.03.2023 11:46

В этой статье я хочу продолжить свой цикл о программировании Arduino для начинающих электронщиков. Мы познакомимся с подключением светодиодного семисегментного индикатора к микроконтроллеру через сдвиговый регистр, разберемся с особенностями его программной обработки. Также я продемонстрирую, как с помощью редактора электронных таблиц Excel можно генерировать семисегментные коды. И, как всегда, много внимание будет уделено деталям, которые часто воспринимаются понятными «по умолчанию», но на самом деле для новичка таковыми не являются. В конце, следуя «Arduino way», напишем простой класс для управления семисегментной индикацией.

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

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

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

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

И действительно, имея под рукой 3D-принтер, вы можете получить светодиодный сегментный индикатор практически любой конфигурации. Например, я использую онлайн кастомайзер на thingiverse. Он позволяет достаточно гибко и без лишних заморочек настраивать модель, которую потом останется всего лишь распечатать и немного доработать напильником.

❯ Подключение и управление

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

Сегменты принято обозначать буквами от A до G, как показано на рисунке. Индикаторы могут оснащаться восьмым сегментом — десятичная точка (decimal point), обозначается как DP или H.

Как правило, светодиоды в таких индикаторах объединяют катодами или анодами. Получаются индикаторы с общим катодом (ОК) или общим анодом (ОА).

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

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

Пускай индикатор будет подключен через сдвиговый регистр 74HC595. Как управлять сдвиговым регистром можно почитать в одной из моих прошлых статей. Так как индикатор состоит из светодиодов, необходимо ограничивать их рабочий ток. Самый простым способом является использование токоограничивающих резисторов. В этом кроется основное преимущество светодиодного индикатора перед другими, мы получаем очень просто драйвер, фактически это любая TTL-совместимая микросхема и горстка резисторов. Но тут же кроется и недостаток — большой потребляемый ток. Зато внешняя подсветка для индикатора тоже не нужна.

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

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

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

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

Давайте попробуем составить семисегментный код для отображения цифры 0 на индикаторе. Для этого необходимо включить светодиоды сегментов A, B, C, D, E, F. Сегменты G и H должны быть выключены. Соответственно, на выводах сдвигового регистра Q0 — Q5 необходимо установить уровни логического нуля, а для выводов Q6 и Q7 — необходимо установить единицы.

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

Использовать семисегментные коды в двоичном формате не очень удобно. С помощью стандартного калькулятора Windows можно преобразовать полученную двоичную комбинацию в другие представления чисел. Для более точной интерпретации сегментного кода рекомендую представлять его в шестнадцатеричном формате.

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

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

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

❯ Excel для формирования семисегментных кодов

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

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

Для этого можно объединять соседние ячейки, менять их размеры, установить видимые границы и залить ячейки серым цветом. Все это можно сделать через команду меню: Главная / Формат / Формат ячеек.

Далее немного оживим изображение индикатора. Сделаю так, чтобы сегменты меняли цвет на красный при заполнении. Для этого с зажатой кнопкой »Ctrl» выделю все ячейки, которые представляют собой сегменты индикатора. На вкладке »Главная» необходимо выбрать меню: Условное форматирование / Правила выделения ячеек / Равно…

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

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

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

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

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

Далее, умножу вес бита на его двоичное значение, чтобы получить десятичное значение бита.

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

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

В соседней ячейке получу значение в формате шестнадцатеричного числа для программы на Си.

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

Мой итоговый вариант выглядит вот так. Я перенес вычисления кодов на отдельную страницу. И в результате получаю готовую строку — инициализатор для программы на Си.

❯ Управление сдвиговым регистром 74HC595

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

Микросхема 74HC595 представляет собой последовательный синхронный сдвиговый регистр, который преобразует последовательный код, поступающий на вход SER, в параллельный код на выходах Q0 — Q7.

Синхронизация записи последовательного кода осуществляется подачей стробирующих импульсов на вход SCK. А вход RCK управляет обновлением выходов Q0-Q7. Это позволяет изменять состояние выходных сигналов Q0 — Q7 одновременно.

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

Для экспериментов традиционно буду использовать Proteus. Схема эксперимента представлена на рисунке.

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

//--------------------------------------------------
//Выходы для управления регистром
#define DATA    11
#define CLK     13
#define UPDATE  10

В функции »loop ()» настрою эти выводы для работы на выход.

//--------------------------------------------------
//настройка периферии микроконтроллера
void setup() {
  pinMode(DATA,OUTPUT);
  pinMode(CLK,OUTPUT);
  pinMode(UPDATE,OUTPUT);
}

Для управления сдвиговым регистром перед функцией »loop ()» объявим функцию »shift ()». Во входных параметрах функции будем передавать данные, для записи в регистр.

//--------------------------------------------------
//Запись данных в регистр
void shift(uint8_t data){

}

Для последовательной передачи данных в теле функции организуем цикл »for». Счетчик »bitNum» в цикле будет определять номер бита переменной »data», отправляемый на вход регистра. Передачу данных начнем со старшего бита, чтобы он оказался на выходе Q7.

//--------------------------------------------------
//Запись данных в регистр
void shift(uint8_t data){
  //последовательный сдвиг 8 бит 
  for(uint8_t bitNum = 7; bitNum < 8; --bitNum){
    
  }
}

Счетчик »bitNum» объявлен как целое без знака. Счет ведется в обратную сторону. При очередном вычитании из счетчика единицы, когда его значение было равным нулю, произойдет его переполнение. Новое значение счетчика станет равным 255. Это больше 8. Условие цикла не выполнятся, и цикл будет завершен.

Для записи бита на вход регистра в тело цикла поместим оператор проверки условия »if». Он будет проверять состояние бита по номеру в переменной »bitNum», и устанавливать соответствующее значение на входе регистра.

//--------------------------------------------------
//Запись данных в регистр
void shift(uint8_t data){
  //последовательный сдвиг 8 бит 
  for(uint8_t bitNum = 7; bitNum < 8; --bitNum){
    //проверка бита
    if(data & (1<

//--------------------------------------------------
//Запись данных в регистр
void shift(uint8_t data){
  //последовательный сдвиг 8 бит 
  for(uint8_t bitNum = 7; bitNum < 8; --bitNum){
    //проверка бита
    digitalWrite(DATA,data & (1<

//--------------------------------------------------
//Запись данных в регистр
void shift(uint8_t data){
  //последовательный сдвиг 8 бит 
  for(uint8_t bitNum = 7; bitNum < 8; --bitNum){
    //проверка бита
    digitalWrite(DATA,data & (1<

//--------------------------------------------------
//супер цикл
void loop() {
  shift(0xF8);
}

//--------------------------------------------------
//Выходы для управления регистром
#define DATA    11
#define CLK     13
#define UPDATE  10

//--------------------------------------------------
//Запись данных в регистр
void shift(uint8_t data){
  //последовательный сдвиг 8 бит 
  for(uint8_t bitNum = 7; bitNum < 8; --bitNum){
    //проверка бита
    digitalWrite(DATA,data & (1<

//--------------------------------------------------
//для работы с SPI интерфейсом
#include 

//--------------------------------------------------
//массив семисегментных кодов
uint8_t segmCode[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};

//--------------------------------------------------
//настройка периферии микроконтроллера
void setup() {
  SPI.begin();
  digitalWrite(SS,LOW);
}

//--------------------------------------------------
//супер цикл
void loop() {
  //считаем от нуля до десяти
  for(uint8_t i = 0; i < 10; ++i){  
    //запись в регистр кода по номеру i
    SPI.transfer(segmCode[i]);
    //обновляем выходы сдвигового регистра
    digitalWrite(SS,HIGH);
    digitalWrite(SS,LOW);
    //пауза для отображения цифры
    delay(1000);
  }
}

//--------------------------------------------------
//для работы с SPI интерфейсом
#include 

//--------------------------------------------------
//массив семисегментных кодов
uint8_t segmCode[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};																																															

//--------------------------------------------------
//настройка периферии микроконтроллера
void setup() {
  SPI.begin();
  digitalWrite(SS,LOW);
}

//--------------------------------------------------
//супер цикл
void loop() {
  //считаем от нуля до десяти
  for(uint8_t i = 0; i < 10; ++i){  
    //запись в регистр кода по номеру i
    SPI.transfer(segmCode[i]);
    //обновляем выходы сдвигового регистра
    digitalWrite(SS,HIGH);
    digitalWrite(SS,LOW);
    //пауза для отображения цифры
    delay(1000);
  }
}

  //считаем от нуля до 60 секунд
  for(uint8_t i = 0; i < 60; ++i){ 

//запись в регистр единицы секунд
    SPI.transfer(segmCode[i % 10]);
    //запись в регистр десятка секунд
    SPI.transfer(segmCode[i /10 % 10]);

//--------------------------------------------------
//для работы с SPI интерфейсом
#include 

//--------------------------------------------------
//массив семисегментных кодов
uint8_t segmCode[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};																																															

//--------------------------------------------------
//настройка периферии микроконтроллера
void setup() {
  SPI.begin();
  digitalWrite(SS,LOW);
}

//--------------------------------------------------
//супер цикл
void loop() {
  //считаем от нуля до 60 секунд
  for(uint8_t i = 0; i < 60; ++i){  
    //запись в регистр единицы секунд
    SPI.transfer(segmCode[i % 10]);
    //запись в регистр десятка секунд
    SPI.transfer(segmCode[i /10 % 10]);
    //обновляем выходы сдвигового регистра
    digitalWrite(SS,HIGH);
    digitalWrite(SS,LOW);
    //пауза для отображения цифры
    delay(1000);
  }

  while(1);
}

//--------------------------------------------------
//вывод десятичного числа произвольной разрядности
void decimalTo7segm(uint32_t dec, uint8_t numberOfDigits){
  for(; numberOfDigits; --numberOfDigits){
    //запись очередного семисегментного кода
    SPI.transfer(segmCode[dec%10]);
    //десятичный сдвиг вправо
    dec /= 10;
  }
  //обновляем выходы сдвигового регистра
  digitalWrite(SS,HIGH);
  digitalWrite(SS,LOW);
}

//--------------------------------------------------
//супер цикл
void loop() {
  //вывод десятичного числа
  decimalTo7segm(1234, 4);
  while(1);
}

//--------------------------------------------------
//для работы с SPI интерфейсом
#include 

//--------------------------------------------------
//массив семисегментных кодов
uint8_t segmCode[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};																																															

//--------------------------------------------------
//вывод десятичного числа произвольной разрядности
void decimalTo7segm(uint32_t dec, uint8_t numberOfDigits){
  for(; numberOfDigits; --numberOfDigits){
    //запись очередного семисегментного кода
    SPI.transfer(segmCode[dec%10]);
    //десятичный сдвиг вправо
    dec /= 10;
  }
  //обновляем выходы сдвигового регистра
  digitalWrite(SS,HIGH);
  digitalWrite(SS,LOW);
}

//--------------------------------------------------
//настройка периферии микроконтроллера
void setup() {
  SPI.begin();
  digitalWrite(SS,LOW);
}

//--------------------------------------------------
//супер цикл
void loop() {
  //вывод десятичного числа
  decimalTo7segm(1234, 4);
  while(1);
}

//--------------------------------------------------
//класс для работы с индикаторами
class SevenSegmIndicator{
public:

private:
  //количество индикаторов (минимальное количество 1)
  uint8_t numberOfDigits = 1;
  //семисегментный код
  uint8_t segmCode[10] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90}; 
};

  //основной метод для вывода данных в индикаторы
  void update(uint32_t dec){
    for(uint8_t num = numberOfDigits; num; --num){
      //запись очередного семисегментного кода
      SPI.transfer(segmCode[dec%10]);
      //обновляем выходы сдвигового регистра
      digitalWrite(SS,HIGH);
      digitalWrite(SS,LOW);
      //десятичный сдвиг вправо
      dec /= 10;
    }
  }

  //конструктор
  SevenSegmIndicator(uint8_t n){
    //запуск аппаратного SPI
    SPI.begin();
    digitalWrite(SS,LOW);
    //запоминаем количество индикаторов
    numberOfDigits = n;
  }

//объект для работы с 4-мя индикаторами
SevenSegmIndicator myIndicator = 4;

  //вывод десятичного числа
  myIndicator.update(1234);

//--------------------------------------------------
//для работы с SPI интерфейсом
#include 

//--------------------------------------------------
//класс для работы с индикаторами
class SevenSegmIndicator{
public:
  //конструктор
  SevenSegmIndicator(uint8_t n){
    //запуск аппаратного SPI
    SPI.begin();
    digitalWrite(SS,LOW);
    //запоминаем количество индикаторов
    numberOfDigits = n;
  }

  //основной метод для вывода данных в индикаторы
  void update(uint32_t dec){
    for(uint8_t num = numberOfDigits; num; --num){
      //запись очередного семисегментного кода
      SPI.transfer(segmCode[dec%10]);
      //обновляем выходы сдвигового регистра
      digitalWrite(SS,HIGH);
      digitalWrite(SS,LOW);
      //десятичный сдвиг вправо
      dec /= 10;
    }
  }
private:
  //количество индикаторов (минимальное количество 1)
  uint8_t numberOfDigits = 1;
  //семисегментный код
  uint8_t segmCode[10] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};  
};

//объект для работы с 4-мя индикаторами
SevenSegmIndicator myIndicator = 4;

//--------------------------------------------------
void setup() {
  
}

//--------------------------------------------------
//супер цикл
void loop() {
  //вывод десятичного числа
  myIndicator.update(1234);
  while(1);
}