Home-theater-designers
Mentre un singolo Arduino può svolgere molte attività, alcuni progetti potrebbero richiedere l'uso di più di una scheda per gestire funzionalità diverse. Quindi, per consentire il trasferimento dei dati tra i due microcontrollori, è necessario impostare un protocollo di comunicazione come CAN, SPI, I2C o UART.
In questa guida tratteremo le basi del funzionamento di I2C, le connessioni hardware e l'implementazione del software necessarie per configurare due schede Arduino come dispositivi I2C master e slave.
MAKEUSEOF VIDEO DEL GIORNO SCORRI PER CONTINUARE CON I CONTENUTI
Cos'è l'I2C?
Inter-Integrated Circuit (I2C) è un protocollo di comunicazione ampiamente utilizzato nei sistemi embedded e nei microcontrollori per consentire il trasferimento di dati tra dispositivi elettronici. A differenza di SPI (Serial Peripheral Interface), I2C consente di collegare più di un dispositivo master a un bus con uno o più dispositivi slave. È stato utilizzato per la prima volta da Philips ed è noto anche come protocollo di comunicazione Two Wire Interface (TWI).
Come funziona la comunicazione I2C?
I2C utilizza due linee bidirezionali: Serial Data (SDA) e Serial Clock (SCL) per trasferire i dati e sincronizzare la comunicazione tra i dispositivi. Ogni dispositivo connesso al bus I2C ha un indirizzo univoco che lo identifica durante la comunicazione. Il protocollo I2C consente a più dispositivi di condividere lo stesso bus e ogni dispositivo può fungere da master o da slave.
La comunicazione viene avviata dal dispositivo master e l'indirizzamento errato dei dispositivi slave può causare errori nel trasferimento. Consulta la nostra guida approfondita su come funzionano le comunicazioni seriali UART, SPI e I2C per darti un po' di contesto.
Uno dei principali vantaggi della comunicazione I2C degno di nota è la flessibilità che offre quando si tratta di gestione dell'alimentazione. I dispositivi che operano a diversi livelli di tensione possono comunque comunicare in modo efficace con l'aiuto di variatori di tensione. Ciò significa che i dispositivi che funzionano a 3,3 V necessitano di variatori di tensione per connettersi a un bus I2C a 5 V.
La biblioteca del filo
La libreria Wire è una libreria Arduino integrata che fornisce funzioni per comunicare su I2C. Utilizza due pin, SDA e SCL, sulla scheda Arduino per la comunicazione I2C.
Pin I2C su Arduino Uno:
Pin Arduino Nano I2C:
Per utilizzare la libreria, è necessario includere il file Filo.h file di intestazione all'inizio del tuo schizzo Arduino.
#include <Wire.h>
La libreria Wire fornisce funzioni per avviare la comunicazione con un dispositivo I2C, inviare dati e ricevere dati. Alcune funzioni importanti che dovresti conoscere includono:
Windows non è in grado di completare la formattazione della scheda SD
- Wire.begin() : utilizzato per unire il bus I2C e avviare la comunicazione.
- Wire.beginTransmission() : utilizzato per specificare l'indirizzo dello slave e iniziare una trasmissione.
- Wire.write() : utilizzato per inviare dati al dispositivo I2C.
- Wire.endTransmission() : utilizzato per terminare la trasmissione e verificare la presenza di errori.
- Wire.requestFrom() : utilizzato per richiedere dati al dispositivo I2C.
- Wire.disponibile() : utilizzato per verificare se i dati sono disponibili per la lettura dal dispositivo I2C.
- filo.read() : utilizzato per leggere i dati dal dispositivo I2C.
Usa il Wire.beginTransmission() funzione per impostare l'indirizzo del sensore, che viene inserito come argomento. Ad esempio, se l'indirizzo del sensore è 0x68 , useresti:
Wire.beginTransmission(0x68);
Configurazione dell'hardware Arduino I2C
Per connettere due schede Arduino utilizzando I2C, avrai bisogno dei seguenti componenti hardware:
- Due schede Arduino (master e slave)
- Tagliere
- Fili di ponticello
- Due resistori pull-up da 4,7kΩ
Collega il SDA E SCL pin di entrambe le schede Arduino su una breadboard. Collegare le resistenze di pull-up tra i SDA E SCL perni e il 5V power rail sulla breadboard. Infine, collega le due breadboard usando i ponticelli.
Circuito ArduinoUno
Circuito Nano Arduino
Configurazione delle schede Arduino come dispositivi master e slave I2C
Usa il Wire.requestFrom() funzione per specificare l'indirizzo del dispositivo slave con cui vogliamo comunicare. Quindi usa il filo.read() funzione per ottenere dati dal dispositivo slave.
Codice dispositivo principale:
#include <Wire.h>
void setup() {
Wire.begin(); // join i2c bus
Serial.begin(9600); // start serial for output
}
void receiveData() {
int address = 8;
int bytesToRead = 6;
Wire.requestFrom(address, bytesToRead);
while (Wire.available()) {
char data = Wire.read();
Serial.print(data);
}
delay(500);
}
void loop() {
receiveData();
}
IL Wire.onReceive() La funzione viene utilizzata per specificare cosa fare quando lo slave riceve i dati dal dispositivo master. Nel codice sopra, il Wire.disponibile() la funzione controlla se i dati sono disponibili e il filo.read() funzione legge i dati inviati dal dispositivo master.
Codice dispositivo slave:
#include <Wire.h>
void setup() {
Wire.begin(8); // join the I2C bus with address 8
Wire.onReceive(receiveEvent); // call receiveEvent when data is received
}
void loop() {
delay(100);
}
void receiveEvent(int bytes) {
Wire.write("hello "); // respond with message of 6 bytes as expected by master
}
Invio e ricezione di dati tramite I2C
In questo esempio leggiamo la temperatura da un sensore di temperatura DHT11 interfacciato con lo slave Arduino e stampiamola sul monitor seriale del master Arduino.
Modifichiamo il codice che abbiamo scritto in precedenza per includere la misurazione della temperatura che poi invieremo alla scheda master tramite il bus I2C. La scheda master può quindi leggere il valore che abbiamo inviato, quindi visualizzarlo sul monitor seriale.
Codice dispositivo principale:
#include <Wire.h>
void setup() {
Wire.begin();
Serial.begin(9600);
Serial.println("Master Initialized!");
}
void loop() {
Wire.requestFrom(8, 1); // Request temperature data from slave
if (Wire.available()) {
byte temperature = Wire.read(); // Read temperature data from slave
Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");
}
delay(2000); // Wait for 2 seconds before requesting temperature again
}
Codice dispositivo slave:
#include <Wire.h>
#include <DHT.h>
#define DHTPIN 4 // Pin connected to DHT sensor
#define DHTTYPE DHT11 // DHT sensor type
DHT dht(DHTPIN, DHTTYPE);
byte temperature;
void setup() {
Wire.begin(8); // Slave address is 8
Wire.onRequest(requestEvent);
dht.begin();
}
void loop() {
delay(2000); // Wait for 2 seconds for DHT to stabilize
temperature = dht.readTemperature(); // Read temperature from DHT sensor
}
void requestEvent() {
Wire.write(temperature); // Send temperature data to master
}
Puoi personalizzare questo codice per adattarlo a qualsiasi sensore tu possa avere nel tuo progetto, o persino visualizzare i valori del sensore su un modulo display per crea il tuo termometro e misuratore di umidità per la tua stanza .
Indirizzamento slave con I2C su Arduino
Per leggere i valori dai componenti aggiunti a un bus I2C in un progetto di questo tipo, è importante includere l'indirizzo slave corretto durante la codifica. Fortunatamente, Arduino offre una libreria di scanner che semplifica il processo di identificazione degli indirizzi degli slave, eliminando la necessità di setacciare lunghi fogli dati dei sensori e documentazione online confusa.
Utilizzare il seguente codice per identificare l'indirizzo di qualsiasi dispositivo slave presente sul bus I2C.
#include <Wire.h> // Include the Wire library for I2C communication
void setup() {
Wire.begin(); // Initialize the I2C communication
Serial.begin(9600); // Initialize the serial communication with a baud rate of 9600
while (!Serial); // Wait for the serial connection to establish
Serial.println("\nI2C Scanner"); // Print a message indicating the start of I2C scanning
}
void loop() {
byte error, address; // Declare variables to store errors and device addresses
int nDevices; // Declare a variable to store the number of devices found
Serial.println("Scanning..."); // Print a message indicating the start of I2C scanning
nDevices = 0; // Set the number of devices found to 0
for (address = 1; address < 127; address++) { // Iterate over all possible I2C addresses
Wire.beginTransmission(address); // Start a transmission to the current address
error = Wire.endTransmission(); // End the transmission and store any errors
if (error == 0) { // If no errors were found
Serial.print("I2C device found at address 0x"); // Print a message indicating a device was found
if (address < 16) Serial.print("0"); // If the address is less than 16, add a leading 0 for formatting purposes
Serial.print(address, HEX); // Print the address in hexadecimal format
Serial.println(" !"); // Print a message indicating a device was found
nDevices++; // Increment the number of devices found
}
else if (error == 4) { // If an error was found
Serial.print("Unknown error at address 0x"); // Print a message indicating an error was found
if (address < 16) Serial.print("0"); // If the address is less than 16, add a leading 0 for formatting purposes
Serial.println(address, HEX); // Print the address in hexadecimal format
}
}
if (nDevices == 0) { // If no devices were found
Serial.println("No I2C devices found\n"); // Print a message indicating no devices were found
}
else { // If devices were found
Serial.println("done\n"); // Print a message indicating the end of I2C scanning
}
delay(5000); // Delay for 5 seconds before starting the next scan
}
Espandi il tuo progetto oggi
L'interfacciamento di due schede Arduino utilizzando il protocollo di comunicazione I2C offre un modo flessibile ed efficiente per eseguire attività complesse che non possono essere gestite da una singola scheda. Con l'aiuto della libreria Wire, la comunicazione tra le due schede tramite I2C è semplificata, consentendoti di aggiungere più componenti al tuo progetto.