Управление 595 сдвиговыми регистрами при помощи avr по spi

Учебный курс AVR. Работа с SPI модулем. Управление сдвиговыми регистрами. Ч3

Управление 595 сдвиговыми регистрами при помощи avr по spi

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

   Расширители портов позволяют добавить микроконтроллеру “полноценные”  выводы, работающие как на выход, так и на вход, и, как правило, управляются с помощью стандартных интерфейсов — SPI  или I2C. Это очень удобно, но подобные микросхемы не из дешевых. 

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

   В этой статье мы рассмотрим расширение портов микроконтроллера с помощью сдвигового регистра 74HC595.  Им можно управлять как стандартными выводами  микроконтроллера, так и с помощью SPI модуля. Также его можно каскадировать, соединяя несколько микросхем в один большой регистр. 

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

   Микросхема 74HC595 представляет собой 8-ми разрядный сдвиговый регистр  с регистром хранения и выходными буферами с тремя состояниями.

   Назначение ее выводов следующее:

DS – вход данных сдвигового регистра

SHCP – тактовый вход сдвигового регистра

MR – вход сброса сдвигового регистра

STCP – тактовый вход регистра хранения

OE – вход разрешения выходных буферов

Q0…Q7 – выходы буферов

Q7S — выход каскадирования

GND, VCC – выводы питания

   Рассмотрим логику работы сдвигового регистра 74HC595.

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

   На входе DS устанавливается требуемый логический уровень.

По положительному перепаду тактового сигнала на входе SHCP содержимое сдвигового регистра (разряды с 0 по 7-ой) смещается на один разряд (в направлении старших разрядов), а нулевой разряд регистра сохраняет логический уровень, установленный на входе DS.

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

   По положительному перепаду тактового сигнала на входе STCP данные с выхода сдвигового регистра записываются в регистр хранения. Если  на выводе OE будет низкий логический уровень, то данные регистра хранения установятся на выходах Q0 … Q7, в противном случае эти выходы будут находиться в третьем состоянии (Hi-Z).

   Для каскадирования сдвигового регистра выход Q7S подключают к входу данных DS следующего регистра, а выводы SHCP, MR, STCP, OE одного регистра соединяют с аналогичными выводами другого. Пример каскадного включения двух сдвиговых регистров можно видеть на схеме ниже. 

   Управление сдвиговым регистром 74HC595 можно реализовать как программно, так и аппаратно, используя SPI модуль микроконтроллера AVR.

Последнее возможно благодаря тому, что временная диаграмма сигналов управления 74HC595 совпадает с  диаграммой формируемой модулем SPI в нулевом режиме (SPI mode 0).

Что собственно неудивительно, поскольку SPI модуль содержит сдвиговый регистр в своем составе. 

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

DS — > MOSI

SHCP — > SCK

STCP — > SS

MR — > через резистор к VCC

OE — > GND  

   Стандартная схема управления 4-ех символьным семисегментным индикатором требует для своей работы 12-ти выводов, поэтому в схеме используются два сдвиговых регистра 74HC595, включенных каскадно. 

   Предельный ток одного выходного вывода сдвигового регистра составляет ~35 мА в обе стороны (втекающий/вытекающий). Этого может быть недостаточно для обеспечения яркого свечения индикатора, поэтому его общие выводы (5, 8, 9, 12) подключены к сдвиговому регистру не напрямую, а через транзисторы. 

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

   Управление регистрами осуществляется по трем линиям, подключенным к SPI модулю микроконтроллера AVR:

    MOSI – последовательный ввод данных

    SCK —  тактовый сигнал для сдвига данных 

    SS – сигнал для защелкивания данных в регистре хранения.

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

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

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

   Теперь драйвер позволяет управлять индикатором, как в стандартной схеме включения, так и в схеме с использованием сдвиговых регистров. Для управления семисегментным индикатором по SPI нужно в файле indicator.

h раскомментировать  строчку #define IND_SHIFT_REG. При этом, к проекту (помимо модуля indicator.c) должен быть подключен модуль реализующий функцию вывода данных по SPI — void SPI_WriteArray(uint8_t num, uint8_t *data). У меня это модуль spi.

c, у вас может быть какой то другой. 

   Несколько слов о проекте. Он состоит из трех модулей:

main.c   — главный программный модуль,

spi.c      — драйвер spi, рассмотренный в предыдущей статье,

indicator.c  — доработанный драйвер семисегментного индикатора.

   В начале main`а происходит инициализация spi модуля и переменных драйвера индикатора. Затем в бесконечном цикле while инкрементируется счетчик и на индикатор выводится его значение. Чтобы не загромождать код, я не стал использовать для этих целей прерывание таймера, а просто добавил в цикл программную задержку. 

      Для вывода данных в сдвиговый регистр используется функция модуля spi.c:

void SPI_WriteArray(uint8_t num, uint8_t *data);

num – количество передаваемых байтов (обычно размерность массива),

*data – указатель на массив с передаваемыми данными.

  Вызовы этой функции прописаны в модуле indicator.c.

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

 так как я не смог заставить его нормально работать с семисегментным индикатором. Зато есть проект для Atmel Studio 6. Все проекты рабочие и тестировались на макете, что впрочем не исключает возможность ошибок. 

Остальные части

Источник: http://chipenable.ru/index.php/programming-avr/item/139

Когда не хватает ног. Часть 2. Сдвиговый регистр 74HC595

 

 В прошлый раз был рассмотрен вариант увеличения выходов микроконтроллера при помощи микросхемы – дешифратора , сегодня рассмотрим более продвинутый вариант на сдвиговом регистре 74HC595.

Использовав всего одну микросхему можно заиметь в свое распоряжение дополнительно 8 выходов, использовав всего 3 ноги микроконтроллера. А благодаря возможности расширения, добавив вторую микросхему, количество выходов можно увеличить до 16.

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

 Итак, рассмотрим более подробно назначение выводов микросхемы и научимся управлять сдвиговым регистром 74hc595 в Bascom-AVR.

 Для начала ознакомимся с выводами микросхемы, а точнее с их функциональностью. Ниже представлена вырезка из даташита на 74hc595 с обозначением выводов микросхемы:

  • Q0…Q7 – выходы которыми будем управлять. Могут находится в трёх состояниях: логическая единица, логический ноль и высокоомное Hi-Z состояние
  • GND – земля
  • Q7′ – выход предназначенный для последовательного соединения регистров.
  • MR – сброс регистра.
  • SH_CP – вход для тактовых импульсов
  • ST_CP – вход «защёлкивающий» данные
  • OE – вход переводящий выходы из HI-Z в рабочее состояние 
  • DS – вход данных
  • VCC – питание 5 вольт

 Логика работы с регистром

 Когда на тактовом входе SH_CP появляется логическая единица, бит находящийся на входе данных DS считывается и записывается в сдвиговый регистр. Этот бит записывается в самый младший разряд.

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

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

Что бы данные появились на выходах Q0…Q7 нужно их «защёлкнуть». Для этого необходимо подать логическую единицу на вход ST_CP

 — MR осуществляет сброс регистра, устанавливая все выходы Q0…Q7 в состояние логического нуля.

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

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

 — OE (output enable) если подать сюда логическую 1, то выходы будут находится в высокоомном HI-Z состоянии. Когда подаем на этот вход логический 0, выходы будут находится в рабочем состоянии.

 — Q7′  предназначен для последовательного соединения сдвиговых регистров.

 Но лучше один раз увидеть, чем два раза прочитать =) поэтому смотрим на анимацию:

 Работа с регистром в лоб

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

$regfile = «attiny2313.

dat»
$crystal = 1000000

Config Portb = Output

Sh_cp Alias Portb.3                'нога для тактовых импульсов
Ds Alias Portb.2                   'нога для вывода данных
St_cp Alias Portb.

0               'нога для «защелкивания» данных в регистр хранения
'вывод через регистр числа 146 (в бинарном представлении 10010010)

St_cp = 0                          'выставляем ногу в режим записи данных

Ds = 1                             'выставляем первый бит
Sh_cp = 0                          'даем импульс на тактовый выход
Sh_cp = 1

Ds = 0                             'выставляем второй бит
Sh_cp = 0
Sh_cp = 1

Ds = 0                             'выставляем третий бит
Sh_cp = 0
Sh_cp = 1

Ds = 1                             'выставляем четвертый бит
Sh_cp = 0
Sh_cp = 1

Ds = 0                             'выставляем пятый бит
Sh_cp = 0
Sh_cp = 1

Ds = 0                             'выставляем шестой бит
Sh_cp = 0
Sh_cp = 1

Ds = 1                             'выставляем седьмой бит
Sh_cp = 0
Sh_cp = 1

Ds = 0                             'выставляем восьмой бит
Sh_cp = 0
Sh_cp = 1

St_cp = 1                          'защелкиваем введенные данные

End

компилируем, зашиваем в микроконтроллер или смотрим в симулятор и видим на выходе нашу комбинацию.

Работает, на выходе регистра появилось отправленное число!

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

Управление регистром 74HC595 в Bascom через команду ShiftOut

 В Bascom-AVR для работы со всевозможными последовательными интерфейсами есть замечательная команда SHIFTOUT
 Эта команда сама разложит число на битовые составляющие и последовательно выведет их на любой пин микроконтроллера, заодно она может выдавать тактовые импульсы. Для работы со сдвиговыми регистрами самое то! Синтаксис команды:

Datapin , Clockpin , var , option

Datapin – порт микроконтроллера для вывода данных

Clockpin – порт микроконтроллера для вывода тактовых импульсов

Var – данные которые хотим отправить в регистр

Option – число от 0 до 3, этим параметром выбирается в каком порядке будут вводиться данные в регистр и активный уровень на линии Clock при котором происходит запись бита:
option=0 – старший бит идет первым, Clock активный уровень низкий
option=1 – старший бит идет первым, Clock активный уровень высокий
option=2 – младший бит идет первым, Clock активный уровень низкий
option=3 – младший бит идет первым, Clock   активный уровень высокий

https://www.youtube.com/watch?v=V3FGfl60QHU

В нашем случае для работы с регистром 74HC595 параметр option нужно ставить 1 или 3.

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

здесь выводится импульс на PortB.0 длительностью 5 микросекунд (при частоте работы мк 4 МГц)

 Теперь давайте выведем число 10010001 (145 в десятичной системе) на выход регистра, подключенному к микроконтроллеру по вышеприведенной схеме:

$regfile = «attiny2313.

dat»
$crystal = 1000000

Dim A As Byte
Config Portb = Output

A = 145

Gosub Hc595                                 'уходим на подпрограмму отправки данных

End

Hc595:                                      'подпрограмма отправки данных

Shiftout Portb.2 , Portb.3 , A , 1          'отправляем данные в регистр
Pulseout Portb , 0 , 5                      'защелкиваем данные
Return

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

Как видно управление сдвиговым регистром 74HC595 в Bascom состоит всего из двух строк кода, и не представляет никаких сложностей.

Увеличение разрядности

 Как говорилось ранее, регистры могут легко состыковаться друг с другом, тем самым давая возможность увеличить количество портов вывода практически до бесконечности.
 Для того чтобы добавить дополнительный регистр, необходимо соединить вместе выводы для тактовых импульсов SH_CP и выводы для защелкивания данных ST_CP. Вход данных первого регистра подключается к микроконтроллеру и туда мы будем гнать данные, а вход второго регистра соединяется к выводу Q7’ первого регистра.
 В программе управления необходимо изменить тип переменной, которую будем выводить через регистры. Так как соединив вместе два регистра мы получили в управление 16 ножек, то переменная должна хранить 16 бит данных (или 2 байта). Такой объем данных хранит переменная типа Word. Этот тип мы и будем использовать, и для примера выведем число 1111001001001100 (в десятичном виде это будет число 62028). 

$regfile = «attiny2313.

dat»
$crystal
 = 1000000

Dim A As Word                                     'выбираем 2х байтный тип переменной

A = 62028                                         'выведем вот это числоShiftout Portb.2 , Portb.3 , A , 1                'отправляем данные в регистрPulseout Portb , 0 , 5                            'защелкиваем данные

 Старший байт (левая часть 11110010) выводится через второй регистр (IC2), а младший байт (01001100) выводится через первый регистр, соединенный к микроконтроллеру напрямую (IC1).

 Думаю проблем с подключением 3, 4, 5 регистров в ряд возникнуть не должно 😉

Удачи!

Источник: http://AVRproject.ru/publ/kak_podkljuchit/bascom_avr_74hc595/2-1-0-44

ATmega8 + Proteus: работа со сдвиговыми регистром 74HC595

разделы: AVR , SPI , Proteus , HD44780 , дата: 26 сентября 2017г

Изучение модуля USI MSP430 странным образом(на самом деле закономерным) вывела меня на такую штуку, как сдвиговый регистр. Имея о них лишь общее представление, мне пришлось срочно разбираться c этой, довольно обширной темой. Итак.

Сдвиговый регистр, он же расширитель портов, он же шинный преобразователь, преобразует сигнал последовательной шины в параллельный или/и обратно.

В рамках этой статью я рассмотрю работу с популярным 8-и битовыми сдвиговым регистром на SPI интерфейсе 74HC595.

В качестве практических примеров, я рассмотрю подключение светодиодной гирлянды, семисегментных индикаторов и дисплея с параллельной шиной HD44780.

В качестве микроконтроллера я буду использовать ATmega8, а в качестве среды моделирования Proteus 8.5.

Кроме этого, я затрону организацию SPI интерфейса у ATmega8.

1) Сдвиговый регистр 74HC595 c SPI интерфейсом

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

    Описание

  • Микросхема принимает на вход последовательность 8-битных данных, которые затем преобразует в логические состояния на 8-пиновом выходе.
  • Микросхема работает только на выход, т.е. мы можем с ее помощью управлять светодиодами или дисплеем HD44780, но не сможем с нее получать данные с датчиков например.
  • Выходы могут принимать состояния: логический ноль, логическую единицу, высокоимпедансное состояние — HiZ.
  • Микросхемы можно соединять каскадом для получения 16-битного выхода, 24-битного, и т.д.
  • Питание микросхемы 74HC595N может варьироваться от двух до шести Вольт.
  • Сдвиговый регистр 74HC595N может работать на частотах до 100MHz.

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

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

Здесь, Q0 — Q7 — это цифровые выходы. MR — это reset. OE — переводит выводы в HiZ режим. Q'7 — это бит переполнения, используется для соединения регистров каскадом. DS — линия передачи данных, SH — линия тактирования, ST — защелка(latch), но мне привычнее такие штуки называть Enter'ом.

В рабочем состоянии, OE должен быть соединен с землей, а MR подтянут к питанию. Ведущий микроконтроллер может менять состояние DS при низком уровне линии тактирования — SH. Чип считывает состояние линии DS при растущем фронте на линии тактирования SH.

Прием данных сдвиговым регистром происходит при низком уровне защелки — ST. При этом принимаемые данные идут во внутренний (теневой) регистр(на самом деле там одна цепочка триггеров). При выставлении защелки ST в высокий уровень, содержимое теневого регистра записывается в регистр вывода, и выходы Q0 — Q7 принимают состояние в соответствии с его содержимым.

Данные посылаются старшим вперед.

Временная диаграмма сигналов:

2) Управление гирляндой светодиодов

Для знакомства с работой сдвигового регистра 74HC595 , в Proteus соберем такую схему:

    Всего в передаче данных задействовано три пина.

  • на PD2 — линия тактирования, SH;
  • на PD3 — линия передачи данных, DS;
  • на PD4 — линия синхронизации данных, ST.

Этими тремя пинами мы можем управлять теперь восемью светодиодами.

Составим программу бегущих огней:

#include
#include
#include
#include
#include #define CLK PD2
#define DS PD3
#define E PD4
#define PORT PORTD
#define DDR DDRD int main()
{ DDR|=(1

Источник: http://www.count-zero.ru/2017/shift_register/

74HC595 (сдвиговый регистр) через SPI в C

В этом посте будет рассмотрено сразу две темы: программирование последовательного интерфейса SPI, а также подключение сдвигового регистра 74HC595.

Прежде чем приступать к программированию последовательного интерфейса SPI и подключению сдвигового регистра 74HC595, рекомендую ознакомиться со следующей информацией:

  • 74HC595 (сдвиговый регистр)
  • Последовательный интерфейс SPI

 Итак, нам необходимо подключить к микроконтроллеру ATmega328p семисигментный индикатор, используя всего 3 вывода. Делается это очень просто, при использовании сдвигового регистра 74HC595. Схема подключения представлена на рисунке 1.

Рисунок 1 — Подключение ATmega328p, 74HC595 и семисегментного индикатора 

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

Между микроконтроллером и сдвиговым регистром три линии:

  • SCK -> SHCP — сигнал синхронизации
  • MOSI -> DS — данные
  • PB0 -> STCP — сигнал выдачи принятых данных регистром на семисегментный индикатор

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

Читайте также:  Советские колонки - какие лучше звучат?

Стоит обратить внимание на то, чтобы младший бит передаваемых в сдвиговый регистр данных D0, соответствовал младшему биту выхода сдвигового регистра Q0, необходимо передавать старший бит первым. В данном примере для простоты, наоборот, старший бит передается последним.

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

Приведенная ниже программа, выводящая в цикле цифры 1 и 2, меняющая их каждую секунду.

Текст программы:

#include  //подключение стандартной библиотеки ввода/вывода 

#define F_CPU 8000000 //частота тактирования 

#include  //подключение стандартной библиотеки задержки 

void SPI_out(char data);

int main(void)

{

//PORT

DDRB=0xFF; //порт B работает как выход

//SPI

SPCR=0b01110011; //прерывания запрещены, SPI включен, младший бит передается первым, МК ведущий, импульсы положительной полярности, скорость CLK/128

    while(1)

    {

//        abcdefgh (цифра 1)

        SPI_out(0b01100000); //вывод цифры

_delay_ms(1000); //ждем 1с

//        abcdefgh (цифра 2)

SPI_out(0b11011010);

_delay_ms(1000);

    }

}

void SPI_out(char data) //функция вывода цифры на индикатор

{

SPDR=data; //запись в регистр данных SPI

while(!(SPSR & (1

Источник: http://avrprog.blogspot.com/2013/09/hc595-spi-c.html

Сдвиговый регистр 74HC595 :AVR devices

Когда необходимо подключить к контроллеру два десятка светодиодов или еще чего на помощь приходят сдвиговые регистры. Ну не тратить же драгоценные пины микроконтроллера на это дело 🙂 Для эксперимента купил сдвиговый регистр 74HC595 и в этой небольшой статье покажу как с ним работать при помощи самого крохотного контроллера Tiny13.

Посмотрим что из себя представляет эта микруха. Распиновка на рисунке ниже:

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

  • Q0…Q7 — выходы которыми будем управлять. Могут находится в трёх состояниях: логическая единица, логический ноль и  высокоомное Hi-Z состояние
  • GND — земля
  • Q7′ — выход предназначенный для последовательного соединения регистров.
  • MR — сброс регистра.
  • SH_CP — вход для тактовых импульсов
  • ST_CP — вход «защёлкивающий» данные
  • OE — вход переводящий выходы из HI-Z в рабочее состояние
  • DS — вход данных
  • VCC — питание 5 вольт

Для управления нам вполне достаточно всего лишь трёх  выводов а именно: SH_CPST_CP, DS.

Как работает регистр
Все не так сложно, как кажется на первый взгляд.  Когда на тактовом входе SH_CP появляется логическая единица, регистр считывает бит со входа данных DS и записывает его в самый младший разряд.

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

Что бы данные появились на выходах Q0…Q7 нужно их «защёлкнуть». Для этого необходимо подать логическую единицу на вход ST_CP. Что бы мы не делали с регистром, данные на выходах не изменятся пока мы вновь не «защёлкнем» их. Отсюда кстати пошло название «регистр-защёлка». Теперь пару слов о других выводах микросхемы.

Когда на входе OE лог 1 то выходы находятся в высокоомном состоянии. Когда подаем на этот вход логический 0, тогда выходы работают в нормальном режиме. MR — сбрасывает регистр устанавливая все выходы Q0…Q7 в состояние логического нуля. Для осуществления сброса нужно подать логический ноль на этот вход. После этого «защёлкнуть» данные.

В нормальном состоянии на этом выводе должна находится логическая единица. Q7′ предназначен для последовательного соединения сдвиговых регистров. Можно соединить хоть десяток штук!

Программное обеспечение
Для того чтоб управлять этим регистром была написана небольшая библиотека. Вы без труда сможете использовать её в любом своем проекте.

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

Если паять совсем лениво то можно собрать тестовую схемку в симуляторе Proteus. Файл симуляции прилагается. Если же хочется попробовать в настоящем железе то вот сама схема:

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

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

Они обычно имеют интерфейс i2c но слишком дороги и малораспространенны во всяком случае у нас. Так что сдвиговые регистры наше все =)
Ну и напоследок фото того на чем это всё проверялось и отлаживалось:

Кстати очень удобно для отладки использовать мини макетки для SOIC корпусов. Рекомендую взять на заметку =). Все вопросы складываем в комментарии.

https://www.youtube.com/watch?v=5tLi4LIXrjo

Файл симуляции + исходник
Чисто по приколу записал видео всего этого безобразия

Источник: http://avrdevices.ru/sdvigovy-registr-74hc595/

Записки программиста

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

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

<\p>

Примечание: Если вы пропустили предыдущий пост, посвященный микросхемам 74xx, вот он — Интегральные схемы: чипы стандартной логики 74xx. Впрочем, тот пост был посвящен логическим вентилям, и для понимания представленного далее материала читать его не требуется.

SIPO сдвиговый регистр 74HC595

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

SIPO означает «последовательный вход, параллельный выход». Если же нужно больше пинов на чтение, используются сдвиговые регистры PISO, «параллельный вход, последовательный выход».

В данном разделе мы познакомимся с типичным SIPO сдвиговым регистром, 74HC595.

Какой пин 74HC595 для чего предназначен, можно узнать из даташита [PDF]:

Если коротко, то:

  • VCC, GND — это питание.
  • OE — разрешение вывода. Чтобы вывод был всегда разрешен, можно подключить этот пин напрямую к минусу.
  • SRCLR — сброс. Если не используется, то нужно подключить напрямую к плюсу.
  • SER, SRCLK — используются для передачи данных. При подаче высокого напряжения на SRCLK происходит считывание одного бита данных с пина SER.
  • RCLK — при подаче сюда высокого напряжения происходит одновременный вывод принятых данных на параллельные выходы.
  • Qa-Qh — параллельные выходы. Сюда происходит вывод последних восьми полученных бит при подаче высокого напряжения на SRCLK.
  • Qh’ — при получении очередного бита информации и смещении значений по параллельным выходам бит Qh на самом деле не отбрасывается, а поступает на этот пин. Подключив его к пину SER другого сдвигового регистра, а также соединив выходы RCLK и SRCLK обоих сдвиговых регистров, можно получить 16-разрядный сдвиговый регистр. Второй сдвиговый регистр в свою очередь можно соединить с третьим и так далее, получив сколь угодно разрядный регистр сдвига.

Надеюсь, идея ясна — мы последовательно передаем на сдвиговый регистр восемь бит информации по одному биту. Затем сдвиговый регистр параллельно выводит полученные биты на восемь пинов. Отсюда и «последовательный вход, параллельный выход».

Пример кода:

const uint8_t hc595_data  = 6; /* SER */
const uint8_t hc595_latch = 7; /* RCLK */
const uint8_t hc595_clock = 8; /* SRCLK */

/* … */

void setup()

{
  pinMode(hc595_data, OUTPUT);
  pinMode(hc595_latch, OUTPUT);
  pinMode(hc595_clock, OUTPUT);

  /* … */

}

/* … */

void loop()

{
  /* … */
  digitalWrite(hc595_latch, LOW);
  shiftOut(hc595_data, hc595_clock, MSBFIRST, hc595_out);
  digitalWrite(hc595_latch, HIGH);
  /* … */
  delay(100);
}

Нам даже не нужно писать никаких циклов. В Arduino уже предусмотрена готовая процедура shiftOut, которая делает все за нас.

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

Существует чип 74HC164, который предоставляет аналогичную функциональность, и имеет при этом 14 пинов вместо 16-и. Его даташит можно полистать здесь [PDF].

PISO сдвиговый регистр 74HC165

Типичным представителем PISO сдвиговых регистров является 74HC165.

Картинка из даташита [PDF]:

Назначение пинов:

  • VCC, GND — питание.
  • A-H — входы сдвигового регистра.
  • SH — когда на этом пине низкое напряжение, происходит считывание данных с пинов A-H.
  • CLK INH — что-то делает только при высоком напряжении на SH. Низкое напряжение означает разрешить использование часов (пин CLK). На практике можно подключить напрямую к земле.
  • CLK — когда на SH высокое напряжение и на CLK INH низкое, при подаче на CLK низкого напряжения происходит сдвиг данных.
  • Qh — выход сдвигового регистра. Одноименный выход с чертой — это инвертированный выход.
  • SER — при очередном сдвиге освободившийся бит принимает значение, поданное на этот пин. Пин может быть задействован при одновременном использовании нескольких сдвиговых регистров. Или можно просто подключить к земле.

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

const uint8_t hc165_data = A5; /* QH */
const uint8_t hc165_latch = A4; /* SH */
const uint8_t hc165_clock = A3; /* CLK */

/* … */

void setup()

{
  /* … */

  pinMode(hc165_data, INPUT);

  pinMode(hc165_clock, OUTPUT);
  pinMode(hc165_latch, OUTPUT);
}

uint8_t shiftIn165(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder)

{
  uint8_t value = 0;
  uint8_t i;

  for (i = 0; i<\p>

Источник: https://eax.me/ic74xx-part2/

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

В ситуации когда не хватает выходов микроконтроллера, что обычно делают? Правильно – берут микроконтроллер с большим количеством выходов. А если не хватает выводов у микроконтроллера с самым большим количеством выходов, то могут поставить и второй микроконтроллер.
Но в большинстве случаев проблему можно решить более дешевыми способами например использовать сдвиговый регистр 74HC595.

Преимущества использования сдвигового регистра 74HC595:

  • не требует никакой обвязки кроме конденсатора по питанию;
  • работает через широкораспостраненный интерфейс SPI;
  • для самого простого включения достаточно двух выходов микроконтроллера;
  • возможность практически неограниченного расширения количества выходов без увеличения занятых выходов микроконтроллера;
  • частота работы до 100 МГц;
  • напряжение питания от 2 В до 6 В;
  • дешевый — стоит менее 5 центов;
  • выпускается как в планарных корпусах (74HC595D удобен для производства), так и в DIP16 (74HC595N удобен для радиолюбителей и макетирования).

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

  • 8-битного регистра сдвига,
  • 8-битного регистра хранения,
  • 8-битного выходного регистра.

Рассмотрим какие выводы есть у сдвигового регистра 74hc595.

Общего вывод и вывод питания объяснений не требуют.

  • GND — земля
  • VCC — питание 5 вольт

Входы 74HC595:

OE

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

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

А если в принципе не нужно переводить выходы в высокоимпедансное состояние – смело заземляйте этот вывод.

MR — сброс регистра

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

DS – вход данных

Последовательно подаваемые сюда данные будут появляются на 8-ми выходах регистра в параллельной форме.

SHCP – вход для тактовых импульсов

Когда на тактовом входе SHCP появляется логическая единица, бит находящийся на входе данных DS считывается и записывается в самый младший разряд сдвигового регистра.

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

Тот бит который был записан ранее сдвигается на один разряд (из Q0 в Q1) , а его место занимает вновь пришедший бит. И так далее по цепочке.

STCP – вход «защёлкивающий» данные

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

Выходы 74HC595

  • Q0…Q7 – выходы которыми будем управлять. Могут находится в трёх состояниях: логическая единица, логический ноль и высокоимпедансное состояние
  • Q7′ – выход предназначенный для последовательного соединения регистров.

Временная диаграмма на которой показано движение логической единицы по всем выходам регистра.

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

Вот такая схема подключения семисегментных индикаторов к микроконтроллеру ATMega48 по SPI получилась:

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

Но так как смена происходит очень быстро, то глазу кажется, что горят все цифры. Кроме того одновременно эта схема и опрашивает 4 кнопки S1-S4. Добавив два сдвоенных диода можно опрашивать 8 кнопок.

А добавив 4 транзистора и резистора можно подключить дополнительный 4-х знаковый индикатор.

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

Источник: http://HardElectronics.ru/74hc595.html

Знакомство с микросхемой регистра сдвига 74HC595 — управление 16 светодиодами

» Схемы » Применение микроконтроллеров · Начинающим

04-06-2010

74HC595

Из этого руководства вы узнаете, как управлять 16 светодиодами используя всего 3 линии управления. Мы осуществим это путем последовательной передачи данных в сдвиговые регистры 74HC595.

Микросхема 74HC595 содержит 8 битный регистр хранения и 8 битный сдвиговый регистр. Данные последовательно передаются в сдвиговый регистр, затем фиксируются в регистре хранения. К регистру хранения подключены 8 выходных линий. На картинке ниже показано расположение выводов микросхемы 74HC595.

Вывод 14 (DS) это вывод данных. В некоторых описаниях он обозначается как «SER».

Когда уровень на выводе 11 (SH_CP, иногда обозначается как SRCLK) переходит из низкого в высокий, значение на выводе DS сохраняется в сдвиговом регистре, при этом данные сдвигаются на один разряд, чтобы предоставить место для нового бита.

Пока на выводе 12 (ST_CP, иногда обозначается как RCLK) низкий уровень, данные записываются в регистр сдвига. Когда уровень переходит в высокий, данные из сдвигового регистра фиксируются в регистре хранения, из которого поступают на выводы Q0…Q7.

На представленной ниже временная диаграмме, показано, каким образом можно установить на выходах Q0…Q7 микросхемы значение 11000011, учитывая что изначально там было значение 00000000.

Ниже показана схема, которую мы соберем в несколько шагов.

Кликните для увеличения

Мы используем перфорированную макетную плату с контроллером Atmega8, которую использовали во многих наших проектах. Добавим еще 2 пустых макетных платы и подведем к ним питание.

Установим микросхему регистра сдвига и подключим к ней питание +5 В и общий провод.

Теперь проведем 3 линии управления между микроконтроллером и регистром сдвига, для чего подсоединим:

  • PC0 к DS
  • PC1 к ST_CP
  • PC2 к SH_CP

Этими линиями являются 3 синих провода на картинке ниже.

Затем подключим светодиоды и резисторы. Я использовал резисторы сопротивлением 510 Ом, но допустимы и другие номиналы.

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

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

Мы используем вывод Q7, чтобы соединить регистры сдвига в одну цепочку.

Модифицированная схема показана ниже.

Кликните для увеличения

Код для реализации скачущего огонька на 16 светодиодах.

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

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

protostack.com

Для комментирования материалов с сайта и получения полного доступа к нашему форуму Вам необходимо зарегистрироваться.
Фрагменты обсуждения: Полный вариант обсуждения »
  • В програмке на 8 светодиодах есть ошибки… Исправьте, плиз…
  • А вы знаете какие именно ошибки в программе. Или пробовали компилировать и получили ошибки при компиляции? Как таковых ошибок в программе нет, но есть один нюанс, который был задуман автором, с целью использовать данный пример на разных контроллерах. Всего навсего… Так же один момент — не указана тактовая частота в программе, но я не считаю что это ошибка, а даже наоборот, с этим параметром можно «поиграться» и увидеть результаты и изменения. Единственное, в тексте описания не говорится о том, что мега настроена на работу от внутреннего осциллятора. У меня скомпилировать получилось, все без ошибок (AVRStudio).
  • Я компелировал в CodeVisionAVR. Ошибки в delay_ms это мелочи, компилятор не понимает _BV() и bit_is_set. Схему тестирую в протеусе. А как в АВРстудио писать на С++, там же вроде ассемблер…
  • AVRStudio + компилятор WinAVR и пишем на Си в студии.
  • Поставил WinAVR, не понимает delay.h Какая библиотека в аврстудио для паузы?
  • Используем: include и include
  • ../new.c:2:26: util/delay.h: No such file or directory :confused: текст программы в АВРСтудио 4: #include #include #define DS_PORT PORTC #define DS_PIN 0 #define ST_CP_PORT PORTC #define ST_CP_PIN 1 #define SH_CP_PORT PORTC #define SH_CP_PIN 2 #define DS_low() DS_PORT&=~_BV(DS_PIN) #define DS_high() DS_PORT|=_BV(DS_PIN) #define ST_CP_low() ST_CP_PORT&=~_BV(ST_CP_PIN) #define ST_CP_high() ST_CP_PORT|=_BV(ST_CP_PIN) #define SH_CP_low() SH_CP_PORT&=~_BV(SH_CP_PIN) #define SH_CP_high() SH_CP_PORT|=_BV(SH_CP_PIN) //Define functions //====================== int i; void ioinit(void); void output_led_state(unsigned char __led_state); //====================== void ioinit (void) { DDRC = 0b00000111; //1 = output, 0 = input PORTC = 0b00000000; } void output_led_state(unsigned char __led_state) { SH_CP_low(); ST_CP_low(); for (i=0;i0; i—) { output_led_state(_BV(i)); _delay_ms(100); } for (i=0; i
Читайте также:  Правильное зу nimh/nicd аккумуляторов электроотвертки

Источник: https://www.rlocman.ru/shem/schematics.html?di=65110

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

Измерительная техника

Главная  Радиолюбителю  Измерительная техника

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

Микросхема 74HC595

Представляет собой восьмибитный регистр сдвига с возможностью «защелкивания» (фиксирования) данных по отдельному управляющему сигналу. Работает микросхема с последовательным интерфейсом SPI (Serial Peripheral Interface, обязательно требуется синхронизация данных с тактовым сигналом).

Корпус микросхемы может быть планарным (кодировка 74HC595D) или стандарта DIP16 (в этом случае кодировка 74HC595N).

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

Рис. 1. Принципиальная схема регистра

(сверху 8-битный регистр сдвига, в середине регистр хранения, ниже – выходной регистр)

Рис. 2. Микросхема 74HC595

Данные подаются на вход DS. Снимаются с выводов Q0-Q7.

GRD – «земля», VCC – питание +5 В (не более 6 В).

SH_CP – контакт для подачи тактовых сигналов (должны быть синхронизированы с битами данных).

MR – позволяет сбросить (обнулить) регистр.

ST_CP – «защелка» введенных данных.

OE – отвечает за переключение между Z-состоянием и рабочим режимом.

Через контакт Q7’ можно соединять последовательно между собой несколько микросхем 74HC595.

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

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

Рис. 3. Светодиодный или жидкокристаллический элемент

С помощью семи сегментов можно показать пользователю 128 (27) различных комбинаций свечения.

Рис. 4. Комбинации свечения

Использование регистра и индикатора вместе

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

Используя 74HC595 можно включить в схему не один индикатор, а несколько (в зависимости от того, сколько разрядов индикации требуется).

Самый простой пример (можно даже собрать в программе Proteus) соединения 74HC595 с индикатором ниже.

Рис. 5. Схема соединения 74HC595 с индикатором

Управлять логикой работы индикатора будет следующий листинг:

#include

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

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

Чтобы было понятнее, приведем кодировку команд сопоставленную с десятичными цифрами.

Цифра HEX
0x3F
1 0x06
2 0x5B
3 0x4F
4 0x66
5 0x6D
6 0x7D
7 0x07
8 0x7F
9 0x6F
h 0x80

Возможно так будет нагляднее (в двоичном коде на контактах светодиодного индикатора).

Обозначения А-H – это светодиоды на панели (смотри обозначения ниже).

Рис. 6. Светодиоды на панели

То есть, чтобы индикатор показал нам цифру 1, нужно отправить код (00000110 или в шестнадцатеричном формате 0x06), тогда загорятся светодиоды c и b. Обратите внимание, здесь массив данных для отображения никак не соотносится с реальными числами, то есть 0x06 – это 6 в десятеричной системе счисления, а светодиоды отобразят 1.

Перейдем к более практическим задачам.

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

Сама схема.

Рис. 7. Схема устройства

Генератор тактовой частоты в Attiny13 встроенный. Данные температуры в контроллер передаются с датчика LM35. И после реализации логики в программируемой микросхеме данные для отображения последовательно передаются в 74HC595, которые в свою очередь накопленные 8 бит информации передают на семисегментные светодиоды.

Листинг программы будет выглядеть так:

#include

Источник: http://www.radioradar.net/radiofan/measuring_technics/register_74hc595_seven_segment_indicator.html

Программирование Arduino урок 13 — сдвиговый регистр 74HC595

Доброго времени суток! Ситуация, когда в микроконтроллере не хватает выходов, встречается довольно часто. Для решения подобной проблемы воспользуемся сдвиговым регистром 74HC595.

74HC595 — восьмиразрядный сдвиговый регистр с последовательным вводом, последовательным/параллельным выводом информации, с триггером-защелкой и тремя состояниями на выходах регистра.

Регистр контролирует 8 выходов, занимая всего 3 выхода микроконтроллера. Кроме этого можно собрать каскад из нескольких таких регистров.

Регистр использует принцип синхронизированной последовательной передачи сигнала.

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

Когда байт полностью вычитан, значения всех 8 бит распределяются по выходам регистра. То есть передаем в регистр сигналы последовательно, а на выходах регистра имеем 8-м параллельных сигналов.

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

Выходы регистра могут быть в одном из трёх состояний:

  • логический ноль;
  • логическая единица;
  • высокоомное (высокоимпедансное) состояние.

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

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

Это может быть полезно, если одними и теми же элементами планируется управлять при помощи разных регистров — когда активен один (сигнал LOW на входе OE), следует перевести второй в высокоомное состояние (сигнал HIGH на входе OE). Если регистр всего один, можно смело подключать OE к земле.

Также к земле подключается выход GND. Для нормального функционирования регистра также следует подключить вход MR к рельсе питания. Туда же подключаем Vcc.

К минусам использования сдвигового регистра стоит отнести невозможность использования широтно-импульсной модуляции (ШИМ), потому что выходы регистра могут иметь только логические значения HIGH (1) и LOW (0).

Распиновка входов/выходов регистра

Регистр работает на интерфейсе SPI: выводы DS, ST_CP, SH_CP — это шины управления.

  • Выводы 1-7, 15 ———— Q0-Q7 ———— Параллельные выходы (разряды);
  • Вывод 8 ———————- GND ————— земля;
  • Вывод 9 ———————- Q7″ —————- Выход для последовательного соединения регистров;
  • Вывод 10 ——————— MR —————- Сброс значений регистра. Сброс происходит при получение LOW. Если заведём питание +5В, то сброс будет неактивным;
  • Вывод 11 ——————— SH_CP ———— Вход для тактовых импульсов — «тактовая линия (SCK)»;
  • Вывод 12 ——————— ST_CP ———— Синхронизация выходов — «защёлка (SS)»;
  • Вывод 13 ——————— OE ———— Вход для переключения состояния выходов из высокоомного в рабочее (подключаем на землю);
  • Вывод 14 ——————— DS —————- Вход для последовательных данных — «шина данных (MOSI)»;
  • Вывод 16 ——————— Vcc —————- Питание.

Соберём стенд с одним сдвиговым регистром.

Подключим:

  • GND (пин 8) на землю;
  • Vcc (пин 16) к питанию 5В;
  • OE (пин 13) на землю;
  • MR (пин 10) к питанию 5В;

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

Можно контролировать выводы MR и OE непосредственно с Arduino (обнуляя входы и/или подключая выходы в нужный момент).

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

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

Подключаем Arduino:

  • DS (dataPin) 14-й вывод регистра с 11-ым выходом Arduino;
  • SH_CP (clockPin) 11-й вывод регистра с 12-ым выходом Arduino;
  • ST_CP (latchPin) 12-й вывод регистра c 8-ым выходом Arduino;

Конденсатор ёмкостью 0.1 микрофарада необходимо подключит на «защёлку» для минимизации шума в схеме при подаче «защелкивающего» импульса. Подключаем светодиоды к выходам регистра через токоограничивающие резисторы.

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

В место неё будет использовать функцию shiftOut() — выводит байт информации на порт вход/выхода последовательно (побитно).

У функции всего четыре параметра:

  • Номер вывода, по которому передаются данные (подключенный к DS);
  • Номер вывода, по которому передаются тактовые импульсы (подключенный к SH_CP).
  • Параметр передачи битов в регистр: MSBFIRST — прямой порядок, начиная со старшего (первого) бита; LSBFIRST — обратный порядок, начиная с младшего (последнего бита).
  • Значение, которое должно быть передано в регистр. В данном случае передаем значение от 0 до 255 (2 в степени 8, регистр 8-ми битный).

Объявим переменные и присвоим им соответствующие значения.

int latchPin = 8; int clockPin = 12; int dataPin = 11;

Конфигурируем выводы на выход и ставим «защёлку», чтобы сдвиговый регистр не принимал сигналов:

void setup(){   pinMode(clockPin, OUTPUT);   pinMode(dataPin, OUTPUT);   pinMode(latchPin, OUTPUT);   digitalWrite(latchPin, HIGH); }

После этого отправим на регистр байт. Для этого снимем защёлку (ставим LOW) — начинаём передачу данных (регистр принимает сигналы с Arduino).

digitalWrite(latchPin, LOW);

Отправляем данные (отправляем байт в цифровом или двоичном виде) = 0b00000001.

shiftOut(dataPin, clockPin, MSBFIRST,0b00000001);

В конце ставим защёлку (ставим HIGH) — заканчиваем передачу.

digitalWrite(latchPin, HIGH);

В итоге весь наш код имеет следующий вид:

int latchPin = 8; int clockPin = 12; int dataPin = 11;  void setup() {   pinMode(clockPin, OUTPUT);   pinMode(dataPin, OUTPUT);   pinMode(latchPin, OUTPUT);   digitalWrite(latchPin, HIGH); }  void loop() {   digitalWrite(latchPin, LOW);   shiftOut(dataPin, clockPin, MSBFIRST, 0b00000001);   digitalWrite(latchPin, HIGH); }

Заливаем прошивку в контроллер. Смотрим на результат.

Непосредственно управление регистром осуществляется с помощью входов DS, SH_CP и ST_CP. Когда происходит переключение SH_CP (clockPin) с LOW на HIGH, в регистр считывается значение с DS (1 бит). При переключении ST_CP (latchPin) с LOW на HIGH заканчивается прием информации и выводы переходят в назначенное состояние.

Напишем функцию (вместо 3-х строк) для оптимизации кода:

void sendBitsToShift (byte value){   digitalWrite(latchPin, LOW);   shiftOut(dataPin, clockPin, MSBFIRST, value);   digitalWrite(latchPin, HIGH); }

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

Для удобства работы создадим массив типа «boolean» для хранения состояния разряда (HIGH или LOW).

boolean statesOfpin[8];

Напишем под него функцию, что будет принимать 2 параметра: номер разряда и уровень, который нужно этому разряду присвоить: HIGH или LOW.

void sendBitsToPin (int pin, boolean state){

Микроконтроллер начинает отсчёт с нуля. Чтобы не было путаницы будем отнимать единицу от номера текущего разряда. Другими словами — пользователь работает с 1 — 8 разрядами, а контроллер воспринимает это, как работу с 0 — 7.

 pin—;

Перезаписываем изменения в массиве:

statesOfpin [pin] = state;

Формируем байт (из 8 битов) и отправляем его на регистр. Объявляем переменные: value — формируемый байт (по умолчанию с нулевым значением); add — хранить байт текущего разряда.

  byte value = 0;   byte add = 1;

Формируем байт.

  for(int i=0; i

Источник: http://mozgochiny.ru/electronics-2/programmirovanie-arduino-urok-13-sdvigovyiy-registr-74hc595/

Как подключить сдвиговый регистр 74HC595 к Arduino

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

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

Схема выводов («распиновка») приведена на рисунке слева.

Назначение выводов сдвигового регистра 74HC595 и внешний вид в выводном корпусе DIP-16

Назначение выводов микросхемы 74HC595 такое.

Обозначение выводаНазначение
Q0…Q7 выходы параллельных данных;
GND земля (0 В);
Q7' выход последовательных данных;
MR сброс ведущего устройства (активный низкий);
SHCP вход тактовых импульсов сдвигового регистра;
STCP вход тактовых импульсов «защёлки»;
OE разрешение вывода (активный низкий);
DS вход последовательных данных;
VCC питание +5 В.

Конструктивно микросхема выполняется в нескольких типах корпусов; я буду использовать микросхему в выводном корпусе DIP-16, т.к. его проще использовать с макетной платой (бредбордом).

2Краткое описание интерфейса SPI

Коротко напомню о последовательном интерфейсе SPI, который мы будем использовать для передачи данных в сдвиговый регистр. SPI – это четырёхпроводный двунаправленный последовательный интерфейс, в котором принимают участие ведущее и ведомое устройства. Ведущим в нашем случае будет являться Arduino, ведомым – регистр 74HC595.

Среда разработки для Arduino имеет встроенную библиотеку работы по интерфейсу SPI. При её применении используются цифровые выводы с 10 по 13 на платах Arduino Uno и Arduino Nano; также они продублированы и выведены на отдельный разъём ICSP:

Выводы Arduino, отведённые под SPI

Обозначение выводаНазначение
SCLK вывод тактовых импульсов SPI;
MOSI данные от ведущего – к ведомому;
MISO данные от ведомого к ведущему;
SS выбор ведомого.

3Подключение сдвигового регистра74HC595 к Arduino

Давайте соберём схему, которая показана на рисунке.

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

Думаю, тут всё понятно. Единственный комментарий – справа на монтажной плате – ряд из 8-ми штырьков (разъём типа PLS), с которых удобно снимать параллельные данные сдвигового регистра.

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

Подключение сдвигового регистра 74HC595 к Arduino

4Тестовый скетч для изучения работы регистра сдвига

Напишем вот такой скетч и загрузим в память Arduino. Здесь мы по циклу будем записывать два числа – 210 и 0 – в сдвиговый регистр с небольшими временными интервалами между ними. Да, только и всего.

#include // подключаем библиотеку void setup() { SPI.begin(); // инициализируем SPI pinMode(PIN_SPI_SS, OUTPUT); } void loop() { digitalWrite(PIN_SPI_SS, LOW); // выбор регистра сдвига SPI.transfer(210); // передаём число «210» в сдвиговый регистр digitalWrite(PIN_SPI_SS, HIGH); // конец передачи delay(10); // задержка 10 мсек digitalWrite(PIN_SPI_SS, LOW); SPI.transfer(0); digitalWrite(PIN_SPI_SS, HIGH); delay(90); }

Переменная PIN_SPI_SS – это внутренняя стандартная константа, которая соответствует выводу «10» Ардуино при использовании его в качестве ведущего устройства интерфейса SPI, который мы тут используем.

В принципе, мы могли бы с таким же успехом использовать любой другой цифровой вывод Arduino; тогда пришлось бы его объявить и не забыть задать режим работы – OUTPUT.

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

5Временная диаграмма работы микросхемы 74HC595

Общий вид временной диаграммы – на рисунке. Голубой пунктирной линией показаны 4 линии SPI, красной пунктирной – 8 каналов параллельных данных регистра сдвига. Точка A на шкале времени – это момент передачи в регистр сдвига числа «210», B – момент записи числа «0», C – завершение текущей итерации цикла и начало новой.

Временная диаграмма работы микросхемы 74HC595

Как видно, от А до B – 10,03 миллисекунд, а от B до С – 90,12 миллисекунд, почти как мы и задали в скетче. Небольшая добавка в 0,03 и 0,12 мс – время передачи последовательных данных от Arduino, поэтому мы тут имеем не ровно 10 и 90 мс.

Рассмотрим подробнее участок A.

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

Диаграмма передачи числа «11010010» по SPI

В первом канале сверху – длинный импульс с нулевым уровнем, которым Arduino инициализирует передачу по линии SPI — ENABLE – выбор ведомого. В это время начинают генерироваться тактовые импульсы SPI — CLOCK (см. второй сверху канал). Для передачи одного байта генерируется 8 тактовых импульсов.

Третий канал сверху – SPI — MOSI – данные, которые мы передаём от Arduino к сдвиговому регистру. Это наше число «210» в двоичном виде – «1101 0010».

После завершения передачи линия SPI — ENABLE поднимается в высокое состояние, и мы видим, что сдвиговый регистр выставил на своих 8-ми ножках значение «1101 0010». Я выделил это в голубой пунктирной линией и подписал значения для наглядности.

Теперь обратим внимание на участок B.

Диаграмма передачи числа «00000000» по SPI

Опять всё начинается с выбора ведомого и генерирования 8-ми тактовых импульсов (первый и второй каналы сверху). Данные на линии SPI — MOSI теперь – «0000 0000» (3-ий сверху канал). То есть мы записываем в этот момент в регистр число «0».

Но пока передача не закончена, в регистре по прежнему хранится значение «1101 0010», которое мы выставили ранее. Оно выводится на параллельные выводы Q0..Q7 (8 нижних каналов на рисунке), а также, при наличии тактовых импульсов в линии SPI — CLOCK, выдаётся в линию SPI — MISO (см.

4-ый канал сверху) c последовательного выхода регистра Q7', что мы тут и видим.

6Подключение нескольких регистров сдвига к Arduino

Если подключить несколько сдвиговых регистров таким образом, чтобы линии CLOCK (SCLK на рисунке ниже), MOSI и MISO у них были общие, а ENABLE (SS на рисунке) каждой микросхемы подключались к разным цифровым выводам Arduino, то можно независимо обращаться к каждому из сдвиговых регистров, активизируя низким уровнем соответствующий из них, и записывать в регистры данные и считывать из них данные. Такое подключение называется независимым.

Независимый и каскадный типы подключений по интерфейсу SPI

Независимое подключение ведомых SPI устройств (например, регистров 74HC595) к ведущему (например, Arduino) изображено на левой части рисунка. Думаю, это уже достаточно просто для нас, так как оно почти ничем не отличается от подключения одного сдвигового регистра. Поэтому давайте рассмотрим другой тип подключения – каскадный.

7Каскадное подключение регистров сдвига к Arduino

Продолжение следует…

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

Источник: https://soltau.ru/index.php/arduino/item/458-kak-podklyuchit-sdvigovyj-registr-74hc595-k-arduino

595-регистр нужен везде и всем!

595-ый – штука широко используемая когда не хватает портов вывода микроконтроллера. Для управления регистром требуется минимум два вывода контроллера (а лучше три), а выходов получаем теоретически сколько угодно (у меня максимум было 48), о чем дальше и пойдет речь.

В самом конце опишу опыт защиты от помех, например когда блок с регистрами подключен шлейфом  к контроллеру, а ведь CMOS-входы, это не старый-добрый-“теплый” TTL, тут токи почти нулевые. А еще не вредно при таких подключениях предусмотреть и ситуацию, когда соединительный шлейф неожиданно сгрызли гризли, а порты управляют ядерным арсеналом.

Читайте также:  Электронный трансформатор для галогенных ламп 12в с мягким стартом

Ну и до кучи напишу какими командами в Atmel контроллерах (ATMEGA, ATTINY) удобно работать с портами при программировании на C (всякие битовые операторы, хитрые #define для повышения читаемости кода и пр.). Вроде как такой гайд для совсем начинающих. А не начинающим лучше сразу на второй пост про помехи…

Во-первых как работает сдвиговый регистр?

Как видно из названия, он что-то куда-то сдвигает. У любого такого регистра есть два основных входа:

  • Вход данных (Data serial input)
  • Вход импульса* сдвига (Shift clock)

* “импульс” (или “строб”), это последовательное изменение значения входа с “0” на “1” и обратно на “0”, или инверсный вариант с “1” на “0” и обратно в “1”. Переход из “0” в “1” называется передним фронтом, наоборот – задним. 74HC595 переключается по переднему фронту, т.е. в момент перехода из “0” в “1”.

Строб сдвига инициирует “переписывание” значений выходов в следующий выход: из 1-го во 2-й, из 2-го в 3-й, …, 7->8, то что было на 8 теряется. Получается сдвиг от первого выхода в направлении последнего. Одновременно на первый выход записывается то, что было на входе данных.

Например: изначально на выходах были нули (00000000),

Затем на Data подали 1, после чего сделали 3 строба на Shift clock.

В итоге получим на выходе: 11100000 (т.е. 3 раза все сдвигали вправо и писали 1 из Data в первый выход).

Потом на вход Data выставили 0 и отправили еще один строб:

Выход: 01110000 (3 единицы отползли вправо, а в первый разряд записался 0 из Data)

Ну и наконец на Data оставили 0 и сделали еще 5 стробов (5 сдвигов вправо):

Выход: 00000011 (сдвинули так сильно, что самая первая записанная единица выскочила за 8 разряд и пропала)

Последовательно выставляя нужные значения на вход Data и сдвигами можно получить любое сочетание на выходах регистра, т.е. преобразовать последовательную передачу в параллельную. У 74HC595 выходов 8, получается что 2 выхода контроллера, можно “развести” на 8 исполнительных устройств.

А если на последний выход регистра прицепить вход Data другого регистра и запараллелить его Shift clock на Shift clock первого, то “убегающий 8 разряд” будет становится первым у следующего регистра и мы получим уже не 8, а 16 разрядов, управляя по прежнему с двух ног контроллера (наращивать разрядность доп.

регистрами можно и дальше, получая 24, 32 и т.д.).

Немного кодирования

Простейший пример (годится для индикации и медленных устройств типа реле).

Последовательно выдаем каждый бит на порт контроллера куда подключен вход Data и дергаем туда-обратно порт, куда подключен вход Shift регистра.

void Out595Port(uint8_t data) { for (uint8_t i=0;i

Источник: https://vms11.wordpress.com/2014/11/15/595-1/

Дисплей на сдвиговых регистрах 74НС595 — обзор и возможности

        Итак, сегодня мы познакомимся с таким интересным девайсом как 7-ми сегментный дисплей управляемый сдвиговыми регистрами на базе микросхемы 74HC595.

К нам на обзор попал дисплей от фирмы RobotDyn, он управляется именно при помощи двух выходных сдвиговых регистров 74HC595 включенных последовательно, но тут есть один нюанс — один регистр управляет включением разряда, а другой регистр — включением сегментов в выбранном разряде. То есть в данном случае, цифры в разрядах на дисплее зажигаются динамически.

Не углубляясь в подробности внутренней работы сдвигового регистра, просто попробуем подключить дисплей от фирмы RobotDyn к плате Arduino Nano, поработать с командами сдвига(shifOut()) и отобразить нужные символы и цифры. Вот так выглядит этот дисплей:

Основные характеристики дисплея:

  • Количество отображаемых цифр — 6 (шести разрядный)
  • Цвет сегментов — белый
  • Напряжение питания 5 вольт
  • Управление сегментами на базе микросхемы 74HC595

На фото(вид сзади) можно видеть пины подключения:

Всего их пять, это:

  • DIO — Пин данных
  • SCK — Пин тактирования
  • RCK — Пин «защелка»
  • GND — Подключение к земле
  • +5V  — Подключение питания 

        На фото видно — что пины подключения расположены с правой и левой стороны, и имеют одинаковые названия.

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

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

  • Display 74HC595[PIN DIO]        —        Arduino Nano [PIN 3]
  • Display 74HC595[PIN SCK]        —        Arduino Nano [PIN 4]
  • Display 74HC595[PIN RCK]        —        Arduino Nano [PIN 2]

        Пины питания(+5V и GND) нужно подключить также соответствующим образом, думаю что с этим ни у кого проблем не возникнет.

И начнем пожалуй с простейшего скетча, попробуем отобразить цифру 5 в самом крайнем левом разряде(индекс разряда в таком случае будет равен 0).

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

/*  * Пины для подсоединения к I/O Wireless Shield for Arduino Nano  * Display[DIO]  to PIN3  * Display[SCK]  to PIN4  * Display[RCK]  to PIN2  * Display[GND]  * Display[+5V]  */ const int Latch = 2;  //RCK 2 const int Data  = 3;  //DIO 3 const int Clock = 4;  //SCK 4 /*  * Определяем разряды на трубке, начнем с крайнего левого  * он будет первым(самым младшим), крайний правый будет шестым  * самым старшим.  */ //   Разряды          0-й   1-й   2-й   3-й*  4-й   5-й   6-й   7-й*     byte numbDigits[8] = {0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08}; /*  * Формируем из сегментов цифру  */ //   Цифры              0     1     2     3     4     5     6     7     8     9 byte numbSerial[10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90}; /*  * Точка для разряда  */ byte pointDigit = 0x80; void setup() {   //Определяем все назначенные пины как выходы   pinMode(Latch, OUTPUT);     pinMode(Clock, OUTPUT);   pinMode(Data, OUTPUT);   } void loop() {   //Чтобы начать работу с дисплеем нужно установить пин «защелку»   //в низкий уровень, пока есть низкий уровень можно записывать   //в регистр значения, кодирующие включение нужных сегментов   //в нужном разряде   digitalWrite(Latch, LOW);   //Сначала записывается байт кодирующий цифру 5   shiftOut(Data, Clock, MSBFIRST, numbSerial[5]);   //Затем записывается байт зажигающий разряд 0   shiftOut(Data, Clock, MSBFIRST, numbDigits[0]);   //Затем нужно «защелкнуть данные», установить пин Latch   //в высокий уровень, если этого не сделать то на дисплее будет   //видна непонятная «каша» из разных зажженых сегментов   digitalWrite(Latch, HIGH); }

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

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

А сейчас смотрим результат работы скетча, на фото: 

Следующий интересный момент — как зажечь десятичную точку? Даже если дисплей и называется семисегментным, он всё равно имеет восьмой сегмент — это и есть десятичная точка на разряде. Итак, в вышеуказанном скетче есть такая строка:

/*  * Десятичная точка для разряда  */ byte pointDigit = 0x80;

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

//Сначала записывается байт кодирующий цифру 5   shiftOut(Data, Clock, MSBFIRST, numbSerial[5] ^ pointDigit);

В Си подобных языках программирования эта операция называется «Исключающее ИЛИ», результат можно видеть на фото:

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

 /*  * Пины для подсоединения к I/O Wireless Shield for Arduino Nano  * Display[DIO]  to PIN3  * Display[SCK]  to PIN4  * Display[RCK]  to PIN2  * Display[GND]  * Display[+5V]  */ const int Latch = 6;  //RCK 2 const int Data  = 8;  //DIO 3 const int Clock = 7;  //SCK 4 /*  * Переменная cycleCounter — счетчик циклов сканирования  * за каждый цикл сканирования loop, будет отрисовываться одна цифра  * в заданном разряде. */ static unsigned char cycleCounter = 0; /*  * Определяем разряды на трубке, начнем с крайнего левого  * он будет первым(самым младшим), крайний правый будет шестым  * самым старшим.  */ //   Разряды          0-й   1-й   2-й   3-й*  4-й   5-й   6-й   7-й*     byte numbDigits[8] = {0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08}; /*  * Формируем из сегментов цифру  */ //   Цифры              0     1     2     3     4     5     6     7     8     9 byte numbSerial[10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90}; /*  * Точка для разряда  */ byte pointDigit = 0x80; void setup() {   //Определяем все назначенные пины как выходы   pinMode(Latch, OUTPUT);     pinMode(Clock, OUTPUT);   pinMode(Data, OUTPUT);   } void loop() {   //Перед началом цикла сканирования, сравниваем счетчик   //если прошло 7 циклов, и счетчик был инкрементирован   //то сбрасываем   if(cycleCounter == 8)   {     cycleCounter = 0;   }     //Чтобы начать работу с дисплеем нужно установить пин «защелку»   //в низкий уровень, пока есть низкий уровень можно записывать   //в регистр значения, кодирующие включение нужных сегментов   //в нужном разряде   digitalWrite(Latch, LOW);   //Сначала сдвигаем байт кодирующий цифру     shiftOut(Data, Clock, MSBFIRST, numbSerial[cycleCounter]);   //Затем сдвигаем байт кодирующий разряд   shiftOut(Data, Clock, MSBFIRST, numbDigits[cycleCounter]);   //Затем нужно «защелкнуть данные», установить пин Latch   //в высокий уровень, если этого не сделать то на дисплее будет   //видна непонятная «каша» из разных зажженых сегментов   digitalWrite(Latch, HIGH);   cycleCounter ++;   delayMicroseconds(1000); }

Результат работы скетча можно видеть на фото:

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

Переменная cycleCounter  является счетчиком циклов, при достижении значения счетчика равного 8 счетчик обнуляется. За один цикл сканирования программы отрисовывается одна цифра в одном разряде начиная с нулевого, потом зажигание передаётся на следующий по порядку разряд.

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

Но и здесь главное не переусердствовать, увеличение значения передаваемое в функцию delayMicroseconds() может привести к другому неприятному визуальному эффекту — мерцанию. Самый оптимальный диапазон значений микросекунд — от 1000 до 3000, подбирается так сказать «под себя».

        Изменив в программе одну строку можно отобразить точку для каждого из разрядов. Выше уже было описана операция «исключающее ИЛИ», применение её в следующей строке скетча: 

//Сначала сдвигаем байт кодирующий цифру     shiftOut(Data, Clock, MSBFIRST, numbSerial[cycleCounter] ^ pointDigit);

Получим следующий результат, смотрим фото:

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

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

Слева — все биты в байте установлены в единицу, следовательно все сегменты погашены, справа — зажжены сегменты генерирующие символ J.

        Для примера можно взять слово Sensor, состоящее из 6-ти символов, как раз по размерности дисплея. Закодировать каждый символ этого слова нетрудно если следовать вышеуказанной таблице. Вывести это слово посимвольно можно изменив и дополнив скетч который выводит цифры. Добавим массив байт кодирующий слово Sensor :

/*  * Сообщение «Sensor»  */                                 //*                     //* byte Sensor[8] = {0x92, 0x86, 0xAB, 0x00, 0x92, 0xA3, 0xAF, 0x00};

Вместо массива с кодами цифр, выводим массив с сообщением Sensor

shiftOut(Data, Clock, MSBFIRST, Sensor[cycleCounter]);

Результат можно видеть на фото ниже:

На этом вроде бы и всё, обзор был задуман как «быстрый пуск», думаю что у нас это вполне получилось.

К недостаткам этого модуля можно отнести следующее — к нему нельзя подключить ещё один такой же последовательно, как например можно подключать дисплеи на базе драйвера MAX7219.

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

Источник: http://arduino.on.kg/displey-na-sdvigovyh-registrah-74ns595—kak-ego-pobedit

Ардуино: всё о сдвиговом регистре

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

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

Два таких индикатора займут уже 16 ног Ардуино.

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

В электронике регистром называют устройство, которое может хранить небольшой объем данных для быстрого доступа к ним. Они есть внутри каждого контроллера и микропроцессора, включая и микроконтроллер Atmega328 — сердце Ардуино Уно.

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

Регистры первого типа называются сдвиговыми, второго типа — параллельными.

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

1. Принцип работы сдвигового регистра

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

Пусть в начальном состоянии регистр уже заполнен какими-то восемью битами. Попробуем «задвинуть» в него восемь новых бит: 11011010.

Как видно, после двух итераций, в начале регистра оказалось два новых бита, а два бита в последних ячейках «вывалились» через край в небытие. На 8-м шаге весь регистр оказался заполнен новыми битами.

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

2. Сдвиговый регистр 74HC595

На этом уроке мы разберем работу сдвигового регистра 74HC595, который может хранить 8 бит данных. Схема выводов микросхемы представлена на картинке. Кстати, у этого регистра есть и отечественный аналог КР1564ИР52.

  • Q0-Q7 — выходы каждой из 8 ячеек;
  • VCC — питание микросхемы, 5В;
  • GND — земля;
  • DS — линия данных;
  • ST_CP — линия синхроимпульса для передачи данных из внутренних ячеек, во внешние;
  • SH_CP — линия синхроимпульса для передачи данных из DS во внутренние ячейки;
  • OE — инверсный, разрешение на вывод данных с внешних ячеек;
  • Out3, Out4 — выводы для подключения второго двигателя;
  • Q7′ — выход регистра, который необходимо соединить с Q0 следующего регистра для создания цепочки.

У регистра есть один вход данных и два входа синхронизации. Синхроимпульс SH_CP запоминает текущее состояние входа данных DS. Другими словами, если на DS в момент синхронизации был высокий уровень HIGH, то в первой ячейке регистра сохранится 1. В противном случае, сохранится .

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

Второй слой ячеек соединяется непосредственно с выходами Q0-Q7, и чтобы переместить бит из первого слоя во второй, нам потребуется второй синхроимпульс ST_CP. Это может немного путать, но зато такой двухслойный регистр дает нам очень полезную возможность.

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

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

Теперь подробнее про алгоритм работы с синхроимпульсами. Вот так выглядит временная диаграмма регистра 74HC595:

Необходимо отметить, что порядок следования импульсов очень важен. Сначала мы устанавливаем на выводе DS нужный уровень сигнала, и только потом делаем импульс на SH_CP.

3. Управление восемью светодиодами

Итак, начнем с самого простого. Будем управлять восемью светодиодами, подключенными к Ардуино Уно посредством сдвигового регистра 74HC595. Не будем забывать, что каждому светодиоду необходим токозадающий резистор. Наличие регистра не освобождает нас от этого важного компонента.

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

Внешний вид макета

Программа

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

const int data_pin = 2; const int sh_pin = 4; const int st_pin = 3; int bt = 0; void shift(byte v){ for(int i=0; i

Источник: http://robotclass.ru/tutorials/arduino-shift-register/

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