Looking at an example of I2C on Arduino

So, let’s talk about I2C! It needs just two main pins: SDA for data and SCL for the clock, usually running at a chill 100kHz.
While you might hear about four pins, really you only need those two for all your data swapping.
The awesome part? You can hook up to 127 devices on the same SDA and SCL pins without stepping on each other’s toes.
If you need to dodge address conflicts, you can tweak the address from 3a to 3b by adjusting certain pin settings on your components.
But if you’ve got a device that can’t change its address and it’s doubling up, it might be time to think about using SPI communication instead.
SPI uses a chip select pin to keep track of multiple devices, which can really save the day when I2C starts to falter.
And pro tip: always check the data sheet for address change options before switching up your communication methods!.

For this project, we’re diving into the Arduino Uno , where the SDA and SCL pins are pretty straightforward: you’ve got SDA hanging out on pin A4 and SCL on A5.
If you’re rolling with a Mega, you’ll find SDA on pin 20 and SCL on 21, while the Leonardo Duo keeps it similar.
We’re going to put this setup to the test with a sensor called PM2008 that’s pretty versatile—it can communicate via both UART and I2C.
Once we’ve got the sensor connected to the shield, the SDA and SCL will automatically sync up with A4 and A5 on the Uno, making everything super easy!.

So, if you’re looking to dive into I2C communication with Arduino, the first thing you’ll need is the Wire library—it’s typically included in the examples you find.
Start by running an I2C scanner to identify connections, since each I2C device has its own unique address, up to a max of 127.
If you spot some addresses, awesome! You can move on to communication.
But if nothing shows up, it might be time to troubleshoot your hardware.
Just double-check the communication voltage (it should be either 3.3V or 5V), make sure the SCL and SDA pins are hooked up right, and confirm that the ground connection is solid.
Also, don’t forget to check for those external pull-up resistors and the requirements noted in the datasheet..

Alright, let’s dive into how to retrieve I2C addresses! First off, if everything’s set up right, running the scanner should easily pull out the address for your component, which happens to be 0x28 for the PM2008.
To get started, just connect your Arduino to the PM2008 shield, upload your sketch, and fire up the serial monitor to see what’s happening.
The code kicks things off by initializing the Wire library to get talking, scanning addresses from 1 to 127, and keeping an eye out for any communication errors.
If you see an error value of 0, congrats! That means you’ve successfully communicated, and the I2C address is all yours.
If not, no worries; the scanner keeps chugging along until it checks all the addresses.
Happy scanning!.

I2C communication is pretty interesting and happens every 5 seconds.
First off, we kick things off with an I2C scanner, which checks if everything’s ready to roll—this is pretty standard whether you’re using Arduino, ST, or TI.
In the scenario we’re discussing, the Arduino plays the master role, managing I2C components and sensors, but it can switch gears to be a slave when it’s getting data from a Raspberry Pi.
For our purposes, we’re assuming the Arduino stays the master while verifying the PM2008 sensor.
When you choose Master Read, you’ll notice that most of the processes aren’t all that different.
Just a quick note, the Wire request command does have a couple of variances since it includes two main pieces: the I2C address and a byte length of 7 bytes..

So, let’s dive into I2C communication with Arduino! The process kicks off with a request that feels a lot like serial communication.
Once you see the ‘Wire available’ message pop up, you’ll enter this infinite loop to read and display one byte at a time.
In our example code, we grab 6 bytes from an I2C component that’s chilling at address 8, and then we output each byte one by one.
When it’s time to write, the setup is pretty similar, but you’ll use wire.beginTransmission to point out the address and wire.write to send over your text value—yep, sending a whole 6 bytes again! I2C is all about reading and sending a specific number of bytes between your Arduino and other components at their designated addresses, and we showcased this using the handy Wire library..