Акселерометр и гироскоп MPU6050

1описание, принцип действия и схема радара rcwl-0516

Датчик представляет собой модуль размером 35.9×17.3 мм и практически плоский, за исключением микросхемы BISS0001 (аналог RCWL-9196) на лицевой стороне и линейного стабилизатора напряжения 7133-1 на обратной. Благодаря линейному стабилизатору модуль можно питать напряжениями от 4 до 27 В, которое подаётся на вывод VIN. Внешний вид модуля приведён на фото.

Обратите внимание, что вывод 3V3 – это не вход питания, а выход линейника! На него подавать ничего не нужно. Можно с него брать напряжение 3.3 В (потребители до 30 мА).

Микросхема BISS0001 – это т.н. PIR-контроллер. Аббревиатура PIR происходит от Passive Infra-Red, т.е. пассивный инфракрасный детектор. Дело в том, что изначально микросхема разрабатывалась как контроллер именно для инфракрасных детекторов движения.

Датчик RCWL-0516 работает на эффекте Доплера. Напомню, эффект Доплера – это изменение частоты отражённой волны при движении наблюдаемого объекта. Модуль постоянно излучает в пространство радиоволновое излучение определённой частоты (около 3150 МГц).

В случае обнаружения движения датчик выставляет на выходе OUT логическую единицу (3.3 В). Причём датчик может работать в двух режимах: перезапускаемом (retriggerable) и неперезапускаемом (non-retriggerable).

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

Режим задаётся так. Если на входе “1” микросхемы BISS0001 логическая единица – режим перезапускаемый, если логический ноль – неперезапускаемый. В данном модуле на входе “1” микросхемы 3.3 В, т.е. он работает в перезапускаемом режиме.

Для регулировки времени срабатывания триггера (времени удержания импульса на выходе OUT) служит место для конденсатора C-TM. Без установленного конденсатора время срабатывания триггера – 2 сек. Добавление ёмкости повысит длительность импульса триггера.

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

Для регулировки дальности обнаружения датчика служит место для резистора R-GN. По умолчанию датчик настроен на максимальною дистанцию обнаружения 7…9 м. Добавление резистора сопротивлением 1 МОм снизит дистанцию примерно в 1.5…2 раза.

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

А пока освещения достаточно, его сопротивление маленькое, и радиоизлучатель будет выключен. С помощью резистора на месте R-CDS можно регулировать порог срабатывания фоторезистора. Если же просто «посадить» выход CDS на землю, то датчик будет неактивен.

2описание оптопары на микросхеме tlp281-4

Рассмотрим работу оптопары на примере микросхемы TLP281, а точнее её разновидности TLP281-4. Микросхема TLP281-4 имеет 4 канала. То есть у неё есть 4 управляющих ножки и 4 выходных ножки, к которым подключается полезная нагрузка.

Будем использовать для работы модуль HW-399. Выглядит он так, как показано на иллюстрации ниже. Рядом приведена его схема.

Здесь выводы IN1…IN4 – это управляющие входные сигналы от микроконтроллера, например, Arduino, или другого управляющего элемента. На них можно подавать напряжение от 3,3 до 5 вольт. Выводы OUT1…OUT4 – выходы. Ножки HVCC и HGND – питание и земля управляемой части электрической схемы. На ножку питания HVCC можно подавать напряжение до 24 вольт.

Выводы IN1…IN4 соответствуют анодам светодиодов модуля, которые и являются источниками светового сигнала для фотокатодов модуля, которые являются электронными ключами OUT1…OUT4.

Для демонстрации работы оптопары давайте соберём схему, показанную на следующем рисунке. Здесь управлять будем одним каналом IN1 модуля HW-399 с помощью Arduino. К выходу OUT1 модуля подключим светодиод, питание на который будем подавать с отдельного источника питания (хотя можно и с самого Arduino, в данном случае это не принципиально). Подключать светодиод необходимо через токоограничивающий резистор, разумеется.

Как только мы соберём схему и подадим питание на внешнюю цепь (ножка HVCC), светодиод загорится. Это из-за того, что на управляющий пин IN1 ещё не подан управляющий сигнал. При отсутствии напряжения логической единицы на входе IN1 (допустим, он просто «висит» в воздухе или подключён к земле)

Давайте загрузим в Arduino стандартный скетч из примеров – Blink. Этот скетч каждую секунду меняет логический уровень на 13-ой ножке Arduino. Таким образом, мы наглядно увидим, как работает управление оптопарой.

Когда на 13-ом выводе Arduino высокий логический уровень – загорается встроенный светодиод платы Arduino, и отправляется управляющий сигнал на вход IN1 модуля. На выходе OUT1 появляется высокий уровень, и светодиод, подключённый к модулю, гаснет, т.к. нулевая разность потенциалов, и ток не может протекать через светодиод.

Когда на 13-ой ножке Arduino низкий уровень, то встроенный светодиод гаснет, и управляющий сигнал переключается также в низкий уровень. Из-за этого между выходом OUT1 и питанием HVCC модуля возникает разность потенциалов, и подключённый к микросхеме TLP281 светодиод загорается. Таким образом эти два светодиода будут загораться как бы в противофазе.

На приведённой осциллограмме голубой график – управляющий сигнал с пина 13 платы Arduino. А фиолетовый график – напряжение на светодиоде на 1-ом выходе модуля HW-399.

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

Мы можем подключить индикатор прямо к выводам Arduino. Для этого придётся задействовать сразу 7 ножек (или 8, если нужна десятичная точка). Обратим внимание, что индикатор 3361AS не имеет токоограничивающих резисторов. Необходимо обеспечить наличие сопротивления номиналом около 180…220 Ом на каждый вывод индикатора (т.к. питание подаём 5 В от Arduino).

Расположение выводов индикатора показано на иллюстрации:

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

Напишем скетч, который последовательно выводит числа от 0 до 9 на первом разряде индикатора.

const int A = 2;
const int B = 3;
const int C = 4;
const int D = 5;
const int E = 6;
const int F = 7;
const int G = 8;
const int DP = 9;

void setup() {
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(DP, OUTPUT);
}

void loop() {
  for (int i=0; i<=9; i  ){
    printNumber(i);
    delay(1000);
  }
}

// зажигает на 7-сегментном индикаторе заданную цифру
void printNumber(int num){
  int numbers[10][8] = { // многомерный массив, в котором описаны состояния сегментов A…G и DP для цифр от 0 до 9
    {1,1,1,1,1,1,0,0}, // 0 
    {0,1,1,0,0,0,0,0}, // 1 
    {1,1,0,1,1,0,1,0}, // 2 
    {1,1,1,1,0,0,1,0}, // 3 
    {0,1,1,0,0,1,1,0}, // 4 
    {1,0,1,1,0,1,1,0}, // 5 
    {1,0,1,1,1,1,1,0}, // 6 
    {1,1,1,0,0,0,0,0}, // 7 
    {1,1,1,1,1,1,1,0}, // 8 
    {1,1,1,1,0,1,1,0}  // 9 
  };
  lightSegments(numbers[num]);
}

// зажигает заданные сегменты
void lightSegments(int segments[]){
  digitalWrite(A, segments[0]);
  digitalWrite(B, segments[1]);
  digitalWrite(C, segments[2]);
  digitalWrite(D, segments[3]);
  digitalWrite(E, segments[4]);
  digitalWrite(F, segments[5]);
  digitalWrite(G, segments[6]);
  digitalWrite(DP, segments[7]);
}

Небольшое пояснение по поводу массива numbers[] в функции printNumber(). Этот массив состоит из 10-ти подмассивов, каждый из которых определяет одну цифру от 0 до 9. В свою очередь подмассивы состоят из 8-ми элементов, которые задают состояния сегментов от A до G и DP. Например, первый подмассив описан как {1,1,1,1,1,1,0,0} и он отвечает за вывод на индикатор нуля. Это означает, что сегменты A,B,C,D,E,F должны гореть, а сегменты G и DP – нет.

[1|1|1|1|1|1|0|0 ]
[A|B|C|D|E|F|G|DP]

В результате получаем примерно следующее:

И вот так в динамике:

Это самый простой способ управления сегментным индикатором, но, как мы видим, он задействует почти все цифровые ножки Arduino. Особенно если мы решим использовать все разряды индикатора. Тогда кроме ножек для управления сегментами придётся дополнительно использовать столько выводов, сколько разрядов у индикатора.

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

В качестве индикатора для вывода показаний компаса будем использовать семисегментный индикатор 3361AS-1. Он построен по принципу индикатора с общим катодом.

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

Напомню, что 7-сегментным индикатор называется из-за того, что он состоит из 7-ми светодиодов, которые расположены в форме цифры “8”. Зажигая определённые сегменты, можно изображать разные цифры. Это похоже на цифры индекса на почтовом конверте: закрашивая определённые участки, мы пишем разные индексы.

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

Отечественными аналогами данного преобразователя являются микросхемы серий ИД1…ИД7.

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

Индикатор 3361AS не имеет токоограничительных резисторов, поэтому необходимо озаботиться этим самому, подключая индикатор. При напряжении питания 5 В сопротивление на каждый сегмент должно быть около 200 Ом.

Желательно также подключить керамический конденсатор ёмкостью примерно 1 мкФ между землёй и питанием микросхемы CD4511.

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

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

// Выводы Arduino для управления двоичным конвертером CD4511:
const byte bit0 = 11;
const byte bit1 = 10;
const byte bit2 = 9;
const byte bit3 = 8;

// Выводы Arduino для выбора десятичных разрядов индикатора 3361AS:
const byte B_0 = 5;
const byte B_1 = 6;
const byte B_2 = 7;

#define seconds() (millis()/1000) // макрос определения секунд, прошедших с начала работы скетча

void setup()
{
  pinMode(bit0, OUTPUT);
  pinMode(bit1, OUTPUT);
  pinMode(bit2, OUTPUT);
  pinMode(bit3, OUTPUT);
  
  pinMode(B_0, OUTPUT);
  pinMode(B_1, OUTPUT);
  pinMode(B_2, OUTPUT);

  digitalWrite(B_0, HIGH);
  digitalWrite(B_1, HIGH);
  digitalWrite(B_2, HIGH);
}

void loop()
{
  // Каждую секунду увеличиваем показания индикатора на 1:
  int sec = seconds();
  for (int i=0; i<1000; i  ) {
    while (sec == seconds()) {
      printNumber(i);
    }
    sec = seconds();
  }
}

// Выводит 3-разрядное число на 7-сегментный индикатор.
void printNumber(int n) {
  setDigit(B_0, n/100); // выводим сотни десятичного числа
  setDigit(B_1, n/10 ); // выводим десятки
  setDigit(B_2, n/1  ); // выводим единицы
}

// Выводит заданное число на заданный разряд индикатора.
void setDigit(byte digit, int value) {
  digitalWrite(digit, LOW); // выбираем разряд индикатора 3361AS-1
  setNumber(value); // выводим на этот разряд число
  delay(4);
  digitalWrite(digit, HIGH); // снимаем выбор разряда индикатора
}

// Выставляет двоичный код на входе преобразователя CD4511
void setNumber(int n) {
  static const struct number {
    byte b3;
    byte b2;
    byte b1;
    byte b0;
  }
  
  numbers[] = {
    {0, 0, 0, 0}, // 0 
    {0, 0, 0, 1}, // 1 
    {0, 0, 1, 0}, // 2 
    {0, 0, 1, 1}, // 3 
    {0, 1, 0, 0}, // 4 
    {0, 1, 0, 1}, // 5 
    {0, 1, 1, 0}, // 6 
    {0, 1, 1, 1}, // 7 
    {1, 0, 0, 0}, // 8 
    {1, 0, 0, 1}, // 9 
  };

  digitalWrite(bit0, numbers[n].b0);
  digitalWrite(bit1, numbers[n].b1);
  digitalWrite(bit2, numbers[n].b2);
  digitalWrite(bit3, numbers[n].b3);
}

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

2подключение и работа радара rcwl-0516

Сначала проверим работоспособность датчика RCWL-0516 без Arduino. Для индикации подключим к выходу OUT датчика светодиод. Когда датчик будет детектировать движение, на выходе OUT будет появляться напряжение 3.3 В, и светодиод будет загораться.

А вот так это выглядит вживую:

Очевидно, что для чтения показаний датчика RCWL-0516 с помощью Arduino, достаточно прочитать логический уровень на любом входе. Например, будем использовать аналоговый вход A0. Но просто прочитать значение – слишком простая задача. Давайте будем передавать информацию о срабатывании датчика по радиоканалу на удалённое устройство.

Передатчик будет выглядеть так:

Здесь данные с выхода OUT датчика RCWL-0516 поступают на аналоговый вход A0 Arduino. А выход TX (D0) последовательного порта Arduino идёт на ножку DATA передатчика. Питается и датчик движения, и передатчик напряжением с выхода 5V Arduino.

Для устойчивости радиоканала важно, чтобы по нему постоянно передавались данные. Причём это не должны быть одни нули.

Допустим, когда датчик RCWL-0516 в состоянии ожидания, мы будем передавать по радио число 0xF0, а когда датчик фиксирует движение, будем передавать 0x0F. Когда датчик зафиксирует движение, также будем зажигать встроенный светодиод Arduino. Таким образом, скетч передатчика будет такой:

  void setup() {
  Serial.begin(9600);  
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  int val = analogRead(A0);
  if (val > 500){ // фиксация движения, на выходе HIGH
     Serial.write(0x0F);
     digitalWrite(LED_BUILTIN, HIGH);
  } 
  else { // нет движения
    Serial.write(0xF0);
    digitalWrite(LED_BUILTIN, LOW);
  }
}
    

Давайте сначала подключим приёмник к компьютеру с помощью преобразователя UART-USB и посмотрим, что вообще мы принимаем из радиоэфира (см. статью для подробностей).

Видно, что в целом мы видим то, что и хотим увидеть: числа 0x0f и 0xf0. Но встречаются и искажения информации, вызванные шумами радиоэфира, от которых придётся избавляться. Самый простой способ – брать несколько соседних значений. И если они все равны ожидаемому, то считаем это за срабатывание. Поэтому скетч для приёмника будет несколько сложнее.

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

3чтение показаний датчика тока acs712с помощью arduino

В скетче будем постоянно читать значение с порта A0 и выводить в монитор последовательных данных. Напомню, АЦП у разных плат Arduino имеет различную разрядность, обычно 10 или 12 бит. Подробнее здесь.

Это означает, что с аналогового порта могут приходить значения от 0 до 210 = 1024 для 10-разрядного АЦП. Будем считать, что у нас датчик тока, диапазон измерений которого от -5 А до 5 А, а чувствительность 185 мВ/А.

Если на 1 А приходится 185 мВ, это соответствует примерно 38 единицам измерения АЦП: 185·1024/5000 = 37.888, (1) где 5000 – это максимальное значение напряжения, которое способен измерить АЦП Arduino, в милливольтах.

На выходе OUT датчика ACS712 при отсутствии измеряемого тока должна быть половина напряжения питания, т.е. 2.5 В. Так как вся шкала АЦП лежит в диапазоне от 0 до 1024, то при отсутствии измеряемого тока мы должны считывать с аналогового порта Arduino число 512.

Это начало шкалы отсчёта. Обозначим его value_zero. Отклонение тока value_adc от нулевого уровня в большую или меньшую сторону и будет показывать силу тока. Следовательно, чтобы посчитать в амперах значение тока с датчика ACS712, необходимо разницу нулевого уровня и измеренного значения с аналогового порта A0 поделить на 38.

На практике значение на аналоговом выводе A0 не будет равняться точно 512. Поэтому, чтобы определить начало отсчёта, добавим в скетч примитивную калибровку. Калибровка будет заключаться в том, что некоторое количество раз прочитаем значение с аналогового порта A0 при отсутствии тока на датчике ACS712, и усредним его. Естественно, нагрузка на время калибровки должна быть выключена, чтобы ток не протекал через датчик.

const int acs712_pin = A0;

int zero; // уровень нуля, относительно которого измеряется ток, обычно VCC/2

void setup() {
  Serial.begin(9600);
  calibrate();
}

// определим нуль шкалы (до включения нагрузки)
void calibrate(){
  zero = 0;
  int repeats = 10;
  for (int i=0; i<repeats; i  ){
    zero  = analogRead(acs712_pin);
    delay(100);
  }
  zero /= repeats; // берём среднее арифметическое
  Serial.print("Zero=");
  Serial.println(zero);
}

void loop() {
  int sensorValue = analogRead(acs712_pin); // читаем значение с АЦП и выводим в монитор
  Serial.print(sensorValue); 
  Serial.print(" = ");
  int c = getCurrent(sensorValue); // преобразуем в значение тока и выводим в монитор
  Serial.print(c); 
  Serial.println(" mA");
  delay(100);
}

// рассчитывает ток в мА по значению с АЦП
int getCurrent(int adc) {
  int delta = zero - adc; // отклонение от нуля шкалы
  float scale = 37.888; // сколько единиц АЦП приходится на 1 ампер, по формуле (1)
  int current = (int)delta*1000/scale; // считаем ток в мА и округляем до целых, по формуле (2)
  return current;
}

Загрузим скетч и плавно начнём поднимать напряжение и ток на нагрузке. Какое-то время подождём, а затем начнём уменьшать ток. В результате получим примерно такую картинку:

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

const int acs712_pin = A0;

int zero; // уровень нуля, относительно которого измеряется ток, обычно VCC/2

void setup() {
  Serial.begin(9600);
  zero = getSmoothedValue(); // определим нуль шкалы (до включения нагрузки)
  Serial.print("Zero=");
  Serial.println(zero);
}

// получает сглаженное значение с АЦП Arduino
int getSmoothedValue(){
  int value;
  int repeats = 10;
  for (int i=0; i<repeats; i  ){ // измеряем значение несколько раз
    value  = analogRead(acs712_pin); // суммируем измеренные значения
    delay(1);
  }
  value /= repeats; // и берём среднее арифметическое
  return value;
}

void loop() {
  int sensorValue = getSmoothedValue(); // читаем значение с АЦП и выводим в монитор
  Serial.print(sensorValue); 
  Serial.print(" = ");
  int c = getCurrent(sensorValue); // преобразуем в значение тока и выводим в монитор
  Serial.print(c); 
  Serial.println(" mA");
  delay(100);
}

// рассчитывает ток в мА по значению с АЦП
int getCurrent(int adc) {
  int delta = zero - adc; // отклонение от нуля шкалы
  float scale = 37.888; // сколько единиц АЦП приходится на 1 ампер
  int current = (int)delta*1000/scale; // считаем ток в мА
  return current;
}

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

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

Тот же самый принцип заложен в библиотеки для Arduino, которые оперируют с датчиком тока ACS712. Например, вот эта библиотека Troyka Current.

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

4изучение драйвера max7219с помощью ft2232h

Но прежде чем подключать модули с MAX7219 к Arduino, попробуем поизучать их с помощью отладочной платы с микросхемой FT2232H. Она позволяет обмениваться по SPI с устройствами и не требует программирования. Все настройки делаются в программе SPI via FTDI, и для быстрого знакомства с новым устройством это очень удобно.

Для начала переведём все драйверы MAX7219 в цепочке в режим теста. Для этого необходимо в каждое из устройств в нашей цепочке передать команду 0F 01. В драйвере MAX7219 имеется сдвиговый регистр, и нам нужно «протолкнуть» команду по всем регистрам в цепочке. Чтобы команда прошла по всей цепочке, необходимо повторить её выдачу 8 раз (по числу драйверов в цепочке).

Почему команда именно такая? Смторим в документацию и видим, что адрес регистра Display Test – 0x0F. А чтобы перейти в режим теста, нужно в регистр Display Test записать 1 (см. таблицу 10 из технического описания драйвера MAX7219). В режиме теста должны загореться все светодиоды, подключённые к драйверу.

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

Кстати, если в поле количества раз поставить 8, то можно записать команду за одно нажатие на кнопку «Записать».

После включения драйвер MAX7219 переходит в режим выключения, за который отвечает регистр Shutdown (0xXC). В этом режиме единственные команды, которые мы можем послать – это переход в режим теста и выход из него. Чтобы перевести устройство в рабочий режим, нужно в регистр 0x0C записать “1” (см. таблицу 3 технического описания):

Теперь устройство готово к приёму всех команд.

Драйвер MAX7219 может работать в режиме декодирования или без него. Причём можно включать и отключать режим декодирования для каждого из разрядов дисплея (или столбцов LED матрицы) индивидуально. Давайте отключим режим декодирования. Для этого нужно послать команду 09 00 восемь раз (см.

Режим с декодированием используется, когда драйвер MAX7219 подключён к 7-сегментному индикатору. Этот режим позволяет передавать драйверу число, и он сам зажигает нужные сегменты дисплея, чтобы отобразить это число на дисплее. Но так как в нашем случае к драйверу подключена LED панель, то режим с декодированием нам не подходит.

Давайте для примера зажгём в первой строчке всех панелей убывающее число светодиодов: на первой панели в первой строчке будет гореть 8 светодиодов, на второй – 7, и так далее. Для этого мы должны так же послать 8 команд, но теперь они будут разные. За запись в первую строчку отвечает регистр Digit 0 (0x01).

    01 01 (00000001)
    01 03 (00000011)
    01 07 (00000111)
    01 0F (00001111)
    01 1F (00011111)
    01 3F (00111111)
    01 7F (01111111)
    01 FF (11111111)

Первое число – номер регистра (Digit 0), второе число – то, что мы записываем в регистр. В скобках указано двоичное представление того, что записываем в регистр. Единицы будут горящими светодиодами на LED панели, нули – потухшими.

Теперь давайте изменим яркость свечения LED панели. Для этого необходимо в регистр Intensity (0x0A) записать число от 0 до 15 (0x0F), где “0” соответствует минимальной яркости, а 0x0F – максимальной (см. таблицу 7 технического описания).

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

4управление 7-сегментным индикатором с помощью драйвера cd4511 и arduino

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

Желательно также подключить керамический конденсатор ёмкостью примерно 1 мкФ между землёй и питанием микросхемы CD4511.

Теперь напишем простой скетч, чтобы проверить работоспособность 7-сегментного индикатора 3361AS-1 в связке с двоично-десятичным декодером, а также получить опыт работы с ними. Данный скетч будет поочерёдно перебирать числа от 0 до 9, перемещаясь по циклу от одного разряда индикатора к следующему.

// выводы Arduino для управления двоичным кодом на входе декодера CD4511:
const byte D_0 = 11;
const byte D_1 = 10;
const byte D_2 = 9;
const byte D_3 = 8;

// выводы Arduino для выбора десятичного разряда индикатора:
const byte B_0 = 7;
const byte B_1 = 6;
const byte B_2 = 5;

void setup() {
  pinMode(D_0, OUTPUT);
  pinMode(D_1, OUTPUT);
  pinMode(D_2, OUTPUT);
  pinMode(D_3, OUTPUT);
  pinMode(B_0, OUTPUT);
  pinMode(B_1, OUTPUT);
  pinMode(B_2, OUTPUT);
}

void loop() {
  for (int i=0; i<3; i  ){ // перебираем разряды с 0 по 2-ой
    setDigit(i);
    for (int n=0; n<10; n  ){ // перебираем числа от 0 до 9
      printNumber(n);
      delay(200);
    }    
  }
}

// выбирает разряд десятичного числа на счётчике:
void setDigit(byte b){
  switch (b) {
    case 0:
      digitalWrite(B_0, LOW);
      digitalWrite(B_1, HIGH);
      digitalWrite(B_2, HIGH);
      break;
    case 1:
      digitalWrite(B_0, HIGH);
      digitalWrite(B_1, LOW);
      digitalWrite(B_2, HIGH);
      break;
    case 2:
      digitalWrite(B_0, HIGH);
      digitalWrite(B_1, HIGH);
      digitalWrite(B_2, LOW);
      break;
  }
}

// зажигает заданную цифру 7-сегментного индикатора
void printNumber(byte n){
  switch(n){
    case 0:
      digitalWrite(D_0, LOW);
      digitalWrite(D_1, LOW);
      digitalWrite(D_2, LOW);
      digitalWrite(D_3, LOW);
      break;
    case 1:
      digitalWrite(D_0, HIGH);
      digitalWrite(D_1, LOW);
      digitalWrite(D_2, LOW);
      digitalWrite(D_3, LOW);
      break;
    case 2:
      digitalWrite(D_0, LOW);
      digitalWrite(D_1, HIGH);
      digitalWrite(D_2, LOW);
      digitalWrite(D_3, LOW);
      break;
    case 3:
      digitalWrite(D_0, HIGH);
      digitalWrite(D_1, HIGH);
      digitalWrite(D_2, LOW);
      digitalWrite(D_3, LOW);
      break;
    case 4:
      digitalWrite(D_0, LOW);
      digitalWrite(D_1, LOW);
      digitalWrite(D_2, HIGH);
      digitalWrite(D_3, LOW);
      break;
    case 5:
      digitalWrite(D_0, HIGH);
      digitalWrite(D_1, LOW);
      digitalWrite(D_2, HIGH);
      digitalWrite(D_3, LOW);
      break;
    case 6:
      digitalWrite(D_0, LOW);
      digitalWrite(D_1, HIGH);
      digitalWrite(D_2, HIGH);
      digitalWrite(D_3, LOW);
      break;
    case 7:
      digitalWrite(D_0, HIGH);
      digitalWrite(D_1, HIGH);
      digitalWrite(D_2, HIGH);
      digitalWrite(D_3, LOW);
      break;
    case 8:
      digitalWrite(D_0, LOW);
      digitalWrite(D_1, LOW);
      digitalWrite(D_2, LOW);
      digitalWrite(D_3, HIGH);
      break;
    case 9:
      digitalWrite(D_0, HIGH);
      digitalWrite(D_1, LOW);
      digitalWrite(D_2, LOW);
      digitalWrite(D_3, HIGH);
      break;
  }
}

Загрузим скетч в Arduino и посмотрим результат.

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

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

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

Также перепишем функцию setNumber() отправки двоичного кода на вход микросхемы преобразователя CD4511. Вместо использования оператора switch, используем массив массивов.

// Выводы Arduino для управления двоичным конвертером CD4511:
const byte bit0 = 11;
const byte bit1 = 10;
const byte bit2 = 9;
const byte bit3 = 8;

// Выводы Arduino для выбора десятичных разрядов индикатора 3361AS:
const byte B_0 = 5;
const byte B_1 = 6;
const byte B_2 = 7;

#define seconds() (millis()/1000) // макрос определения секунд, прошедших с начала работы скетча

void setup()
{
  pinMode(bit0, OUTPUT);
  pinMode(bit1, OUTPUT);
  pinMode(bit2, OUTPUT);
  pinMode(bit3, OUTPUT);
  
  pinMode(B_0, OUTPUT);
  pinMode(B_1, OUTPUT);
  pinMode(B_2, OUTPUT);

  digitalWrite(B_0, HIGH);
  digitalWrite(B_1, HIGH);
  digitalWrite(B_2, HIGH);
}

void loop()
{
  // Каждую секунду увеличиваем показания индикатора на 1:
  int sec = seconds();
  for (int i=0; i<1000; i  ) {
    while (sec == seconds()) {
      printNumber(i);
    }
    sec = seconds();
  }
}

// Выводит 3-разрядное число на 7-сегментный индикатор.
void printNumber(int n) {
  setDigit(B_0, n/100); // выводим сотни десятичного числа
  setDigit(B_1, n/10 ); // выводим десятки
  setDigit(B_2, n/1  ); // выводим единицы
}

// Выводит заданное число на заданный разряд индикатора.
void setDigit(byte digit, int value) {
  digitalWrite(digit, LOW); // выбираем разряд индикатора 3361AS-1
  setNumber(value); // выводим на этот разряд число
  delay(4);
  digitalWrite(digit, HIGH); // снимаем выбор разряда индикатора
}

// Выставляет двоичный код на входе преобразователя CD4511
void setNumber(int n) {
  static const struct number {
    byte b3;
    byte b2;
    byte b1;
    byte b0;
  }
  
  numbers[] = {
    {0, 0, 0, 0}, // 0 
    {0, 0, 0, 1}, // 1 
    {0, 0, 1, 0}, // 2 
    {0, 0, 1, 1}, // 3 
    {0, 1, 0, 0}, // 4 
    {0, 1, 0, 1}, // 5 
    {0, 1, 1, 0}, // 6 
    {0, 1, 1, 1}, // 7 
    {1, 0, 0, 0}, // 8 
    {1, 0, 0, 1}, // 9 
  };

  digitalWrite(bit0, numbers[n].b0);
  digitalWrite(bit1, numbers[n].b1);
  digitalWrite(bit2, numbers[n].b2);
  digitalWrite(bit3, numbers[n].b3);
}

Получится вот такая картина.

В динамике это выглядит так. Тут как раз временами видны мерцания сегментов светодиодного индикатора.

Можно попробовать поиграть значением задержек в функции setDigit(). Если сделать задержки меньше, то мерцание станет меньше заметно. Но начнут сильнее засвечиваться соседние сегменты на выбранном разряде индикатора. Тут необходимо выбрать какое-то компромиссное решение.

6как читать данные сдатчика тока и напряжения ina219

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

Чтобы понять, что здесь происходит, необходимо познакомиться с картой регистров датчика INA219. Датчик содержит всего 6 регистров. Все регистры 16-разрядные.

Для обмена с модулем воспользуемся отладочной платой с микросхемой FT2232H и программой SPI via FTDI. Это будет проще, чем использовать Arduino, т.к. для внесения изменений в целях эксперимента не придётся каждый раз перепрограммировать ПЗУ, а можно будет вносить изменения в передаваемые команды «на лету».

Запустим программу SPI via FTDI, выберем в меню «Устройство» интерфейс I2C. Подключимся к порту A. Просканируем устройства на шине I2C. Программа найдёт устройство по адресу 64 (0x40), если конечно вы не меняли адрес перемычками A0 и A1.

Как вы уже наверное догадались, команда “0” означает адрес регистра, из которого мы хотим прочитать данные. А число 0x399F – это данные в нулевом регистре (регистр конфигурации). И это соответствует документации, т.к. после включения и загрузки микросхема INA219 имеет именно такую конфигурацию по умолчанию. Вот какую структуру имеет регистр конфигурации.

В регистре конфигурации датчика INA219 присутствуют следующие части:

• RST (reset) – сброс;
• BRNG (bus voltage range) – диапазон измерения шины;
• BADC (bus ADC resolution/averaging) – разрешающая способность АЦП шины;
• SADC (shunt ADC resolution/averaging) – разрешающая способность АЦП шунта;
• MODE – режим;
• PG – усиление и диапазон PGA.

0x399F в двоичном виде это “001_11_0011_0011_111”. Следовательно, значения по умолчанию после включения такие.

• BRNG равен “1”, что означает диапазон измерений 32 вольта FSR;
• PG равно “11”: задаёт диапазон ±320 мВ и коэффициент усиления 8;
• BADC, SADC равны “0011”: максимальная разрешающая способность АЦП – 12 бит;
• MODE, равное “111”, означает непрерывный режим работы, включены и шунт, и шина.

Для чтения других регистров необходимо сначала так же записать их адрес в поле «Чтение» «Команда», а затем прочитать 2 байта. Или можно записать номер регистра в поле «Запись» «Команда», а затем просто читать (не указывая адрес регистра в команде чтения).

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

Вернёмся к нашей осциллограмме. Мы видим на ней 6 циклов чтения (каждый начинается с зелёной точки ● и заканчивается тёмно-красной ●). Сначала читаем регистр с напряжением шунта Vшунт. (адрес 0x01), который хранит значение 0x1957.

Далее читаем значение регистра напряжения шины Vшины (0x02), в котором значение 0x19BA. Далее читаем регистр калибровки Cal (0x05) со значением 0x1000. Потом регистр тока шунта Iшунт. (0x04), в котором значение 0x1959.

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

7подключение трёхканального датчика тока и напряжения ina3221 к arduino

Датчик тока INA3221 практически идентичен датчику INA219. Основное отличие состоит в том, что он имеет 3 измерительных канала вместо одного. Показания с них можно снимать независимо друг от друга. Будем использовать вот такую небольшую плату с датчиком:

Подключается данный модуль к Arduino всего 4-мя проводами: два для питания, и ещё два – шина I2C.

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

Используем библиотеку для работы с датчиком INA3221. Поместим файлы с расширениями *.cpp и *.h в одну директорию, в ней же создадим файл с расширением *.ino и следующим содержимым:

#include "Wire.h"
#include "SDL_Arduino_INA3221.h"

SDL_Arduino_INA3221 ina3221; // создаём экземпляр класса датчика

// Три канала измерения датчика INA3221
#define CHANNEL_1 1
#define CHANNEL_2 2
#define CHANNEL_3 3

void setup(void)
{
  Serial.begin(115200);
  Serial.println("Arduino INA3221 test");
  ina3221.begin();

  Serial.print("ID=0x");
  int id = ina3221.getManufID();
  Serial.println(id, HEX);

  Serial.println("Measuring voltage and current with ina3221 ...");
}

void loop(void)
{
  Serial.println("---------------------------------------------");
  Serial.println("Channel:tt(1)t(2)t(3)t"); // "t" - это символ табуляции

  // Вывод напряжений по трём каналам:
  Serial.print("Bus voltage, V: t");
  float busvoltage1 = ina3221.getBusVoltage_V(CHANNEL_1);
  float busvoltage2 = ina3221.getBusVoltage_V(CHANNEL_2);
  float busvoltage3 = ina3221.getBusVoltage_V(CHANNEL_3);
  Serial.print(busvoltage1); Serial.print("t");
  Serial.print(busvoltage2); Serial.print("t");
  Serial.print(busvoltage3); Serial.println("t");

  // Вывод напряжений на шунте по трём каналам:
  Serial.print("Shunt voltage, mV: t");
  float shuntvoltage1 = ina3221.getShuntVoltage_mV(CHANNEL_1);
  float shuntvoltage2 = ina3221.getShuntVoltage_mV(CHANNEL_2);
  float shuntvoltage3 = ina3221.getShuntVoltage_mV(CHANNEL_3);
  Serial.print(shuntvoltage1); Serial.print("t");
  Serial.print(shuntvoltage2); Serial.print("t");
  Serial.print(shuntvoltage3); Serial.println("t");

  // Вывод напряжений нагрузки по трём каналам:
  Serial.print("Load voltage, V: t");
  float loadvoltage1 = busvoltage1   (shuntvoltage1 / 1000);
  float loadvoltage2 = busvoltage2   (shuntvoltage2 / 1000);
  float loadvoltage3 = busvoltage3   (shuntvoltage3 / 1000);
  Serial.print(loadvoltage1); Serial.print("t");
  Serial.print(loadvoltage2); Serial.print("t");
  Serial.print(loadvoltage3); Serial.println("t");

  // Вывод тока по трём каналам:
  Serial.print("Current, mA: tt");
  float current_mA1 = ina3221.getCurrent_mA(CHANNEL_1);
  float current_mA2 = ina3221.getCurrent_mA(CHANNEL_2);
  float current_mA3 = ina3221.getCurrent_mA(CHANNEL_3);
  Serial.print(current_mA1); Serial.print("t");
  Serial.print(current_mA2); Serial.print("t");
  Serial.print(current_mA3); Serial.println("t");

  delay(2000);
}

Загрузим данный скетч в память Arduino. Перед тем как подключать нагрузку, необходимо подать с источника питания напряжение на контакты POW и GND, расположенные с одного из краёв модуля. Это напряжение будет подаваться на нагрузку и оно в данном модуле общее для всех трёх измерительных каналов. Допустимый диапазон напряжений от 0 до 26 вольт. Я сейчас подам 5 В.

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

Теперь можно подключать нагрузку. Давайте нагрузим выходы модуля и посмотрим, что будет выводиться в монитор последовательного порта. Я подключу на канал 1 два параллельных резистора номиналом 4,3 кОм, что в сумме даст сопротивление 2,15 кОм. А на канал 3 – один резистор 4,3 кОм.

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

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

Подключение гироскопа mpu6050 к arduino: схема и программа