{"id":5908,"date":"2019-04-20T10:41:17","date_gmt":"2019-04-20T14:41:17","guid":{"rendered":"https:\/\/dronebotworkshop.com\/?p=5908"},"modified":"2023-04-12T11:36:38","modified_gmt":"2023-04-12T15:36:38","slug":"i2c-part-2-build-i2c-sensor","status":"publish","type":"post","link":"https:\/\/dronebotworkshop.com\/i2c-part-2-build-i2c-sensor\/","title":{"rendered":"I2C Part 2 &#8211; Build an I2C Sensor"},"content":{"rendered":"\n<p><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-9571 size-full alignnone\" title=\"Download PDF\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2023\/04\/dbws-pdfdown.png?resize=64%2C64&#038;ssl=1\" alt=\"Download PDF\" width=\"64\" height=\"64\" data-recalc-dims=\"1\" \/> <a href=\"#Parts_List\"><img loading=\"lazy\" decoding=\"async\" class=\"alignnone wp-image-9563 size-full\" title=\"Parts List\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2023\/04\/dbws-parts.png?resize=64%2C64&#038;ssl=1\" alt=\"Parts List\" width=\"64\" height=\"64\" data-recalc-dims=\"1\" \/><\/a> <a href=\"https:\/\/youtu.be\/yBgikWNoU9o\" target=\"_blank\" rel=\"noopener\"><img loading=\"lazy\" decoding=\"async\" class=\"alignnone wp-image-9565 size-full\" title=\"View on YouTube\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2023\/04\/dbws-youtube.png?resize=64%2C64&#038;ssl=1\" alt=\"View on YouTube\" width=\"64\" height=\"64\" data-recalc-dims=\"1\" \/><\/a> <a href=\"https:\/\/s3.amazonaws.com\/download.dronebotworkshop.com\/I2C+Sensor+-+Dronebot+Workshop.zip\"><img loading=\"lazy\" decoding=\"async\" class=\"alignnone wp-image-9569 size-full\" title=\"Download Code\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2023\/04\/dbws-codedown.png?resize=64%2C64&#038;ssl=1\" alt=\"Download Code\" width=\"64\" height=\"64\" data-recalc-dims=\"1\" \/><\/a><\/p>\n<h2><span style=\"font-weight: 400;\">Introduction<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">In the <a href=\"https:\/\/dronebotworkshop.com\/i2c-arduino-arduino\/\">first part of the series on using I2C<\/a> we discussed what I2C is and how it is implemented. \u00a0We also hooked up a couple of Arduino&#8217;s and sent data between them using I2C and the Arduino Wire Library.<\/span><\/p>\n<div class=\"youtube-player\" data-id=\"yBgikWNoU9o\"><\/div>\n<p><span style=\"font-weight: 400;\">Today we will continue the discussion about I2C. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">We will look into the protocol that I2C uses to transfer data and to establish slave addresses. We will also build our own I2C sensor.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Let\u2019s get started!<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">Inside I2C<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">As you\u2019ll recall from the last article and video, I2C is a method of exchanging data between integrated circuits, sensors, microcomputers and microcontrollers. It uses two wires for communications and another two for power and ground.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5893\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Build-I2C-Sensor.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"Build a I2C Sensor\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Build-I2C-Sensor.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Build-I2C-Sensor.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">The two communications connections are as follows:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><b>SDA<\/b><span style=\"font-weight: 400;\"> &#8211; This is the serial data line. I2C is a unidirectional system, so data can only travel in one direction at any given moment.<\/span><\/li>\n<li style=\"font-weight: 400;\"><b>SCL<\/b><span style=\"font-weight: 400;\"> &#8211; The clock signal, which synchronizes the data.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">I2C works on the principle of Masters and Slaves, the Master provides the clock signal and orchestrates all of the communications. Only one device can be master at any given moment, there can be several Slaves.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">I2C Addressing<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Every I2C Slave has an address that is unique on the I2C bus. \u00a0Masters do not have addresses. The address is used by the Master to communicate with a Slave, one device at a time.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Most I2C devices use a 7-bit addressing scheme, some newer devices use a 10-bit address. <\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5894\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Address-Format.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Address Format\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Address-Format.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Address-Format.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">In the more common 7-bit addressing system the lower bit (bit 0) is used to determine if the master wants to send data to the slave or read data from the slave.<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">If Bit 0 is HIGH then the master is requesting to read data from the slave.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">If Boit 0 is LOW then the master is going to write data to the slave.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">The remaining 7-bits are the I2C address of the slave that the master wants to communicate with.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">Reserved Addresses<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Using 7-bits for addressing will, in theory, allow a maximum of 128 addresses. Probably more than you\u2019ll need for your project.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">However, that isn\u2019t actually true.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">There are really \u201conly\u201d 112 addresses available on an I2C bus, as there are several reserved addresses. A couple of these addresses are used by the Master when making a call to all I2C devices, one is used to change into 10-bit addressing mode and several are reserved for future purposes.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The <\/span><a href=\"https:\/\/www.i2c-bus.org\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">I2C Bus Organization<\/span><\/a><span style=\"font-weight: 400;\"> has provided the date for the following table. If you are building an I2C device you should avoid these addresses, as they are reserved:<\/span><\/p>\n<table style=\"height: 307px;\" width=\"768\">\n<tbody>\n<tr style=\"background-color: #6495ed; color: #ffffff;\">\n<td><span style=\"font-weight: 400;\">Address in Binary, MSB on the left<\/span><\/td>\n<td><span style=\"font-weight: 400;\">Purpose<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">0000000 0<\/span><\/td>\n<td><a href=\"https:\/\/www.i2c-bus.org\/addressing\/general-call-address\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">General Call<\/span><\/a><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">0000000 1<\/span><\/td>\n<td><a href=\"https:\/\/www.i2c-bus.org\/addressing\/start-byte\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Start Byte<\/span><\/a><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">0000001 X<\/span><\/td>\n<td><a href=\"https:\/\/www.i2c-bus.org\/addressing\/cbus-addresses\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">CBUS Addresses<\/span><\/a><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">0000010 X<\/span><\/td>\n<td><a href=\"https:\/\/www.i2c-bus.org\/addressing\/different-bus-formats\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Reserved for Different Bus Formats<\/span><\/a><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">0000011 X<\/span><\/td>\n<td><span style=\"font-weight: 400;\">Reserved for future purposes<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">00001XX X<\/span><\/td>\n<td><a href=\"https:\/\/www.i2c-bus.org\/addressing\/high-speed\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">High-Speed Master Code<\/span><\/a><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">11110XX X<\/span><\/td>\n<td><a href=\"https:\/\/www.i2c-bus.org\/addressing\/10-bit-addressing\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">10-bit Slave Addressing<\/span><\/a><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400;\">11111XX X<\/span><\/td>\n<td><span style=\"font-weight: 400;\">Reserved for future purposes<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3><span style=\"font-weight: 400;\">Assigned Addresses<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">In addition to the reserved addresses, you need to avoid using the address of another I2C device that is used on your I2C bus implementation.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Usually, this is just a matter of determining what addresses are in use, what ones you might possibly use in the future and then just picking an address for your home-brew device that doesn\u2019t conflict.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">If, however, you are creating an I2C device that will be used by other people then address selection becomes a bit more challenging.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">If you are building a commercial product then the I2C Bus Committee at NXP can assign you an address, for a fee. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">Otherwise for hobby and non-profit projects you are pretty well on your own.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Oddly enough, there is no \u201cmaster list\u201d of I2C bus assignments. The closest thing I have been able to find is <\/span><a href=\"https:\/\/www.i2c-bus.org\/addressing\/10-bit-addressing\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Adafruit\u2019s I2C Address Compilation<\/span><\/a><span style=\"font-weight: 400;\">.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">I2C Protocol<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">As I\u2019ve already mentioned, the Master device initiates the communications and supplies the clock signal. It is not possible for a Slave device to initiate communications, it needs to wait until it is called by the Master.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The sequence of communications is as follows:<\/span><\/p>\n<h4><span style=\"font-weight: 400;\">Normal State<\/span><\/h4>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5900\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Normal-State.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol Normal State\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Normal-State.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Normal-State.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">When the I2C bus is idle both the SDA (data) and SCL (clock) lines are held HIGH by the Master.<\/span><\/p>\n<h4><span style=\"font-weight: 400;\">Start Condition<\/span><\/h4>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5901\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Start-Condition-1.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol Start Condition 1\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Start-Condition-1.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Start-Condition-1.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">In order the begin exchanging data the Master puts the bus into Start Condition. It signifies this by changing the state of the DSDA line from HIGH to LOW. At this point, the SCL line is still held HIGH.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5902\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Start-Condition-2.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol Start Condition 2\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Start-Condition-2.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Start-Condition-2.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">In the second phase of the Start Condition, the SCL line drops LOW. The SDA line now transmits the first byte of data, which is the beginning of the address.<\/span><\/p>\n<h4><span style=\"font-weight: 400;\">Address Sent<\/span><\/h4>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5896\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Address-Sent.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol Address Sent\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Address-Sent.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Address-Sent.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">The Address is sent and is received by all of the attached slaves. It can be one of two types of addresses:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">A General Call (all zeros), which is a broadcast message to all of the slave devices.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">A specific slave address.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">The first bit of the address byte is examined to see if the master is about to send data or if it is requesting data. This will determine the source of data for the next several operations.<\/span><\/p>\n<h4><span style=\"font-weight: 400;\">Sending Data<\/span><\/h4>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5898\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-First-Data-Byte-Sent.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol First Data Byte Sent\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-First-Data-Byte-Sent.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-First-Data-Byte-Sent.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">The data is now transferred on the I2C bus, it\u2019s origin depends upon the previous address byte.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5899\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-More-Data-Sent.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol More Data Sent\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-More-Data-Sent.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-More-Data-Sent.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">This may be one or many bytes of data sent, these bytes are synchronized by the clock signal provided by the Master on the SCL line.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5897\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Final-Data-Sent.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol Final Data Sent\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Final-Data-Sent.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Final-Data-Sent.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">The last byte of data is no different than the previous bytes. If the slave is sending data them the Master should have already determined how much data it expects, so it knows when it is the last byte. The number of bytes will vary depending upon the slave device.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">After the last byte is sent the SDA line will be held LOW.<\/span><\/p>\n<h4><span style=\"font-weight: 400;\">Stop Condition<\/span><\/h4>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5903\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Stop-Condition.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Protocol Stop Condition\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Stop-Condition.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Protocol-Stop-Condition.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">The final stage is the Stop Condition. This is signified by the SDA line transitioning from LOW to HIGH, the opposite sequence from the Start Condition. \u00a0The SCL clock line will go HIGH. <\/span><\/p>\n<h2><span style=\"font-weight: 400;\">Ultrasonic Sensor Array<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">Now let\u2019s construct our own I2C sensor device.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We are going to construct an I2C ultrasonic distance sensor. This is not by itself unique, as there are commercial I2C ultrasonic distance sensors available, such as the <\/span><a href=\"https:\/\/www.dfrobot.com\/product-1057.html?tracking=585c2ddea9c83\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">URM07 from dfRobot<\/span><\/a><span style=\"font-weight: 400;\">. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">What is unique about our sensor is that it won\u2019t just consist of one sensor, it will have four of them. You could use this device to measure the distance to the four corners of the room.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Our sensor will be accurate to a distance of 254 cm and will have a 1 cm resolution.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">I\u2019m going to build the sensor on a breadboard using an Arduino Uno, however in a \u201creal life\u201d application I would use a smaller Arduino, like the <\/span><a href=\"https:\/\/dronebotworkshop.com\/arduino-pro-mini\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Arduino Pro Mini,<\/span><\/a><span style=\"font-weight: 400;\"> or an <\/span><a href=\"https:\/\/dronebotworkshop.com\/arduino-uno-atmega328\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">ATmega328 chip<\/span><\/a><span style=\"font-weight: 400;\">.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">HC-SR04 Ultrasonic Sensor<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Our sensor will make use of the popular HC-SR04 ultrasonic sensors. \u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">These devices are inexpensive and easily obtained through just about any electronics parts store. They are reasonably accurate and have become a staple in robotics projects.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">As with most ultrasonic sensors, the HC-SR04 consists of a transmitter and receiver. The transmitter sends pulses of ultrasonic sound towards the target, and the receiver picks up the reflected signal.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">As the pulses travel at the speed of sound it is just a matter of measuring the time delay between sending and receiving the pulse. This can be used to calculate the distance.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">If you want to really learn everything about using the HC-SR04 with an Arduino you can check out the article and video I did on this sensor a while back &#8211; <\/span><a href=\"https:\/\/dronebotworkshop.com\/hc-sr04-ultrasonic-distance-sensor-arduino\/\"><span style=\"font-weight: 400;\">Using the HC-SR04 Ultrasonic Distance Sensor with Arduino<\/span><\/a><span style=\"font-weight: 400;\">.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">Arduino Hookup <\/span><\/h3>\n<p><span style=\"font-weight: 400;\">The HC-SR04 has four pins. Two are used for power and ground, the other two for the transmit (Trigger) and receive (Echo).<\/span><\/p>\n<p><span style=\"font-weight: 400;\">To save on wiring you can run the sensor in \u201c1-pin mode\u201d, tying the Trigger and Echo pins together. Your code just needs to flip between sending and receiving, and you save some wiring.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5905\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Ultrasonic-Sensor-Hookup.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Ultrasonic Sensor Hookup\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Ultrasonic-Sensor-Hookup.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Ultrasonic-Sensor-Hookup.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">Otherwise, the wiring is fairly simple. In addition to the sensor wiring, we will use two of the Arduino\u2019s analog pins, A4 and A5, as I2C connections. A4 is the SDA connection while A5 is the SCL.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">Ultrasonic Sensor Test Sketch<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Before we work on our I2C sensor code I thought it would be a good idea to make sure that our four ultrasonic sensors were working correctly. So I wrote a test sketch to test everything out, without I2C.<\/span><\/p>\n<pre class=\"lang:default decode:true \" title=\"Ultrasonic 4 Sensors Test\">\/*\r\n  Ultrasonic 4 Sensors Test\r\n  ultrasonic-4sense-test.ino\r\n  Uses 4 x HC-SR04 Ultrasonic Range Finders\r\n  Uses NewPing Library\r\n\r\n  DroneBot Workshop 2019\r\n  <blockquote class=\"wp-embedded-content\" data-secret=\"GvgdacJEHk\"><a href=\"https:\/\/dronebotworkshop.com\/\">Welcome to the Workshop!<\/a><\/blockquote><iframe class=\"wp-embedded-content\" sandbox=\"allow-scripts\" security=\"restricted\" style=\"position: absolute; clip: rect(1px, 1px, 1px, 1px);\" title=\"&#8220;Welcome to the Workshop!&#8221; &#8212; DroneBot Workshop\" src=\"https:\/\/dronebotworkshop.com\/embed\/#?secret=AT0A8KQPr1#?secret=GvgdacJEHk\" data-secret=\"GvgdacJEHk\" width=\"600\" height=\"338\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\"><\/iframe>\r\n*\/\r\n\r\n\/\/ Include NewPing Library for HC-SR04 sensor\r\n#include &lt;NewPing.h&gt;\r\n\r\n\/\/ Hook up 4 HC-SR04 sensors in 1-pin mode\r\n\/\/ Sensor 0\r\n#define TRIGGER_PIN_0  8\r\n#define ECHO_PIN_0     8\r\n\r\n\/\/ Sensor 1\r\n#define TRIGGER_PIN_1  9\r\n#define ECHO_PIN_1     9\r\n\r\n\/\/ Sensor 2\r\n#define TRIGGER_PIN_2  10\r\n#define ECHO_PIN_2     10\r\n\r\n\/\/ Sensor 3\r\n#define TRIGGER_PIN_3  11\r\n#define ECHO_PIN_3     11\r\n\r\n\/\/ Maximum Distance is 400 cm\r\n#define MAX_DISTANCE 400\r\n\r\n\/\/ Create objects for ultrasonic sensors\r\nNewPing sensor0(TRIGGER_PIN_0, ECHO_PIN_0, MAX_DISTANCE);\r\nNewPing sensor1(TRIGGER_PIN_1, ECHO_PIN_1, MAX_DISTANCE);\r\nNewPing sensor2(TRIGGER_PIN_2, ECHO_PIN_2, MAX_DISTANCE);\r\nNewPing sensor3(TRIGGER_PIN_3, ECHO_PIN_3, MAX_DISTANCE);\r\n\r\n\/\/ Variables to represent distances\r\nfloat distance0, distance1, distance2, distance3;\r\n\r\nvoid setup() {  \r\n  \r\n   \/\/ Serial monitor for testing\r\n   Serial.begin (9600);\r\n   \r\n}\r\n\r\nvoid loop() {\r\n   \r\n  \/\/ Read sensors in CM \r\n  \/\/ Sensor 0\r\n  distance0 = sensor0.ping_cm();\r\n  delay(20);\r\n  \r\n  \/\/ Sensor 1\r\n  distance1 = sensor1.ping_cm();\r\n  delay(20);\r\n  \r\n  \/\/ Sensor 2\r\n  distance2 = sensor2.ping_cm();\r\n  delay(20);\r\n  \r\n  \/\/ Sensor 3\r\n  distance3 = sensor3.ping_cm();\r\n  delay(20);\r\n  \r\n   \r\n  \/\/ Send results to Serial Monitor\r\n  \/\/ Sensor 0\r\n  Serial.print(\"Distance 0 = \");\r\n  if (distance0 &gt;= 400 || distance0 &lt;= 2) {\r\n    Serial.println(\"Out of range\");\r\n  }\r\n  else {\r\n    Serial.print(distance0);\r\n    Serial.println(\" cm\");\r\n    delay(500);\r\n  }\r\n  \/\/ Sensor 1\r\n  Serial.print(\"Distance 1 = \");\r\n  if (distance1 &gt;= 400 || distance1 &lt;= 2) {\r\n    Serial.println(\"Out of range\");\r\n  }\r\n  else {\r\n    Serial.print(distance1);\r\n    Serial.println(\" cm\");\r\n    delay(500);\r\n  }\r\n  \/\/ Sensor 2\r\n  Serial.print(\"Distance 2 = \");\r\n  if (distance2 &gt;= 400 || distance2 &lt;= 2) {\r\n    Serial.println(\"Out of range\");\r\n  }\r\n  else {\r\n    Serial.print(distance2);\r\n    Serial.println(\" cm\");\r\n    delay(500);\r\n  }\r\n  \/\/ Sensor 3\r\n  Serial.print(\"Distance 3 = \");\r\n  if (distance3 &gt;= 400 || distance3 &lt;= 2) {\r\n    Serial.println(\"Out of range\");\r\n  }\r\n  else {\r\n    Serial.print(distance3);\r\n    Serial.println(\" cm\");\r\n    delay(500);\r\n  }\r\n  \r\n  \r\n  delay(500);\r\n}\r\n\r\n<\/pre>\n<p><span style=\"font-weight: 400;\">The sketch uses the <\/span><a href=\"https:\/\/bitbucket.org\/teckel12\/arduino-new-ping\/downloads\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">NewPing library<\/span><\/a><span style=\"font-weight: 400;\"> to simplify working with the HC-SR04 sensors. \u00a0You can use the Library Manager in your Arduino IDE to install this library.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">After including the library we define constants to represent the pins on the HC-SR04. Since we are using 1-pin mode the same pins are defined for both Trigger and Echo on each of the four sensors.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We also define a maximum distance. In this test, it will be 400 cm, which is near the maximum range of the ultrasonic sensors.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We use the NewPing library to create objects to represent each sensor and also define variables to hold the distance values we receive.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In the Setup, all that we need to do is to set up the serial monitor.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Now to the Loop. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">We read each sensor value in centimeters and place it into the sensors distance variable. Then we add a very short time delay, this is done to (hopefully) prevent the sensors from interfering with one another.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We then check to see if the value falls between 2 and 400. If it is out of this range we print an \u201cout of range\u201d message to the monitor. If it is within the range then we print the value.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">After a half-second time delay, we repeat the loop.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5906\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Ultrasonic-4-Sensor-Demo.jpg?resize=750%2C422&#038;ssl=1\" alt=\"Ultrasonic 4-Sensor Demo\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Ultrasonic-4-Sensor-Demo.jpg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Ultrasonic-4-Sensor-Demo.jpg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">Load the sketch to your Arduino and observe it in action. Try and orient your sensors so they are pointing in different directions if possible. I found the easiest way to test them was ti place an object very close to them, which will cause an \u201cout of range\u201d message if the object is less than 2 cm away.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Once you have determined that your sensors are working leave the breadboard wired up the way it is and proceed to the next sketches.<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">Remote I2C Sensor Array<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">Now that we have established that our sensors are working correctly it\u2019s time to convert them into an I2C device.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In order to do this, we will need a second Arduino to serve as the Master. Our existing Arduino is already hooked up correctly to act as the Slave, all that will be required is to change the code so that the results are sent over the I2C bus when a request is received from the Master.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">Hooking up the Master<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">The following diagram only shows the hookup between the Master and Slave Arduino&#8217;s. Remember to keep all of the existing wiring to the four HC-SR04 ultrasonic sensors intact!<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5895\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Arduino-Master-Slave-Hookup.jpeg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Arduino Master Slave Hookup\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Arduino-Master-Slave-Hookup.jpeg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Arduino-Master-Slave-Hookup.jpeg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">As you can see the hookup is very simple. I am showing two 10k resistors used as pull-ups for the SDA and SCL lines, but you may not even need to use them.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">On both Arduino&#8217;s the A4 line is also the SDA line, and A5 is SCL. Just connect both of those together, you&#8217;ll also need to connect the ground from each of the Arduino&#8217;s together.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">If you do use the two pull-up resistors then use the 5-volt supply from the Master Arduino to act as the reference voltage. Do not tie the 5-volt lines from each Arduino together!<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Once you have it all hooked up you\u2019ll need to load two sketches, one on the Slave and one on the Master.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">Arduino Sensor (Slave) Sketch<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Both the Slave and Master sketches borrow heavily from code written by Andreas Spiess <\/span><span style=\"font-weight: 400;\">and presented in <\/span><a href=\"https:\/\/www.youtube.com\/watch?v=aLkkAsrSibo\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">a video on his excellent YouTube channel<\/span><\/a><span style=\"font-weight: 400;\">. In his video, he used an ATtiny85 and three sensors.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The sketch used on the slave Arduino, the one with the four sensors, is shown here:<\/span><\/p>\n<pre class=\"lang:default decode:true\" title=\"I2C Ultrasonic 4 Sensors Slave\">\/*\r\n  I2C Ultrasonic 4 Sensors Slave\r\n  ultrasonic-4sense-i2c-slave.ino\r\n  Uses 4 x HC-SR04 Ultrasonic Range Finders\r\n  Uses I2C Interface\r\n  Uses NewPing Library\r\n\r\n  DroneBot Workshop 2019\r\n  <blockquote class=\"wp-embedded-content\" data-secret=\"GvgdacJEHk\"><a href=\"https:\/\/dronebotworkshop.com\/\">Welcome to the Workshop!<\/a><\/blockquote><iframe class=\"wp-embedded-content\" sandbox=\"allow-scripts\" security=\"restricted\" style=\"position: absolute; clip: rect(1px, 1px, 1px, 1px);\" title=\"&#8220;Welcome to the Workshop!&#8221; &#8212; DroneBot Workshop\" src=\"https:\/\/dronebotworkshop.com\/embed\/#?secret=AT0A8KQPr1#?secret=GvgdacJEHk\" data-secret=\"GvgdacJEHk\" width=\"600\" height=\"338\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\"><\/iframe>\r\n*\/\r\n\r\n\/\/ Include NewPing Library for HC-SR04 sensor\r\n#include &lt;NewPing.h&gt;\r\n\r\n\/\/ Include Arduino Wire library for I2C\r\n#include &lt;Wire.h&gt;\r\n\r\n\/\/ Define Slave I2C Address\r\n#define SLAVE_ADDR 9\r\n\r\n\/\/ Hook up 4 HC-SR04 sensors in 1-pin mode\r\n\/\/ Sensor 0\r\n#define TRIGGER_PIN_0  8\r\n#define ECHO_PIN_0     8\r\n\r\n\/\/ Sensor 1\r\n#define TRIGGER_PIN_1  9\r\n#define ECHO_PIN_1     9\r\n\r\n\/\/ Sensor 2\r\n#define TRIGGER_PIN_2  10\r\n#define ECHO_PIN_2     10\r\n\r\n\/\/ Sensor 3\r\n#define TRIGGER_PIN_3  11\r\n#define ECHO_PIN_3     11\r\n\r\n\/\/ Maximum Distance is 260 cm\r\n#define MAX_DISTANCE 260\r\n\r\n\/\/ Create objects for ultrasonic sensors\r\nNewPing sensor0(TRIGGER_PIN_0, ECHO_PIN_0, MAX_DISTANCE);\r\nNewPing sensor1(TRIGGER_PIN_1, ECHO_PIN_1, MAX_DISTANCE);\r\nNewPing sensor2(TRIGGER_PIN_2, ECHO_PIN_2, MAX_DISTANCE);\r\nNewPing sensor3(TRIGGER_PIN_3, ECHO_PIN_3, MAX_DISTANCE);\r\n\r\n\/\/ Define return data array, one element per sensor\r\nint distance[4];\r\n\r\n\/\/ Define counter to count bytes in response\r\nint bcount = 0;\r\n\r\nvoid setup() {\r\n\r\n  \/\/ Initialize I2C communications as Slave\r\n  Wire.begin(SLAVE_ADDR);\r\n \r\n   \/\/ Function to run when data requested from master\r\n  Wire.onRequest(requestEvent); \r\n  \r\n}\r\n\r\nvoid requestEvent() {\r\n \r\n  \/\/ Define a byte to hold data\r\n  byte bval;\r\n  \r\n  \/\/ Cycle through data\r\n  \/\/ First response is always 255 to mark beginning\r\n  switch (bcount) {\r\n    case 0:\r\n      bval = 255;\r\n      break;\r\n    case 1:\r\n      bval = distance[0];\r\n      break;\r\n    case 2:\r\n      bval = distance[1];\r\n      break;\r\n    case 3:\r\n      bval = distance[2];\r\n      break;\r\n    case 4:\r\n      bval = distance[3];\r\n      break;\r\n  }\r\n  \r\n  \/\/ Send response back to Master\r\n  Wire.write(bval);\r\n  \r\n  \/\/ Increment byte counter\r\n  bcount = bcount + 1;\r\n  if (bcount &gt; 4) bcount = 0;\r\n\r\n}\r\n\r\nvoid readDistance()\r\n{\r\n  distance[0] = sensor0.ping_cm();\r\n  if (distance[0] &gt; 254 ) {\r\n    distance[0] = 254;\r\n  }\r\n  delay(20);\r\n  \r\n  distance[1] = sensor1.ping_cm();\r\n  if (distance[1] &gt; 254 ) {\r\n    distance[1] = 254;\r\n  }\r\n  delay(20);\r\n  \r\n  distance[2] = sensor2.ping_cm();\r\n  if (distance[2] &gt; 254 ) {\r\n    distance[2] = 254;\r\n  }\r\n  delay(20);\r\n  \r\n  distance[3] = sensor3.ping_cm();\r\n  if (distance[3] &gt; 254 ) {\r\n    distance[3] = 254;\r\n  }\r\n  delay(20);\r\n  \r\n  \r\n}\r\n\r\nvoid loop()\r\n{\r\n  \/\/ Refresh readings every half second\r\n  readDistance();\r\n  delay(500);\r\n}\r\n\r\n\r\n\r\n\r\n\r\n\r\n<\/pre>\n<p><span style=\"font-weight: 400;\">You\u2018ll notice many similarities to the previous sketch, it uses the NewPing library and defines the pins and sensor objects in the same way as before. \u00a0It also uses the Arduino Wire library for I2C communications, this library is part of your Arduino IDE so you won&#8217;t need to install it.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We need to pick an address for our device, I chose 9 but you can pick anything really. \u00a0If you plan to implement a permanent version of this in one of your designs you should choose an address that won\u2019t conflict with any other I2C devices that you may be using.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The maximum distance has been reduced here, this is because we really are not planning to measure anything over 254 cem. This is because we want to fit our data into one byte.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Instead of using four separate variables to hold the four distance measurements we will put them into a 4-element array.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We are going to send the four distance variables one after another, preceded by a \u201cmarker byte\u201d, so we also need to define a counter to keep track of where we are in the response. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">In the Setup, we set the device up as a Slave by passing the address to the Wire library.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We also need to specify a function that we will call every time we get a request from the Master. \u00a0We will call the function <\/span><i><span style=\"font-weight: 400;\">requestEvent<\/span><\/i><span style=\"font-weight: 400;\">.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Before we examine the <\/span><i><span style=\"font-weight: 400;\">requestEvent<\/span><\/i><span style=\"font-weight: 400;\"> function it would be a good idea to look at another function, <\/span><i><span style=\"font-weight: 400;\">readDistance<\/span><\/i><span style=\"font-weight: 400;\">, as this is used in the requestEvent function.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The <\/span><i><span style=\"font-weight: 400;\">readDistance<\/span><\/i><span style=\"font-weight: 400;\"> function simply reads all four sensors and assigns their value to the elements in the array. \u00a0As with our stand-alone test, there is a small delay between readings to prevent interference between sensors.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In the Loop, we execute the <\/span><i><span style=\"font-weight: 400;\">readDistance<\/span><\/i><span style=\"font-weight: 400;\"> function every half-second. \u00a0This means that when the Master asks for a value it will already be there waiting for it.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Now back up to the <\/span><i><span style=\"font-weight: 400;\">requestEvent<\/span><\/i><span style=\"font-weight: 400;\"> function. \u00a0This is the function that is called when the Master requests data.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Our response will be sent to the Master over the I2C bus as a string of individual bytes. To allow the Master to distinguish which byte belongs to each sensor we will start the sequence with \u201cstart byte\u201d which always has a value of 255. This is why we need to limit our distance reading to 254 cm.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We use the counter we established earlier to cycle through the start byte and the four data values. For each of them, we use the <\/span><i><span style=\"font-weight: 400;\">Wire.write<\/span><\/i><span style=\"font-weight: 400;\"> method to send the data back to the Master over the I2C bus.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Now that you have seen the Slave sketch it\u2019s time to examine the code we will use on the Master.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">Arduino Master Sketch<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Here is the sketch used on the Master, it\u2019s actually simpler than the one we just looked at:<\/span><\/p>\n<pre class=\"lang:default decode:true \" title=\"I2C Ultrasonic 4 Sensors Master\">\/*\r\n  I2C Ultrasonic 4 Sensors Master\r\n  ultra-4sense-i2c-master.ino\r\n  Receives data from 4 remote Ultrasonic Sensors\r\n  Uses I2C Interface\r\n\r\n  DroneBot Workshop 2019\r\n  <blockquote class=\"wp-embedded-content\" data-secret=\"GvgdacJEHk\"><a href=\"https:\/\/dronebotworkshop.com\/\">Welcome to the Workshop!<\/a><\/blockquote><iframe class=\"wp-embedded-content\" sandbox=\"allow-scripts\" security=\"restricted\" style=\"position: absolute; clip: rect(1px, 1px, 1px, 1px);\" title=\"&#8220;Welcome to the Workshop!&#8221; &#8212; DroneBot Workshop\" src=\"https:\/\/dronebotworkshop.com\/embed\/#?secret=AT0A8KQPr1#?secret=GvgdacJEHk\" data-secret=\"GvgdacJEHk\" width=\"600\" height=\"338\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\"><\/iframe>\r\n*\/\r\n\r\n\/\/ Include Arduino Wire library for I2C\r\n#include &lt;Wire.h&gt;\r\n\r\n\/\/ Define Slave I2C Address\r\n#define SLAVE_ADDR 9\r\n\r\n\/\/ Define counter to count bytes in response\r\nint bcount;\r\n\r\n\/\/ Define array for return data\r\nbyte distance[4];\r\n\r\nvoid setup()\r\n{\r\n  Wire.begin();\r\n  Serial.begin(9600);\r\n}\r\n\r\nbyte readI2C(int address) {\r\n  \/\/ Define a variable to hold byte of data\r\n  byte bval ;\r\n  long entry = millis();\r\n  \/\/ Read one byte at a time\r\n  Wire.requestFrom(address, 1); \r\n  \/\/ Wait 100 ms for data to stabilize\r\n  while (Wire.available() == 0 &amp;&amp; (millis() - entry) &lt; 100)  Serial.print(\"Waiting\");\r\n  \/\/ Place data into byte\r\n  if  (millis() - entry &lt; 100) bval = Wire.read();\r\n  return bval;\r\n}\r\n\r\nvoid loop()\r\n{\r\n  \r\n  while (readI2C(SLAVE_ADDR) &lt; 255) {\r\n  \/\/ Until first byte has been received print a waiting message\r\n    Serial.print(\"Waiting\"); \r\n  }\r\n  for (bcount = 0; bcount &lt; 4; bcount++) {\r\n    distance[bcount] = readI2C(SLAVE_ADDR);\r\n  }\r\n  for (int i = 0; i &lt; 4; i++) {\r\n    Serial.print(distance[i]);\r\n    Serial.print(\"\\t\");\r\n  }\r\n  Serial.println();\r\n  delay(200);\r\n}\r\n\r\n\r\n<\/pre>\n<p><span style=\"font-weight: 400;\">Once again we will use the Arduino Wire Library to handle all of the I2C functions. \u00a0We will define an address for the Slave that we want to communicate with, in this case, I chose 9 to match the Slave sketch. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">As with the previous sketch, we will define a counter to count the incoming bytes and an array to hold the four distance values we receive.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In the Setup, we initialize the I2C bus. Note that we do not specify an address this time, this lets the Wire library know that we wish to operate as a Master.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We also set up the serial monitor so we can look at the incoming data.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Next, we create a function called <\/span><i><span style=\"font-weight: 400;\">readI2C<\/span><\/i><span style=\"font-weight: 400;\">. It has one parameter, the address of the device we want to read, and it outputs a byte of data.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The function makes use of the <\/span><a href=\"https:\/\/www.arduino.cc\/reference\/en\/language\/functions\/time\/millis\/\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Arduino <\/span><i><span style=\"font-weight: 400;\">millis<\/span><\/i><span style=\"font-weight: 400;\"> function<\/span><\/a><span style=\"font-weight: 400;\">, this is a function that outputs the number of milliseconds that have elapsed since the Arduino was powered up or reset. It will be used as a timer, to allow the data to settle.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">A <\/span><i><span style=\"font-weight: 400;\">Wire.request <\/span><\/i><span style=\"font-weight: 400;\">is used to request data from the slave. Remember, in this application, this will bring back one byte of data. \u00a0We return that byte as the function&#8217;s output.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In the Loop, we call the <\/span><i><span style=\"font-weight: 400;\">readI2C<\/span><\/i><span style=\"font-weight: 400;\"> function and read the data. We wait until it equals 255, as this is the start of our data sequence.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The next four reads are going to be the data from the four ultrasonic sensors. We put each value into our array.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Finally, we print the array values to the serial monitor. They are spaced with a tab character toi make it easier to read.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Load the sketch and keep the computer plugged into the Master Arduino so you can observe the readings on the serial monitor.<\/span><\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignnone size-full wp-image-5904\" src=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Sensor-Demo.jpg?resize=750%2C422&#038;ssl=1\" alt=\"I2C Sensor Demo\" width=\"750\" height=\"422\" srcset=\"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Sensor-Demo.jpg?w=768&amp;ssl=1 768w, https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/I2C-Sensor-Demo.jpg?resize=300%2C169&amp;ssl=1 300w\" sizes=\"(max-width: 750px) 100vw, 750px\" data-recalc-dims=\"1\" \/><\/p>\n<p><span style=\"font-weight: 400;\">You can power the Slave Arduino with a power supply or USB adapter. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">The test is pretty well the same test you performed for the stand-alone version, the difference is that the data is now being delivered over the I2C bus.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">There are a number of ways you can expand upon your new sensor. You could, of course, add more sensors. And you can rewrite the code to send all of the data at once, instead of as individual bytes.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">But this should be enough to get you started building your own I2C sensor devices.<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">Conclusion<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">As you can see it is not that difficult to build your own I2C sensors, especially now that you understand the protocol used on the I2C bus. \u00a0You can make them a lot smaller and more efficient by using an Arduino Pro Mini or ATmega328 chip in place of the Arduino Uno. And you can certainly add more functions to them than this simple experiment.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">The next time we look at I2C we will interface a Raspberry Pi and an Arduino. This is a bit tricky as the Raspberry Pi uses 3.3-volt logic and the Arduino uses 5-volt logic. But it is a common problem and there is more than one way to solve it.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Until then go out and sense something!<\/span><\/p>\n<p>&nbsp;<\/p>\n<div class=\"dbwspartsbox\">\n<h3>Parts List<\/h3>\n<p><em>Here are some components that you might need to complete the experiments in this article. Please note that some of these links may be affiliate links, and the DroneBot Workshop may receive a commission on your purchases. This does not increase the cost to you and is a method of supporting this ad-free website.<\/em><\/p>\n<p>COMING SOON!<\/p>\n<\/div>\n<p>&nbsp;<\/p>\n<div class=\"dbwsresourcebox\">\n<h3><span style=\"font-weight: 400;\">Resources<\/span><\/h3>\n<p><span style=\"font-weight: 400;\"><a href=\"https:\/\/s3.amazonaws.com\/download.dronebotworkshop.com\/I2C+Sensor+-+Dronebot+Workshop.zip\" target=\"_blank\" rel=\"noopener noreferrer\">Sketches used in this Article<\/a> &#8211; All of the sketches in a ZIP file, for your convenience.<\/span><\/p>\n<p><a href=\"https:\/\/www.youtube.com\/watch?v=aLkkAsrSibo\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Ultrasonic Distance Sensors Arduino Tutorial<\/span><\/a><span style=\"font-weight: 400;\"> &#8211; Excellent video by Andreas Spiess.<\/span><\/p>\n<p><a href=\"https:\/\/www.arduino.cc\/en\/reference\/wire\" target=\"_blank\" rel=\"noopener noreferrer\"><span style=\"font-weight: 400;\">Arduino Wire Library<\/span><\/a><span style=\"font-weight: 400;\"> &#8211; The built-in library for working with I2C.<\/span><\/p>\n<p>&nbsp;<\/p>\n<\/div>\n<p>&nbsp;<\/p>\n","protected":false},"excerpt":{"rendered":"<p>In our second look at using the I2C bus we will build our own I2C sensor, one that has four ultrasonic distance sensors.<\/p>\n<p>We&#8217;ll also learn about the protocol used by I2C communications<\/p>\n","protected":false},"author":1,"featured_media":5893,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9,90],"tags":[45,44],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Build-I2C-Sensor.jpeg?fit=768%2C432&ssl=1","jetpack_shortlink":"https:\/\/wp.me\/p74ClK-1xi","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts\/5908"}],"collection":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/comments?post=5908"}],"version-history":[{"count":2,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts\/5908\/revisions"}],"predecessor-version":[{"id":9937,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts\/5908\/revisions\/9937"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/media\/5893"}],"wp:attachment":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/media?parent=5908"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/categories?post=5908"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/tags?post=5908"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}