MicroPython:Библиотеки/machine/Класс I2C: различия между версиями

Материал из Онлайн справочника
Перейти к навигацииПерейти к поиску
Нет описания правки
Нет описания правки
 
(не показаны 3 промежуточные версии 1 участника)
Строка 14: Строка 14:
Пример использования:
Пример использования:


<syntaxhighlight lang="python" enclose="div">
<syntaxhighlight lang="python">
from machine import I2C
from machine import I2C


Строка 50: Строка 50:
== Конструкторы ==
== Конструкторы ==


* [[MicroPython:Библиотеки/machine/Класс I2C/machine.I2C()|machine.I2C(]]
* [[MicroPython:Библиотеки/machine/Класс I2C/machine.I2C()|machine.I2C()]]
 
==Общие методы==
 
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.init()|I2C.init()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.deinit()|I2C.deinit()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.scan()|I2C.scan()]]
 
==Примитивные I2C-операции==


• Класс machine.I2C(id=- 1, *, scl, sda, freq=400000) – конструирует и возвращает новый объект I2C при помощи следующих аргументов:
o id – идентификатор периферийного I2C-устройства. Значение по умолчанию – это «-1», и если оставить его, будет задействована программная I2C-шина, контакты SCL и SDA которой можно задать (в большинстве случаев) на всех контактах устройства. Если в id задано «-1», то в последующих аргументах также надо задать scl и sda. Другие допустимые значения для id зависят от используемого порта/платы, и в этом случае использование аргументов scl и sda может не потребоваться (или может быть даже не разрешено).
o scl – это должен быть объект Pin, обозначающий контакт SCL.
o sda – это должен быть объект Pin, обозначающий контакт SDA.
o freq – это должно быть целое число, задающее максимальную частоту для SCL-линии.
Общие методы
• I2C.init(scl, sda, *, freq=400000) – инициализирует I2C-шину при помощи следующих аргументов:
o scl – объект Pin для SCL-линии.
o sda – объект Pin для SDA-линии.
o freq – тактовая частота SCL-линии.
• I2C.deinit() – выключает I2C-шину.
Доступность: WiPy.
• I2C.scan() – сканирует все I2C-адреса в диапазоне между «0x08» и «0x77» (включительно) и возвращает список ответивших устройств. Устройство считается ответившим, если оно задало SDL-линии значение LOW после того, как ее адрес (включая бит записи) был отправлен по шине.
Примитивные I2C-операции
В методах ниже реализованы примитивные I2C-операции для ведущего устройства (мастера), и их совместное использование позволяет выполнить любую I2C-транзакцию. Они нужны на тот случай, если вам нужно больше контроля над I2C-шиной; в противном случае вам подойдут и стандартные методы (см. ниже).
В методах ниже реализованы примитивные I2C-операции для ведущего устройства (мастера), и их совместное использование позволяет выполнить любую I2C-транзакцию. Они нужны на тот случай, если вам нужно больше контроля над I2C-шиной; в противном случае вам подойдут и стандартные методы (см. ниже).
Эти методы доступны только при использовании программной I2C-шины.
Эти методы доступны только при использовании программной I2C-шины.
• I2C.start() – генерирует на шине состояние START (если на SCL-линии значение HIGH, на SDA-линии будет выполнен переход с HIGH на LOW).
 
• I2C.stop() – генерирует на шине состояние STOP (если на SCL-линии значение HIGH, на SDA-линии будет выполнен переход с LOW на HIGH).
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.start()|I2C.start()]]
• I2C.readinto(buf, nack=True, /) – считывает байты с шины и сохраняет их в буфер buf. Количество считанных байтов будет равно размеру буфера buf. При получении всех байтов, кроме последнего, по шине будет отправлено «ACK». Если последний байт будет отправлен и nack равно True, то будет отправлено «NACK»; в противном случае будет отправлено «ACK» (и это будет значить, что по мнению ведомого устройства, при следующем вызове будут считана новая порция байтов).
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.stop()|I2C.stop()]]
• I2C.write(buf) – записывает байты из буфера buf на шину. После каждого байта проверяет, не было ли прислано «ACK», а при получении «NACK» останавливает передачу оставшихся байтов. Возвращает количество полученных «ACK».
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.readinto()|I2C.readinto()]]
Стандартные операции на шине I2C
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.write()|I2C.write()]]
 
==Стандартные операции на шине I2C==
 
В методах ниже реализованы стандартные I2C-операции чтения/записи ведущего устройства (мастера) с заданным ведомым устройством.
В методах ниже реализованы стандартные I2C-операции чтения/записи ведущего устройства (мастера) с заданным ведомым устройством.
• I2C.readfrom(addr, nbytes, stop=True, /) – считывает количество байтов nbytes с ведомого устройства, заданного в аргументе addr. Если в аргументе stop задано True, то в конце операции будет сгенерировано состояние STOP. Возвращает объект bytes, содержащий считанные данные.
• I2C.readfrom_into(addr, buf, stop=True, /) – считывает данные в буфер buf с ведомого устройства, заданного в аргументе addr. Количество считанных байтов будет равняться размеру буфера buf. Если в аргументе stop будет задано True, то в конце операции будет сгенерировано состояние STOP. Возвращает None.
• I2C.writeto(addr, buf, stop=True, /) – записывает байты из буфера buf на ведомое устройство, заданное в аргументе addr. Если после записи байта из буфера buf будет получено «NACK», то оставшиеся байты отправлены не будут. Если в аргументе stop будет задано True, то в конце операции будет сгенерировано состояние STOP (даже если будет получено «NACK»). Возвращает количество полученных «ACK».
• I2C.writevto(addr, vector, stop=True, /) – записывает байты из vector на ведомое устройство, заданное в аргументе addr. Значение в аргументе vector должно быть кортежем или списком объектов с буферным протоколом. Сначала один раз передается addr, а затем друг за другом записываются байты из каждого объекта, находящегося в vector. Объекты в vector могут быть размером в 0 байтов, и в этом случае они никак не будут участвовать в выводе данных.
Если после записи байта из одного из объектов в vector будет получено «NACK», тогда оставшиеся байты и все оставшиеся объекты отправлены не будут. Если в аргументе stop будет задано True, то в конце операции будет сгенерировано состояние STOP – даже если будет получено «NACK». Функция возвращает количество полученных «ACK».
Операции с памятью
Некоторые I2C-устройства работают как запоминающие устройства (или наборы регистров), с которыми можно осуществлять операции чтения/записи. В этом случае в I2C-операции будет участвовать 2 адреса: адрес ведомого устройства и адрес памяти. Методы ниже – это удобные функции для коммуникации с такими устройствами.
• I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8) – считывает nbytes байтов с ведомого устройства, заданного в аргументе addr, начиная с адреса памяти, заданного в аргументе memaddr. В аргументе addrsize задается размер адреса в битах. Возвращает объект bytes, содержащий прочитанные данные.
• I2C.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8) – считывает данные в буфер buf с ведомого устройства, заданного в аргументе addr, начиная с адреса памяти, заданного в аргументе memaddr. Количество считанных байтов определяется размером буфера buf. В аргументе addrsize задается размер адреса в битах (на ESP8266 этот аргумент не распознается, а размер адреса всегда равен 8 битам).
Метод возвращает None.
• I2C.writeto_mem(addr, memaddr, buf, *, addrsize=8) – записывает данные из буфера buf на ведомое устройство, заданное в аргументе addr, начиная с адреса памяти, заданного в аргументе memaddr. Значение в аргументе addrsize определяет размер адреса в битах (на ESP8266 этот аргумент не распознается, а размер адреса всегда равен 8 битам).
Метод возвращает None.


* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.readfrom()|I2C.readfrom()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.readfrom_into()|I2C.readfrom_into()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.writeto()|I2C.writeto()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.writevto()|I2C.writevto()]]
==Операции с памятью==


Некоторые I2C-устройства работают как запоминающие устройства (или наборы регистров), с которыми можно осуществлять операции чтения/записи. В этом случае в I2C-операции будет участвовать 2 адреса: адрес ведомого устройства и адрес памяти. Методы ниже – это удобные функции для коммуникации с такими устройствами.


<syntaxhighlight lang="python" enclose="div">
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.readfrom_mem()|I2C.readfrom_mem()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.readfrom_mem_into()|I2C.readfrom_mem_into()]]
* [[MicroPython:Библиотеки/machine/Класс I2C/I2C.writeto_mem()|I2C.writeto_mem()]]


=См.также=
=См.также=

Текущая версия от 19:52, 23 мая 2023

Перевод: Максим Кузьмин
Проверка/Оформление/Редактирование: Мякишев Е.А.


Класс I2C – протокол для передачи последовательных данных по 2 линиям[1]

I2C – это 2-проводной протокол для коммуникации между устройствами. На физическом уровне он состоит из 2 проводов: SCL и SDA – для тактового сигнала и передачи данных.

Объекты I2C при создании привязываются к заданной I2C-шине. Их можно инициализировать при создании или позже.

Печать объекта I2C показывает информацию о его настройках.

Пример использования: 

from machine import I2C

i2c = I2C(freq=400000)          # Создаем I2C-шину, работающую 
                                # на частоте 400 КГц.
                                # Некоторым портам требуются
                                # дополнительные параметры для
                                # выбора периферийного нужного 
                                # устройства и/или контактов.

i2c.scan()                      # Делаем сканирование, чтобы
                                # найти ведомые устройства.
                                # Этот метод вернет список
                                # 7-битных адресов.

i2c.writeto(42, b'123')         # Записываем 3 байта 
                                # на ведомое устройство 
                                # с 7-битным адресом «42».

i2c.readfrom(42, 4)             # Считываем 4 байта 
                                # с ведомого устройства
                                # с 7-битным адресом «42».

i2c.readfrom_mem(42, 8, 3)      # Считываем 3 байта из памяти 
                                # ведомого устройства с адресом «42»,
                                # начиная с адреса в памяти «8»
                                # на ведомом устройстве.

i2c.writeto_mem(42, 2, b'\x10') # Записываем 1 байт на память 
                                # ведомого устройства с адресом «42»,
                                # начиная с адреса в памяти «2»
                                # на ведомом устройстве.

Конструкторы

Общие методы

Примитивные I2C-операции

В методах ниже реализованы примитивные I2C-операции для ведущего устройства (мастера), и их совместное использование позволяет выполнить любую I2C-транзакцию. Они нужны на тот случай, если вам нужно больше контроля над I2C-шиной; в противном случае вам подойдут и стандартные методы (см. ниже).

Эти методы доступны только при использовании программной I2C-шины.

Стандартные операции на шине I2C

В методах ниже реализованы стандартные I2C-операции чтения/записи ведущего устройства (мастера) с заданным ведомым устройством.

Операции с памятью

Некоторые I2C-устройства работают как запоминающие устройства (или наборы регистров), с которыми можно осуществлять операции чтения/записи. В этом случае в I2C-операции будет участвовать 2 адреса: адрес ведомого устройства и адрес памяти. Методы ниже – это удобные функции для коммуникации с такими устройствами.

См.также

Партнерские ресурсы
Криптовалюты
Магазины
Хостинг
Разное

Внешние ссылки

  1. ↑ docs.micropython.org - class I2C – a two-wire serial protocol
Источник — http://wikihandbk.com/ruwiki/index.php?title=MicroPython:Библиотеки/machine/Класс_I2C&oldid=7738181