Raspberry pi i2c python

Raspberry Pi. Работаем с I2C на Python

Наконец-то появилось немного свободного времени и я решил более тщательно поковырять порты GPIO у Raspberry Pi. Если хочется просто подрыгать ногами, помигать светодиодами или пообмениваться данными через уарт, то это достаточно просто и в сети полно мануалов, хотя если кому надо, пишите, проведу небольшой ликбез. Я же решил сразу поиграться с шиной I2C и подключить к Raspberry Pi микромеханический трехосный акселерометр MMA7455 (в свое время купил на ебее уже распаянный на платке с выведенными нужными ногами на штыри, цена вопроса 7-10 баксов).

Итак, сначала подключим акс к плате:

В качестве рабочего дистрибутива ОС я использую Raspbian, поскольку его рекомендуют сами разработчики платы и в нем есть все необходимые драйвера, правда сразу все не заработает. Для начала необходимо убрать модуль I2C из блэклиста и добавить его в автозагрузку. Для этого делаем в консоли следующее, открываем файл raspi-blacklist.conf и видим в нем следующее:

Закоментируем две строчки и сохраним файл:

ПРИМЕЧАНИЕ: Все действия я провожу через SSH, поэтому не использую графические утилиты, в редакторе nano для сохранения файла необходимо нажать Ctrl-O, для выхода — Ctrl-Х.

Далее добавляем модуль I2C в автозагрузку, открываем файл /etc/modules

и добавляем в конец строку i2c-dev, должно получиться так:

После перезагрузки проверяем появилось ли нужное устройство в системе:

Если в ответ на эту команду мы получили:

значит все прошло успешно.
Теперь необходимо поставить некоторые дополнительные пакеты:

Теперь, при подключенном акселерометре, выполним команду:

и увидим табличку в которой отобразится адрес подключенного устройства, в случае MMA7455 — 1D, что соответствует даташиту.

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

и вставляем нижеприведенный листинг

Результат работы (запускать sudo python mma7455.py)

На этом пока все, если что не понятно — спрашивайте.

Источник

Raspberry Pi. Настройка и использование шины I2C.

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

Итак, возьмем какое-нибудь устройство, работающее по I2C и подключим его к Raspberry Pi. У меня под рукой обнаружилась такая плата с 9-осевым датчиком MPU-9250:

Вполне подойдет для экспериментов. Естественно, выбор именно этого устройства не накладывает никаких ограничений на работу с шиной. То есть все, что мы сегодня разберем на примере MPU-9250 актуально и для любых других устройств, подключенных по I2C.

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

При работе с I2C обязательно нужны подтягивающие резисторы, которые подтягивают линии SDA и SCL к напряжению питания:

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

Включение I2C на Raspberry Pi.

Первым делом нам следует включить интерфейс I2C. Для этого воспользуемся утилитой для конфигурации Raspberry Pi — raspi-config. Вводим в терминале команду:

Далее переходим в пункт Interfacing options и включаем I2C:

После этого необходимо перезапустить плату:

Альтернативным способом включения I2C является редактирование файла /boot/config.txt. В файле находим и раскомментируем строку:

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

Работа с I2C через консоль.

Для I2C, как и для других модулей платы, существуют разные варианты и методы использования. И начнем мы с применения команд непосредственно в консоли, в чем нам поможет пакет i2c-tools. Устанавливаем командой:

После успешной установки мы можем использовать команду i2cdetect для просмотра доступных шин I2C:

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

Из вывода команды следует, что у нас активирована шина i2c-1, которую мы и будем использовать. Для новых версий плат Raspberry Pi всегда по умолчанию используется именно i2c-1. Для более старых же модификаций, например Raspberry Pi Model B с оперативной памятью 256 МБ, будет использована шина i2c-0.

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

Цифра 1 здесь как раз и относится к тому, что мы будем работать с шиной i2c-1. Кроме того, используем ключ -y. По умолчанию команда i2cdetect ожидает подтверждения от пользователя прежде, чем вмешиваться в работу шины, а ключом -y мы даем ей добро на работу с I2C без дополнительного разрешения.

Итак, вывод этой команды может быть таким:

Здесь мы видим все подключенные к I2C устройства и их адреса. Поскольку я подключил датчик MPU-9250, адрес которого — 0x68, то его мы тут и обнаружили:

Кроме того, пакет i2c-tools включает в себя ряд других команд для работы с шиной, в частности:

  • i2cdump — позволяет прочитать значения всех регистров подключенного к шине устройства. Например:

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

  • i2cget — чтение значения конкретного регистра определенного устройства. Конечно, же рассмотрим пример:

Считываем значение все того же регистра с адресом 0x75 и проверяем, верное ли значение выдает команда:

  • i2cset — запись определенного значения в регистр устройства. И снова не обходимся без примера:

Здесь мы последовательно указываем — номер шины, адрес устройства, адрес регистра и значение, которое будет записано в этот регистр. В данном случае записываем в регистр с адресом 0x1A значение 0x03.

На этом завершаем работу с I2C через консоль, мы рассмотрели все основные и необходимые операции и переходим к работе с I2C при помощи Python.

Работа с I2C на Python.

Для работы с шиной I2C необходимо установить пакет python-smbus:

По традиционной схеме создаем файл, в котором и будем писать код для работы с I2C, назовем файл, к примеру, i2c_test.py. Ну и для наглядной демонстрации прочитаем значение все того же регистра с адресом 0x75 и сравним результаты. Собственно, пишем минимально необходимый для этого код:

Давайте разберем, что тут происходит, поэтапно. Делаем import библиотеки:

Открываем использующуюся у нас шину i2c-1:

И, наконец, читаем значение регистра, выводим его на экран и заканчиваем работу с I2C:

Первый аргумент функции — адрес устройства, второй — адрес регистра. Запускаем выполнение кода:

И в результате видим верное значение регистра:

А это говорит нам о том, что код сработал абсолютно верно. Напоследок, рассмотрим некоторые другие функции библиотеки smbus, которые можно использовать по своему усмотрению:

Функция Описание
long read_byte(int addr) Чтение байта данных
long write_byte(int addr, char val) Запись байта данных
long read_byte_data(int addr, char cmd) Чтение значения регистра
long write_byte_data(int addr, char cmd, char val) Запись значения в регистр
long[] read_block_data(int addr, char cmd) Чтение блока данных (до 32-х байт) из регистра
write_block_data(int addr, char cmd, long vals[]) Запись блока данных в регистр
long read_word_data(int addr, char cmd) Чтение слова (2-х байт) из регистра
long write_word_data(int addr, char cmd, int val) Запись слова (2-х байт) в регистр

На этом заканчиваем обзор работы с шиной I2C для Raspberry Pi, на очереди — интерфейс SPI, который будем запускать в следующей статье.

Источник

Raspberry pi i2c python

Copy raw contents

Copy raw contents

Using ControlEverything products with Raspberry Pi over I2C

In this article we will connect a ControlEverything relay controller to the Raspberry Pi.

What we will accomplish

  • We will explore the I2C protocol which is used to interact with ControlEverything Peripheral hardware connected to the Raspberry Pi.
  • We will use i2c-tools which is a linux command line tool used for discovering and interacting with I2C devices connected to the Raspberry Pi
  • Finally we will write a couple of simple Python applications which will control the relay on the ControlEverything board.

Purpose of Article

The purpose of this article is to get you familiar with communicating to ControlEverything hardware attached to the Raspberry Pi.

Hardware used in this article

  • [Raspberry Pi 3 with Raspbian image] [pi]
  • [ControlEverything Pi interface sheild] [piShield]
  • [ControlEverything I2C Relay Controller] [relayController]
  • [12VDC power supply for relay controller] [12vdcPower]
  • USB micro power supply for powering Raspberry Pi.

The Raspberry Pi we are using is a Raspberry Pi 3. We have the Raspbian image installed on the Pi used in this article. If you have a different version of the Pi or a different Linux image installed your results may vary. Just google setting up I2C on your particular Raspberry Pi setup.

I am using TightVNCServer to remotely access the Pi’s desktop from my Mac. If you find that interesting I highly recommend [this great article] [tightvncarticle].

We have accompanying videos for this article on a Youtube Playlist [Here] [youtubeplaylist]

ControlEverything designs and develops peripheral products for the IOT platform market. Our products are proven reliable and we are very excited to support Raspberry Pi. For more information on ControlEverything please visit www.controleverything.com

How to use this library

The libary can be imported into an existing application or you can simply use our example code. This can be done through the Particle WEB IDE(Build). Click the Community Libraries Icon and search for SI7020-A20_CE. Once found select that library. Click Include in App button to add it to an existing application or simply click the Use this example button to use our example code. If you are adding this library to an existing application select the App you want to include the library in. Finally click Add to this app. For more information see [Particles’s documentation] [sparkIncludeLibrary]

Chapter 1 Initial configuration of the Pi

For all intents and purposes this is a brand new fresh Raspberry Pi with Raspbian just installed.
Before we can interface with I2C devices connected to the Pi Raspbian requires that we enable the I2C port on the ARM processor. To do that open the terminal on the Pi and enter:

A window will appear where you can access system level settings on the Pi. Scroll down the list to Advanced Options and select it. On the next window scroll down to I2C and select it. When prompted to enable the I2C interface select yes. On the next prompt select OK. On the next prompt(Would you like the I2C kernel module to be loaded by default?) select Yes. Then select OK. Finally back at the main window hit the right arrow button on your keyboard to select Finish. When prompted to reboot say Yes. The Pi will now reboot. Once it boots back up we will have access to the I2C port.

Chapter 2 i2c-tools

i2c-tools is an extremely usefull diagnostics tool that I would not recommend any developer to be without when using ControlEverything products on a Linux based computing platform such as the Raspberry Pi. So lets install it. Open up the Terminal.

If you have not done so in a while, or ever, it would be a good idea to go ahead and update the Linux Package Installer by entering in the terminal:

Once apt-get is up to date enter in the terminal:

Say yes to any prompts that may appear.

We will use i2c-tools to scan for connected devices first so make sure your ControlEverything device is properly connected to the Raspberry Pi and is powered up. In the terminal enter:

The 1 in the command above specifies I2C bus 1. To my knowledge Raspbian only supports 1 I2C bus and it is bus 1. That is important information to have in the future of this article. Now hopefully you will see a device detected on the port. My relay controller has a default I2C address of 0x20 and I do not have any Address jumpers installed so it pops up in i2cdetect as 20 so I know it is properly connected and ready to use.

I2C Device Addressing

Lets take a brief moment to talk about I2C device bus addressing.

An I2C bus should consist of a Master device and one or more connected slave devices. In this case the Raspberry Pi is acting as the I2C bus Master device and the relay controller is acting as an I2C slave device connected to that bus.

I2C slave devices have an address byte which is how the master individually communicates with them. The valid range for this I2C device bus address is 0-127 or 0x00-0x7F. My particular device(relay controller) is using address 0x20 but I could change that using the on board address jumpers. There can only be one slave on the bus using a particular address. You do not want 2 slave devices on the bus using the same address. This means if I wanted to add a second relay controller I would want to be sure to set it’s address to something other than 0x20 by using the on board address jumpers.

Another thing to note is that while valid I2C bus addresses are 0-127 not all I2C devices support setting the address to any value from 0-127. This relay controller for instance has only 3 address jumpers which allows me to set the address to 0x20 — 0x28 This means I can only have up to 8 of these devices on a single I2C bus. If more of the same device need to be connected it is possible to use an I2C bus multiplexer which takes that single I2C bus and splits it into multiple individual busses, but that is an article for another day.

We could spend hours talking about this.

Reading and writing to I2C slave devices

I2C slave devices are relatively simple things. They have a group of registers each of which hold a single byte. We can read a byte from a register or write a byte to a register. Everything that we accomplish using I2C connected devices is done in this way. By writing to registers you can modify the configuration settings for the device or make it to something. By reading from a register you can get sensor readings, device status, or check settings stored in the device. For simplicities sake that’s about it. Once again we could talk about this for hours.

Enough Jargen already lets do something!

First we need to know a little about the device we are interacting with and what is required to accomplish what we are trying to do. In my case I have a single relay board. To get information about how to control it I could pull up it’s product page on ControlEverything and look at the code samples. There I will see the I2C write and read commands used for interacting with the controller. There I find that there is a single configuration command that needs to be written to the controller first thing. This command sets all IO lines of the device to outputs(we need that if we want to turn the relay on and off) so lets use i2c-tools to set that configuration byte. In the terminal enter:

  • i2cset is the command to write to an i2c slave device on the bus.
  • The -y is a command flag that answers an annoying are you sure prompt prior to sending the command
  • 0x20 indicates the I2C device on the bus we are directing this write command to. In this case it is my 1 channel relay controller
  • 0x00 indicates the register on that device which I am writing a value to. Register 0x00 is a configuration register in this devices which sets the direction of the 8 IO lines.
  • 0x00 indicates the byte I wish to write to the register. This will set all IO lines on this device to outputs.

Now that the lines are set as outputs I can write commands to turn the relays on and off. The output registers on this device are set through register 0x09. A write to this register will set the status of all outputs on the device. Lets turn on the relay. In the terminal enter:

This command writes a value of 0xFF to register 0x09 which essentially turns on all output lines on the chip. Inversely we can turn all outputs off with this command:

So using i2c-tools we were able to detect the devices address on the port and then configure and control it all from the terminal with no code development required. This is fantastic for experineting and getting familiar with your particular I2C device.

It’s also possible to read from an I2C device but for simplicity’s sake we will save that for a future article.

Chapter 3 Python

So now we know our controller is properly connected to the Pi and works. We also know what commands to send to do what we want. Lets write a Python script for fun.

Now Python needs a way of interacting with devices on the Pi’s I2C port. Luckley there is a very simple to use Python Package that allows for that. It’s called SMBus. Lets install that now. In the terminal enter:

That’s it. We are ready to write our Python application. Now I could sit here and write a book or I could just tell you to have a look at the Python examples in the Python Scripts folder on this Repo so that’s what I’ll do. The scripts in there are very simple and self explanitory. With the knowledge you have gained so far you will be able to completely determine what is going on in that code.

If you have any questions be sure you watch all the videos in the [YouTube Playlist] [youtubeplaylist] which serve to accompany this article. I do everything in those videos I do here in the article so you can see in realtime how this all comes together.

Источник

Adblock
detector