КОРЗИНА
магазина
8 (499) 500-14-56 | ПН. - ПТ. 12:00-18:00
ЛЕСНОРЯДСКИЙ ПЕРЕУЛОК, 18С2, БЦ "ДМ-ПРЕСС"

Программная установка адресов модулей FLASH-I2C

Общие сведения:

Все модули серии «Flash» позволяют назначать себе адрес для шины I2C, который сохраняется в энергонезависимую память и действует даже после отключения питания. По умолчанию все модули серии «Flash» поставляются с адресом 0x09. Допускается указывать адреса в диапазоне: 7 < адрес < 127. Протокол шины I2C не допускает наличие устройств с одинаковым адресом.

Для работы с модулями серии «Flash» используются библиотеки. В каждой библиотеке предусмотрен метод смены адреса changeAddress(), но он будет работать только с тем модулем, для которого написана библиотека. Например библиотека iarduino_I2C_Bumper может изменить адрес модуля Бампер, а библиотека iarduino_I2C_Encoder изменить адрес модуля энкодер, но не наоборот.

Изменить адрес любого I2C модуля серии «Flash» можно аппаратно, используя установщик адресов FLASH-I2C, или программно, используя библиотеку смены адресов iarduino_I2C_Address.

Примеры:

В данном разделе раскрыты примеры изменения адреса при использовании библиотеки iarduino_I2C_Address. Сама библиотека содержит больше примеров, доступных из меню Arduino IDE: Файл / Примеры / iarduino_I2C_Address.

Смена адреса одного модуля на шине I2C:

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

uint8_t newAddress = 0x09;                        // Назначаемый модулю адрес (0x07 < адрес < 0x7F).
                                                  //
#include <Wire.h>                                 // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
#include <iarduino_I2C_Address.h>                 // Подключаем библиотеку для работы с адресами модулей линейки I2C-flash.
iarduino_I2C_Address j;                           // Объявляем объект j для работы с модулем I2C-flash. Адрес модуля будет определен автоматически.
                                                  // Если адрес модуля известен, то его можно указать при создании объекта, например, iarduino_I2C_Address j(0xA0);
void setup(){                                     //
     Serial.begin(9600);                          // Инициируем передачу данных по шине UART на скорости 9600 бит/сек.
     j.begin(&Wire); // &Wire1, &Wire2 ...        // Начинаем работу с модулем, указав на какой шине I2C он находится (по умолчанию &Wire).
     if(!j){ Serial.print("Модуль не найден"); }  //
     while(!j){;}                                 // Запрещаем дальнейшую работу если модуль не обнаружен.
     Serial.print("Найден модуль 0x");            //
     Serial.println( j, HEX );                    // Выводим текущий адрес модуля.
     j=newAddress;                                // Меняем адрес модуля на newAddress.
     if(j==newAddress){                           // Проверяем новый адрес модуля.
         Serial.println("Адрес модуля изменён");  // Успех записи нового адреса можно проверить по результату присвоения: if( j=newAddress ){/*успешно*/;}else{/*провал*/;}
     }                                            // 
     Serial.print("Текущий адрес модуля 0x");     //
     Serial.println( j, HEX );                    //   Выводим текущий адрес модуля.
}                                                 //
                                                  //
void loop(){                                      //
}                                                 //

Для работы данного примера, на шине I2C должен быть только один модуль.

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

В примере проверка нового адреса выполнена после его присвоения, но эту проверку можно выполнить непосредственно в момент присвоения if( j=newAddress ){ /* Успех */; }.

Смена адресов нескольких модулей:

Пример меняет адреса нескольких модулей сразу. Модулям с адресами 0xAB и 0xCD назначаются адреса 0x10 и 0x11 соответственно. На шине могут присутствовать и иные модули, адреса которых отличаются от указанных.

#include <Wire.h>                                 // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
#include <iarduino_I2C_Address.h>                 // Подключаем библиотеку для работы с адресами модулей линейки I2C-flash.
iarduino_I2C_Address j[]={0xAB, 0xCD};            // Определяем массив объектов, указав текущие адреса модулей I2C-flash на шине I2C.
                                                  // 
void setup(){                                     //
     Serial.begin(9600);                          // Инициируем передачу данных по шине UART на скорости 9600 бит/сек.
//   Начинаем работу с модулями:                  // Указанные действия можно выполнить в цикле (см. пример ниже).
     j[0].begin(&Wire); // &Wire1, &Wire2 ...     // Начинаем работу с первым модулем, указав на какой шине I2C он находится (по умолчанию &Wire).
     j[1].begin(&Wire); // &Wire1, &Wire2 ...     // Начинаем работу с вторым модулем, указав на какой шине I2C он находится (по умолчанию &Wire).
//   if( j[0].begin(&Wire) ){/*присутствует*/;}   // Начало работы с проверкой. В данном случае проверка будет пройдена если на шине Wire имеется модуль I2C-flash с адресом 0xAB.
//   if( j[1].begin(&Wire) ){/*присутствует*/;}   // Начало работы с проверкой. В данном случае проверка будет пройдена если на шине Wire имеется модуль I2C-flash с адресом 0xCD.
//   Выводим старые адреса модулей на шине I2C:   // Указанные действия можно выполнить в цикле.
     Serial.println("Найдены модули:");           //
     if( j[0] ){ Serial.println( j[0] ); }        // Если модуль с адресом 0xAB не обнаружен, то условие if( j[0] ) не будет выполнено.
     if( j[1] ){ Serial.println( j[1] ); }        // Если модуль с адресом 0xCD не обнаружен, то условие if( j[1] ) не будет выполнено.
//   Указываем новые адреса модулям:              // Указанные действия можно выполнить в цикле.
     Serial.println("Меняем адреса модулей...");  // Важно назначать адреса, которых ещё нет на шине I2C!!!
     j[0] = 0x10;                                 // Успех записи нового адреса можно проверить по результату присвоения:    if( j[0]= 0x10 ){/*успешно*/;}else{/*провал*/;}
     j[1] = 0x11;                                 // Успех записи нового адреса можно проверить после присвоения: j[1]=0x11; if( j[1]==0x11 ){/*успешно*/;}else{/*провал*/;}
//   Выводим адреса модулей на шине I2C:          // Указанные действия можно выполнить в цикле.
     Serial.println("Новые адреса модулей:");     //
     if( j[0] ){ Serial.println( j[0] ); }        //
     if( j[1] ){ Serial.println( j[1] ); }        //
}                                                 //
                                                  //
void loop(){                                      //
}                                                 //

Для работы данного примера, на шине I2C должны присутствовать модули с адресами указанными при определении массива объектов j, в данном случае, адреса: 0xAB и 0xCD.

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

Если объявить массив объектов без указания адресов, например, iarduino_I2C_Address j[2]; то адреса будут определены автоматически. Нулевой элемент массива объектов будет работать с модулем имеющем наименьший адрес и далее по возрастанию.

Количество элементов массива j может отличаться от количества модулей на шине I2C.

  • Если у массива j больше элементов чем модулей на шине, то «лишние» элементы массива не пройдут инициализацию j[n].begin(&Wire) и не пройдут проверку if( j[n] ), но при этом все устройства будут обнаружены, а их адреса доступны для изменения из массива.
  • Если у массива j меньше элементов чем модулей на шине, то «лишние» модули не будут обнаружены, а их адреса не будут доступны для изменения из массива.

Автоматическая сортировка адресов всех модулей:

Пример находит все модули на шине и автоматически меняет адреса устройств Flash I2C. Новые адреса устройств будут идти по порядку начиная с адреса в константе start.

Важной особенностью этого примера является то, что функция sorting() способна обнаружить все устройства Flash I2C, в т.ч. и с одинаковыми адресами, и назначить каждому устройству новый уникальный адрес. Предположим, если на шине находится 5 устройств Flash I2C, неважно какие у них адреса, допустим у всех устройств адрес 0x09, то после выполнения скетча, на шине будут 5 устройств с адресами: 0x60, 0x61, 0x62, 0x63, 0x64.

const uint8_t start = 0x60;                       // Первый адрес создаваемого списка новых адресов для модулей Flash I2C.
                                                  //
#include <Wire.h>                                 // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
#include <iarduino_I2C_Address.h>                 // Подключаем библиотеку для работы с адресами модулей линейки I2C-flash.
iarduino_I2C_SortAddress k;                       // Объявляем объект (k) для сортировки адресов.
                                                  // 
void setup(){                                     //
//   Подготовка:                                  //
     Serial.begin(9600);                          // Инициируем передачу данных по шине UART на скорости 9600 бит/сек.
     k.begin(&Wire); // &Wire1, &Wire2 ...        // Указываем объекту k на какой шине I2C проводить сортировку адресов (по умолчанию &Wire).
//   Выполняем сортировку адресов:                //
     Serial.print("Сортировка... ");              //
     bool i = k.sorting(start);                   // Если адреса уже отсортированы, то функция вернёт false.
     if(i){ Serial.println("выполнена!"   ); }    //
     else { Serial.println("не требуется."); }    //
}                                                 //
                                                  //
void loop(){                                      //
}                                                 //

В этом примере объект k создан как экземпляр класса iarduino_I2C_SortAddress, в отличии от предыдущих примеров, где объект j создан как экземпляр класса iarduino_I2C_Address.

Объект k имеет только две функции:

  • Функция begin() принимает ссылку на объект работы с шиной I2C: &Wire, &Wite1, &Wire2...
  • функция sorting() выполняет сортировку, принимая адрес который станет первым в списке новых адресов.

Но объект k не умеет работать с устройствами и выводить их адреса, как мы делали в предыдущих примерах, по этому в следующем примере создадим объекты обоих классов и не только отсортируем устройства, но и выведем их адреса...

Автоматическая сортировка и вывод адресов:

Значение константы sum определяет количество элементов массива j, а следовательно, количество занимаемой памяти. Значение sum должно быть равно или больше чем реальное количество модулей на шине I2C.

const uint8_t sum   = 10;                         // Количество объектов. Должно быть равно или больше реального количества модулей на шине I2C.
const uint8_t start = 0x60;                       // Первый адрес создаваемого списка новых адресов для модулей Flash I2C.
                                                  //
#include <Wire.h>                                 // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
#include <iarduino_I2C_Address.h>                 // Подключаем библиотеку для работы с адресами модулей линейки I2C-flash.
iarduino_I2C_Address j[sum];                      // Объявляем массив объектов (j), указав их количество (sum). Адреса модулей будут определены автоматически.
iarduino_I2C_SortAddress k;                       // Объявляем объект (k) для сортировки адресов.
                                                  // 
void setup(){                                     //
//   Подготовка:                                  //
     Serial.begin(9600);                          // Инициируем передачу данных по шине UART на скорости 9600 бит/сек.
     k.begin(&Wire); // &Wire1, &Wire2 ...        // Указываем объекту k ссылку на шину I2C, где требуется произвести сортировку адресов.
     uint8_t i;                                   //
//   Начинаем работу с модулями:                  //
     for(i=0; i<sum; i++){ j[i].begin(&Wire); }   // Если очередной модуль обнаружен на шине Wire, то функция begin вернёт true.
//   Выводим адреса найденных модулей:            //
     Serial.println("Найдены модули:");           //
     for(i=0; i<sum; i++){                        // Вместо цикла for() можно воспользоваться циклом while( j[i] ){ ... i++; }
         if( j[i] ){                              // Если модуль не существует, то j[i] вернёт false.
             Serial.print((String)(i+1)+".) 0x"); // Выводим порядковый номер модуля.
             Serial.println( j[i], HEX );         // Выводим адрес модуля на шине I2C.
         }                                        //
     }                                            //
//   Выполняем сортировку адресов:                //
     Serial.print("Сортировка... ");              //
     i = k.sorting(start);                        // Если адреса уже отсортированы, то функция sorting() вернёт false.
     if(i){ Serial.println("выполнена!"   ); }    //
     else { Serial.println("не требуется."); }    //
//   Повторно начинаем работать с модулями:       //
     for(i=0; i<sum; i++){ j[i].begin(&Wire); }   // Если очередной модуль обнаружен на шине Wire, то функция begin вернёт true.
//   Выводим адреса найденных модулей:            //
     Serial.println("Найдены модули:");           //
     for(i=0; i<sum; i++){                        // Вместо цикла for() можно воспользоваться циклом while( j[i] ){ ... i++; }
         if( j[i] ){                              // Если модуль не существует, то j[i] вернёт false.
             Serial.print((String)(i+1)+".) 0x"); // Выводим порядковый номер модуля.
             Serial.println( j[i], HEX );         // Выводим адрес модуля на шине I2C.
         }                                        //
     }                                            //
}                                                 //
void loop(){}                                     //

В этом примере массив объектов j создан от класса iarduino_I2C_Address, каждый элемент этого массива работает с одним модулем, адрес которого был обнаружен функцией begin(). В то время как объект k создан как экземпляр класса iarduino_I2C_SortAddress, он предназначен только для автоматической сортировки всех адресов. Для объекта k так же вызывается функция begin() которая получает ссылку на используемую шину I2C, но ничего не возвращает.

Код функции setup() разделён на 4 части: подготовка, начало работы с модулями и вывод их изначальных адресов на экран, сортировка, повторное начало работы с модулями и вывод их адресов на экран уже после сортировки.

В этом примере выведены только адреса устройств Flash I2C, но есть возможность вывести и более подробную информацию о устройствах Flash I2C, как в следующем примере...

Вывод подробной информации о всех модулях:

Значение константы sum определяет количество элементов массива j, а следовательно, количество занимаемой памяти. Значение sum должно быть равно или больше чем реальное количество модулей на шине I2C.

const uint8_t sum   = 10;                            // Количество объектов. Должно быть равно или больше реального количества модулей на шине I2C.
                                                     //
#include <Wire.h>                                    // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
#include <iarduino_I2C_Address.h>                    // Подключаем библиотеку для работы с адресами модулей линейки I2C-flash.
iarduino_I2C_Address j[sum];                         // Объявляем массив объектов (j), указав их количество (sum). Адреса модулей будут определены автоматически.
                                                     // 
void setup(){                                        //
// Подготовка:                                       //
   Serial.begin(9600);                               // Инициируем передачу данных по шине UART на скорости 9600 бит/сек.
   uint8_t i;                                        //
// Проходим по всем элементам массива j:             //
   for(i=0; i<sum; i++){                             //
   // Начинаем работу с модулем:                     //
      if( j[i].begin(&Wire) ){                       // Если очередной модуль обнаружен на шине Wire, то функция begin вернёт true.
      // Выводим информацию о модуле:                //
         Serial.print((String)(i+1)+".) 0x");        // Выводим порядковый номер модуля.
         Serial.print( j[i], HEX );                  // Выводим адрес модуля на шине I2C.
         if(j[i].getDevice()==DEVICE_I2C_FLASH || j[i].getDevice()==DEVICE_I2C_FLASH_OLD){
            Serial.print(F(" Модуль Flash I2C «"));  //
            Serial.print(j[i].getName());            // Выводим название модуля. Будет пустым если модуль DEVICE_I2C_FLASH_OLD.
            Serial.print(F("»"));                    //
            Serial.print(F(", модель 0x"));          //
            Serial.print(j[i].getModel(),HEX);       // Выводим номер модели (идентификатор устройства).
            Serial.print(F(", версия "));            //
            Serial.print(j[i].getVersion());         // Выводим версию прошивки модуля.
            Serial.print(F(", подтяжка линий ") );   //
            Serial.print(j[i].getPullI2C()?"в":"от");// Выводим состояние внутрисхемной подтяжки линий шины I2C.
            Serial.print(F("ключена"));              //
         }else                                       //
         if(j[i].getDevice()==DEVICE_I2C_UNKNOWN){   //
            Serial.print(F("Неизвестный модуль"));   //
         }else                                       //
         if(j[i].getDevice()==DEVICE_I2C_DOUBLE){    //
            Serial.print(F(" адрес принадлежит"));   //
            Serial.print(F(" двум и более модулям"));//
         }                                           //
         Serial.println('.');                        //
      }                                              //
   }                                                 //
}                                                    //
                                                     //
void loop(){                                         //
}                                                    //

В этом примере выводятся адреса всех устройств обнаруженных на шине I2C, но не более чем указано в константе sum. Если найденное устройство принадлежит семейству Flash I2C то для него выводится название, номер модели, версия прошивки и состояние внутрисхемной подтяжки линий шины I2C. Для остальных устройств будет выведена строка "Неизвестный модуль". Если на одном адресе обнаружено несколько устройств из линейки Flash I2C, то для этого адреса будет выведена строка "адрес принадлежит двум и более модулям".

Описание функций библиотеки:

В данном разделе описаны функции библиотеки iarduino_I2C_Address для работы с модулями серии Flash-I2C.

Данная библиотека может использовать как аппаратную, так и программную реализацию шины I2C. О том как выбрать тип шины I2C рассказано в статье Wiki - расширенные возможности библиотек iarduino для шины I2C.

Подключение библиотеки:

  • Если адрес модуля известен (в примере используется адрес 0x09):
#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
                                         // Вместо библиотеки Wire.h можно подключить библиотеку iarduino_I2C_Software.h для работы с программной шиной I2C.
#include <iarduino_I2C_Address.h>        // Подключаем библиотеку.
iarduino_I2C_Address obj(0x09);          // Создаём объект obj указав адрес модуля на шине I2C.
  • Если адрес модуля неизвестен (адрес будет найден автоматически):
#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
                                         // Вместо библиотеки Wire.h можно подключить библиотеку iarduino_I2C_Software.h для работы с программной шиной I2C.
#include <iarduino_I2C_Address.h>        // Подключаем библиотеку.
iarduino_I2C_Address obj;                // Создаём объект obj без указания адреса.
  • Если адреса модулей известны (в примере используются адреса 0x0A, 0x0B, 0x0C):
#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
                                         // Вместо библиотеки Wire.h можно подключить библиотеку iarduino_I2C_Software.h для работы с программной шиной I2C.
#include <iarduino_I2C_Address.h>        // Подключаем библиотеку.
iarduino_I2C_Address obj[]={0x0A,0x0B,0x0C}; // Создаём массив объектов указав текущие адреса модулей на шине I2C.
  • Если адреса модулей неизвестны (адреса будут найдены автоматически):
#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
                                         // Вместо библиотеки Wire.h можно подключить библиотеку iarduino_I2C_Software.h для работы с программной шиной I2C.
#include <iarduino_I2C_Address.h>        // Подключаем библиотеку.
iarduino_I2C_Address obj[3];             // Создаём массив объектов obj указав количество модулей.
  • Если требуется выполнить автоматическую сортировку адресов модулей Flash I2C:
#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
                                         // Вместо библиотеки Wire.h можно подключить библиотеку iarduino_I2C_Software.h для работы с программной шиной I2C.
#include <iarduino_I2C_Address.h>        // Подключаем библиотеку.
iarduino_I2C_SortAddress all;            // Объявляем объект all для сортировки адресов.
  • Если требуется выполнить сортировку и работать с модулями:
#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_I2C_Address.
                                         // Вместо библиотеки Wire.h можно подключить библиотеку iarduino_I2C_Software.h для работы с программной шиной I2C.
#include <iarduino_I2C_Address.h>        // Подключаем библиотеку.
iarduino_I2C_SortAddress all;            // Объявляем объект all для сортировки адресов.
iarduino_I2C_Address obj[3];             // Создаём массив объектов obj указав количество модулей.

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

Создание объекта как экземпляра класса iarduino_I2C_SortAddress позволяет использовать только две функции: begin() для выбора шины I2C на которой требуется выполнить сортировку и sorting() для выполнения сортировки адресов сразу всех устройств Flash I2C.

Функция begin();

  • Назначение: Указание шины I2C на которой нужно выполнить автоматическую сортировку.
  • Класс: iarduino_I2C_SortAddress.
  • Синтаксис: begin( [ &ШИНА ] );
  • Параметры:
    • &ШИНА - Ссылка на объект для работы с шиной I2C на которой находятся модули.
      • Для аппаратной шины: &Wire, &Wire1, &Wire2..., если подключена библиотека Wire.h
      • Для программной шины: ссылка на объект библиотеки iarduino_I2C_Software.h.
      • Параметр является не обязательным, по умолчанию используется ссылка &Wire.
  • Возвращаемое значение: Нет.
  • Примечание:
    • Функцию достаточно вызвать однократно, но обязательно до обращения к функции sorting().
  • Пример:
all.begin();       // Использовать аппаратную шину I2C по умолчанию.
all.begin(&Wire);  // Использовать основную аппаратную шину I2C.
all.begin(&Wire1); // Использовать первую аппаратную шину I2C.

Функция begin();

  • Назначение: Начало работы с модулем.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: begin( [ &ШИНА ] );
  • Параметры:
    • &ШИНА - Ссылка на объект для работы с шиной I2C на которой находится модуль.
      • Для аппаратной шины: &Wire, &Wire1, &Wire2..., если подключена библиотека Wire.h
      • Для программной шины: ссылка на объект библиотеки iarduino_I2C_Software.h.
      • Параметр является не обязательным, по умолчанию используется ссылка &Wire.
  • Возвращаемое значение: bool - результат обнаружения модуля (true или false).
  • Примечание:
    • По результату обнаружения модуля можно определить наличие модуля на шине.
    • Функцию достаточно вызвать однократно, но обязательно до обращения к любым другим функциям объекта библиотеки.
  • Пример:
if( obj.begin() ){ Serial.print( "Модуль обнаружен!" ); }
else             { Serial.print( "Модуль не найден!" ); }

Функция sorting();

  • Назначение: Автоматическая сортировка адресов всех устройств Flash I2C.
  • Класс: iarduino_I2C_SortAddress.
  • Синтаксис: sorting( АДРЕС );
  • Параметры:
    • uint8_t АДРЕС - первый адрес из списка создаваемых адресов.
  • Возвращаемое значение: bool - результат изменения адресов (true или false).
  • Примечание:
    • Функция меняет адреса всех устройств Flash I2C.
    • Новые адреса устройств будут идти по порядку начиная с указанного.
    • Если текущие адреса устройств не требуют сортировки (уже идут по порядку начиная с указанного), то функция не будет менять адреса и вернёт false.
    • Если на шине есть устройства Flash I2C с одинаковыми адресами, функция найдет каждое устройство и назначит им новый уникальный адрес.
    • Допускается наличие на шине устройств не из линейки Flash I2C (их адрес не меняется).
    • Устройства DEVICE_I2C_FLASH_OLD не поддерживают автоматическую сортировку.
  • Пример:
if( all.sorting() ){ Serial.print( "Сортировка выполнена!" ); }
else               { Serial.print( "Сортировка не требуется." ); }

Оператор присвоения адреса

  • Назначение: Смена адреса модуля на шине I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: ОБЪЕКТ = АДРЕС.
  • Параметры: Нет.
  • Возвращаемое значение: bool - результат сохранения нового адреса (true или false).
  • Примечание:
    • Вместо оператора «=» можно использовать функцию changeAddress().
    • Синтаксис функции changeAddress() указан в разделе дополнительные функции.
  • Пример:
obj = 50; // Присвоение модулю адреса 50 без проверки сохранения адреса в модуль.
if( obj = 25 ){ Serial.print( "Присвоение адреса 25 с проверкой сохранения" ); }

Оператор получения адреса

  • Назначение: Запрос текущего адреса модуля на шине I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: ПЕРЕМЕННАЯ = ОБЪЕКТ.
  • Параметры: Нет.
  • Возвращаемое значение: uint8_t - текущий адрес модуля.
  • Примечание:
    • Вместо оператора «=» можно использовать функцию getAddress().
    • Синтаксис функции getAddress() указан в разделе дополнительные функции.
  • Пример:
uint8_t i = obj; // Получение текущего адреса модуля в переменную i.
Serial.print( "Адрес модуля = " );
Serial.print( i );

Операторы сравнения адреса

  • Назначение: Сравнение текущего адреса модуля на шине I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: Как у любого оператора сравнения.
  • Параметры: Нет.
  • Возвращаемое значение: bool - результат сравнения.
  • Примечание:
    • Операторы сравнения можно использовать с функцией getAddress().
    • Синтаксис функции getAddress() указан в разделе дополнительные функции.
  • Пример:
if( obj <  25 ){ Serial.println( "Адрес модуля меньше 25" ); }
if( obj == 25 ){ Serial.println( "Адрес модуля равен  25" ); }
if( obj >  25 ){ Serial.println( "Адрес модуля больше 25" ); }

Дополнительные функции библиотеки:

Дополнительные функции позволяют получать информацию о модулях Flash-I2C.

Функция getDevice();

  • Назначение: Запрос принадлежности устройства к линейке Flash I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: getDevice();
  • Параметры: Нет.
  • Возвращаемое значение: uint8_t ТИП - 1 из 5 значений:
    • DEVICE_I2C_ABSENT - устройство отсутствует на шине (не найдено).
    • DEVICE_I2C_UNKNOWN - неизвестное устройство (стороннее).
    • DEVICE_I2C_DOUBLE - адрес занят двумя и более устройствами.
    • DEVICE_I2C_FLASH - устройство принадлежит линейке Flash I2C.
    • DEVICE_I2C_FLASH_OLD - устройство Flash I2C без поддержки вывода названия и сортировки адреса.
  • Пример:
if( obj.getDevice()==DEVICE_I2C_DOUBLE ){ Serial.println("На шине есть устройства с одинаковыми адресами."); }

Функция reset();

  • Назначение: Перезагрузка модуля.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: reset();
  • Параметры: Нет.
  • Возвращаемое значение: bool - результат перезагрузки (true или false).
  • Пример:
if( obj.reset() ){ Serial.print( "Модуль    перезагружен" ); }
else             { Serial.print( "Модуль не перезагружен" ); }

Функция changeAddress();

  • Назначение: Смена адреса модуля на шине I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: changeAddress( АДРЕС );
  • Параметры:
    • uint8_t АДРЕС - новый адрес модуля на шине I2C (целое число от 0x08 до 0x7E)
  • Возвращаемое значение: bool - результат смены адреса (true или false).
  • Примечание: Вместо функции changeAddress() можно использовать оператор «=».
  • Пример:
if( obj.changeAddress(0x12) ){ Serial.print( "Адрес модуля изменён на 0x12" ); }
else                         { Serial.print( "Не удалось изменить адрес"    ); }

Функция getAddress();

  • Назначение: Запрос текущего адреса модуля на шине I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: getAddress();
  • Параметры: Нет.
  • Возвращаемое значение: uint8_t АДРЕС - текущий адрес модуля на шине I2C (от 0x08 до 0x7E)
  • Примечание: Вместо функции getAddress() можно использовать оператор «=».
  • Пример:
Serial.print( "Адрес модуля на шине I2C = 0x");
Serial.println( obj.getAddress(), HEX );

Функция getVersion();

  • Назначение: Запрос версии прошивки модуля.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: getVersion();
  • Параметры: Нет
  • Возвращаемое значение: uint8_t ВЕРСИЯ - номер версии прошивки от 0 до 255.
  • Пример:
Serial.print( "Версия прошивки модуля ");
Serial.println( obj.getVersion(), HEX );

Функция getModel();

  • Назначение: Запрос типа модуля.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: getModel();
  • Параметры: Нет.
  • Возвращаемое значение: uint8_t МОДЕЛЬ - идентификатор модуля от 0 до 255.
  • Примечание: По идентификатору можно определить тип модуля.
  • Пример:
switch( obj.getModel() ){
  case 1: Serial.print( "I2C Кнопка"    ); break;
  case 2: Serial.print( "I2C Светодиод" ); break;
  case 3: Serial.print( "I2C Резистор"  ); break;
  case 4: Serial.print( "I2C Зуммер"    ); break;
  ...
}

Функция getName();

  • Назначение: Запрос названия модуля.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: getName();
  • Параметры: Нет
  • Возвращаемое значение: String НАЗВАНИЕ - от 0 до 255 символов.
  • Примечание:
    • Название возвращается в кодировке UTF-8.
    • В названии модулей допускается наличие символов Кириллицы.
    • Если модуль не поддерживает вывод названия, то функция вернёт пустую строку.
    • Проверить поддержку вывода названия можно функцией getDevice().
    • Вывод названия поддерживают только устройства DEVICE_I2C_FLASH.
  • Пример:
Serial.print( "Название модуля: ");
Serial.println( obj.getName() );
  • Пример с проверкой поддержки модулем вывода своего названия:
switch( obj.getDevice() ){
  case DEVICE_I2C_FLASH:     Serial.print( (String) "Название модуля: " + obj.getName() ); break;
  case DEVICE_I2C_FLASH_OLD: Serial.print( (String) "Названия нет, но модель: " + obj.getModel() ); break;
  default:                   Serial.print( "Название и модель модуля неизвестны"); break;
}

Функция setPullI2C();

  • Назначение: Управление внутрисхемной подтяжкой линий шины I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: setPullI2C( [ФЛАГ] );
  • Параметры:
    • bool ФЛАГ требующий установить внутрисхемную подтяжку линий шины I2C (true или false).
  • Возвращаемое значение:
    • bool - результат включения / отключения внутрисхемной подтяжки (true или false).
  • Примечание:
    • Вызов функции без параметра равносилен вызову функции с параметром true - установить.
    • Флаг установки внутрисхемной подтяжки сохраняется в энергонезависимую память модуля, а значит будет действовать и после отключения питания.
    • Внутрисхемная подтяжка линий шины I2C осуществляется до уровня 3,3 В, но допускает устанавливать внешние подтягивающие резисторы и иные модули с подтяжкой до уровня 3,3 В или 5 В, вне зависимости от состояния внутрисхемной подтяжки модуля.
  • Пример:
if( obj.setPullI2C(true ) ){ Serial.print( "Внутрисхемная подтяжка установлена." ); }
if( obj.setPullI2C(false) ){ Serial.print( "Внутрисхемная подтяжка отключена."   ); }

Функция getPullI2C();

  • Назначение: Запрос состояния внутрисхемной подтяжки линий шины I2C.
  • Класс: iarduino_I2C_Address.
  • Синтаксис: getPullI2C();
  • Параметры: Нет.
  • Возвращаемое значение: bool - ФЛАГ включения внутрисхемной подтяжки (true или false).
  • Пример:
if( obj.getPullI2C() ){ Serial.print( "Внутрисхемная подтяжка включена."  ); }
else                  { Serial.print( "Внутрисхемная подтяжка отключена." ); }

Ссылки:




Обсуждение

Гарантии и возврат Используя сайт Вы соглашаетесь с условями