I2C tussen Arduinos
Misschien willen we soms de werklast van de ene Arduino met de andere delen. Of misschien willen we meer digitale of analoge pinnen. Inter-Integrated Circuit of I2C (uitgesproken als I-kwadraat C) is de beste oplossing.
I2C is een interessant protocol. Het wordt meestal gebruikt om te communiceren tussen componenten op moederborden in camera's en in elk ingebed elektronisch systeem.
Hier maken we een I2C-bus met twee Arduino's. We zullen één master Arduino programmeren om de andere slave Arduino de opdracht te geven om de ingebouwde LED een of twee keer te laten knipperen, afhankelijk van de ontvangen waarde.
Om dit op te bouwen hebben we de volgende "ingrediënten" nodig:
- 2 Arduinos
- Startkabels
Stap 1: hoe ze te verbinden
Volg deze stappen om twee Arduino UNO's te verbinden met I2C:
- Verbind de pinnen A4 en A5 op de ene Arduino met dezelfde pinnen op de andere.
De GND- lijn moet gemeenschappelijk zijn voor beide Arduino's. Verbind het met een jumper.
We hebben ook een schematische en een "breadboard" -implementatie, beide gemakkelijk te volgen. Gelukkig is het een simpele implementatie.
Denk eraan om nooit 5 V en 3, 3 V Arduinos met elkaar te verbinden. Dat zal het nietde 5V Arduino gekwetst, maar hij zal zeker zijn 3.3 V broer irriteren!
Stap 2: Code
De volgende code is opgesplitst in twee delen: de mastercode en de slavecode, die op twee verschillende Arduino's draaien. Laten we eerst eens kijken naar de hoofdcode :
// Voeg de vereiste Wire-bibliotheek toe voor I2C
#include int x = 0; ongeldige setup () {// Start de I2C-bus als Master Wire.begin (); } void loop () {Wire.beginTransmission (9); // verzenden naar apparaat # 9 Wire.write (x); // stuurt x Wire.endTransmission (); // stop met het verzenden van x ++; // Verhogen x if (x> 5) x = 0; // `reset x zodra het 6 vertraging (500) krijgt; }
En hier is de slaafcode die de tekens interpreteert die door de meester zijn verzonden:
// Voeg de vereiste Wire-bibliotheek toe voor I2C
#inc int int = 13; int x = 0; leegte setup () {// Definieer de LED pin als Output pinMode (LED, OUTPUT); // Start de I2C-bus als slave op adres 9 Wire.begin (9); // Koppel een functie om te activeren wanneer iets wordt ontvangen. Wire.onReceive (receEvent); } nietig ontvangenEvent (int bytes) {x = Wire.read (); // lees een teken uit de I2C} lege lus () {// Als ontvangen waarde 0 knipper-LED is voor 200 ms if (x == '0') {digitalWrite (LED, HIGH); vertraging (200); digitalWrite (LED, LOW); vertraging (200); } // Als de ontvangen waarde 3 knipperende LED is gedurende 400 ms if (x == '3') {digitalWrite (LED, HIGH); vertraging (400); digitalWrite (LED, LOW); vertraging (400); }}
Bijlagen
Stap 3: Code Breakdown
Laten we eerst naar de meester kijken . We moeten de vereiste Wire.h- bibliotheek opnemen:
#include
Vervolgens starten we in de setup-functie de I2C-bus met de functie Wire.begin () . Als er geen argument wordt gegeven in de functie, start Arduino als een master.
Ten slotte sturen we een teken x, dat tussen 0 en 5 ligt. We gebruiken de volgende functies tot
begin een verzending naar het apparaat met het adres 9, schrijf het teken en stop de verzending:
Wire.beginTransmission (9); // verzenden naar apparaat # 9 Wire.write (x); // stuurt x Wire.endTransmission (); // stop met verzenden
Laten we nu de slaaf Arduino-code verkennen. We nemen hier ook de Wire.h- bibliotheek op, maar nu starten we de I2C-bus met Wire.begin (9) . Het nummer in het argument is het adres dat we voor de Arduino willen gebruiken. Alle apparaten met adres 9 ontvangen de verzending.
Nu moeten we op de een of andere manier reageren wanneer we een I2C-transmissie ontvangen. De volgende functie voegt een triggerfunctie toe wanneer een teken wordt ontvangen. Beter gezegd, wanneer de Arduino een personage op I2C ontvangt, zal het de functie uitvoeren waarvan we zeggen dat het moet worden uitgevoerd:
Wire.onReceive (receEvent);
En dit is de functie. Hier slaan we eenvoudig de waarde van het ontvangen karakter op:
nietig ontvangenEvent (int bytes) {x = Wire.read (); } In loop () interpreteren we dat teken eenvoudig om de ingebouwde LED met verschillende snelheden te laten knipperen, afhankelijk van het ontvangen teken.
Stap 4: Meer over I2C
Om de theorie kort door te nemen, heeft I2C twee digitale lijnen nodig: Serial Data Line ( SDA ) om gegevens over te dragen en Serial Clock Line ( SCL ) om de klok te houden. Elke I2C-verbinding kan één master en meerdere slaves hebben. Een meester kan naar slaven schrijven en de slaven vragen om gegevens te geven, maar geen enkele slaaf kan rechtstreeks naar de meester of naar een andere slaaf schrijven. Elke slaaf heeft een uniek adres op de bus en de meester moet de adressen weten van elke slaaf die hij wil benaderen.
Elke I2C-bus ondersteunt maximaal 112 apparaten . Alle apparaten moeten GND delen. De snelheid is ongeveer 100 kb / s - niet erg snel, maar nog steeds respectabel en redelijk bruikbaar. Het is mogelijk om meer dan één master in een bus te hebben, maar het is echt ingewikkeld en wordt over het algemeen vermeden.
Veel sensoren gebruiken I2C om te communiceren, meestal traagheidsmeeteenheden, barometers,
temperatuursensoren en sommige Sonars. Onthoud dat I2C niet is ontworpen voor lange kabellengtes . Afhankelijk van het gebruikte kabeltype kan 2 meter al problemen veroorzaken.
I2C is een ingewikkeld transmissieprotocol, maar het is erg handig. Alle Arduino's implementeren het, met een paar verschillen in pin-toewijzingen:
Board I2C pinnen
Uno, Pro Mini A4 (SDA), A5 (SCL)
Mega, Due 20 (SDA), 21 (SCL)
Leonardo, Yun 2 (SDA), 3 (SCL)
Stap 5: meer apparaten aansluiten
Als we meer dan twee apparaten op een I2C-bus moeten aansluiten, hoeven we alleen maar alle SDA- en SCL-lijnen met elkaar te verbinden. We hebben het adres nodig van elke slaaf die door de meester Arduino moet worden aangesproken.
Hier is een video van een persoonlijke implementatie met 1 master en 3 slaves.
Meer onderwerpen over Arduino-communicatie zoals Wireless Serial, SD-kaarten of Ethernet zijn te vinden in mijn Arduino Development Cookbook dat hier beschikbaar is. : D
