Bevezetés
I2C communications have become the de facto method of communications between microcontrollers, microcomputers and a variety of integrated circues and sensors. 1982 óta működik, eredetileg televíziós vevőkészülékekben való használatra fejlesztették ki.
bár sok I2C érzékelőt és kijelzőt használtunk a korábbi cikkekben, valójában nem vizsgáltuk meg, hogyan működik az I2C, és hogyan használható a mikrokontrollerek közötti kommunikációra.
ma fogjuk kijavítani, és többet megtudni I2C. azt is látni, hogyan lehet használni, hogy információt cserélnek két Arduinos és hogyan lehet használni, hogy lehetővé teszi az egyik Arduino, hogy ellenőrizzék egy másik.
Ez lesz az első a négy cikk I2C. a jövőben cikkek látni fogjuk, hogyan lehet építeni a saját I2C eszközök, hogyan kell interface egy Raspberry Pi és egy Arduino segítségével I2C és hogyan kell csinálni néhány fejlett I2C konfigurációk, beleértve a több mesterek egy I2C busz.
kezdjük!
I2C Communications
I2C egy soros protokoll használt kis sebességű 2-vezetékes interfész. Eredetileg Phillips fejlesztette ki 1982-ben, hogy a televíziós vevőkészülékeken belüli integrált áramkörök kommunikálhassanak egymással.
Az idők megváltoztak, Phillips most NXP, az I2C pedig kommunikációs szabvány lett, amelyet gyakorlatilag minden nagy félvezető gyártó támogat.a
I2C az “Inter-Integrated Circuit”rövidítése. Azt is nevezik ” IIC “vagy” I négyzet C”.
felhasználások és korlátozások
az I2C-t olyan mikrokontrollerekkel használják, mint az Arduino, valamint olyan mikroszámítógépekkel, mint a Raspberry Pi. Sok kijelző és érzékelő interfész a fogadó vezérlő segítségével I2C.
I2C nem több korlátozás azonban. Nem különösebben gyors, bár a legtöbb tervezett felhasználáshoz elég gyors.
az I2C csak rövid távolságokon használható, végül is eredetileg az integrált áramkörök közötti kommunikációra szánták ugyanazon a nyomtatott áramköri lapon. A megbízható átvitel maximális távolsága a sebesség növekedésével csökken, a leglassabb sebességnél (100 Kbaud vagy 100 KHz órajel) a maximális távolság körülbelül egy méter.
I2C sebesség
az eredeti I2C busz maximális sebessége 100 KHz volt. A leggyakoribb alkalmazások még mindig ezt a sebességet használják, mivel ez elég ahhoz, hogy adatokat továbbítsanak az érzékelőkről az egyszerű kijelzőkre.
I2C és van néhány nagyobb sebesség mód. Nem minden I2C eszköz támogatja ezeket a módokat:
- Gyors mód – ez maximális órajele 400 KHz.
- Hi-Speed Mode – a maximális órafrekvencia fo 3.4 MHz
- Ultra Fast Mode – maximális órafrekvencia 5 MHz
egy I2C buszon ez a mester határozza meg az órajel sebességét.
hogyan működik az I2C
egy I2C busznak két jele van, valamint egy hálózati és földi kapcsolat.
a két jelvonal a következő:
- SDA – ez a kétirányú adatsor.
- SCL – ez az órajel.
minden jelvezetékhez két húzóellenállás van csatlakoztatva,a buszt inaktív állapotban a tápfeszültségre húzza.
vegye figyelembe, hogy a tápfeszültség nem szabványos, lehet 3,3 vagy 5 volt. Ez is lehet egy alacsonyabb feszültség néhány nagy sebességű I2C megvalósítások.
Ez a tápfeszültség-különbség problémákat okozhat, ha különböző logikai szinteket használó I2C eszközöket csatlakoztat. Ezt egy jövőbeli cikkben fogjuk megvitatni, amikor megmutatom, hogyan kell a Raspberry Pi (3.3 voltos logika) egy Arduino Uno (5 voltos logika).
kétféle eszköz létezik, amelyek az I2C busz – mesterekhez és Rabszolgákhoz kapcsolódhatnak.
A Master eszköz vezérli a buszt, és ellátja az órajelt. Adatokat kér a rabszolgáktól külön-külön. A buszon egynél több mestereszköz lehet, de csak egy lehet az aktív mester egy adott pillanatban.
a mestereszközöknek nincs hozzá címük.
a Slave eszközöknek van címük, ennek a címnek egyedinek kell lennie a buszon. 7 bites címzési sémát használnak, így akár 128 Rabszolga is lehet egy I2C buszon. A való életben ezt a nagy eszközgyűjteményt soha nem használják, ritka, hogy több mint egy tucat I2C eszközt lát egy buszon.
egy újabb, 10 bites címzési sémát hajtottak végre, visszafelé kompatibilis a meglévő 7 bites címzési módszerrel.
kereskedelmi I2C eszközök kiosztott I2C címet NXP, akik fenntartják a busz SPECIFIKÁCIÓK. Bár az I2C 2006 óta nyílt forráskódú, Az NXP slave címének megszerzéséért díjat számítanak fel. Nem szükséges díj a mester eszközök, vagy olyan eszközök esetében, amelyek nem kereskedelmi gyártásra szolgálnak.
egyes I2C eszközök több címet kapnak, általában az alsó címbitekben lévő eltérések. Ezek az eszközök manuálisan konfigurálhatók különböző címekhez, lehetővé téve több azonos típusú eszköz használatát egyetlen I2C buszon.
Egyéb I2C származékok
vannak más buszok is, amelyek az I2C buszból származtak, és amelyek sok szempontból kompatibilisek az I2C-vel.
- TWI – a kétvezetékes interfész gyakorlatilag megegyezik az I2C busszal. Ez valójában az a busz, amelyet az Arduino használ, a TWI-t akkor fejlesztették ki, amikor az I2C busz nem volt nyílt forráskódú, az Atmel pedig nem akarta kockáztatni a kereskedelmi név megsértését. Az egyetlen nagy különbség a TWI és az I2C között az, hogy a TWI nem támogatja az “óra nyújtás”nevű fejlett technikát.
- az SMBus egy másik I2C egyenértékű busz, amelyet az Intel fejlesztett ki. Mint TWI támogatja a legtöbb I2C funkciók.
egy jövőbeli cikkben elmagyarázom, hogyan épül fel az I2C busz adatai. De most van néhány alapvető I2C információ, elég ahhoz, hogy kísérletezni kezdjünk.
Arduino Wire Library
Az Arduino beépített könyvtárral rendelkezik az I2C-vel való munkavégzéshez, a Wire Library-nek. Nagyon könnyű kommunikálni az I2C buszon, így az Arduino-t úgy konfigurálhatja, hogy mester vagy rabszolga legyen.
a vezetékes könyvtárnak számos hasznos funkciója van az I2C használatához.
- begin() – ez elindítja a könyvtárat, és az Arduino-t mesternek vagy rabszolgának állítja be.
- requestFrom() – ezt a funkciót a mester használja a szolga adatainak kérésére.
- beginTransmission() – ezt a funkciót a mester használja az adatok küldésére egy meghatározott rabszolgának.
- endtranszmisszió() – ezt a funkciót a mester használja a startranszmissziós funkcióval elindított átvitel befejezéséhez.
- write() – mind a master, mind a slave által használt adatok küldése az I2C buszon.
- elérhető() – mind a mester, mind a slave használja a bájtok számának meghatározására a kapott adatokban.
- read() – egy bájtnyi adatot olvas az I2C buszról.
- SetClock() – a mester által egy adott órajel-frekvencia beállításához használt.
- onReceive() – a slave által használt függvény megadására, amelyet akkor hívnak meg, amikor az adatok a mestertől érkeznek.
- onRequest() – a slave által használt függvény megadására, amelyet akkor hívnak, amikor a mester adatokat kért.
ezeket a funkciókat vázlatainkban fogjuk használni.
Arduino I2C kapcsolatok
az I2C SDA és SCL kapcsolatai különböznek az Arduino modellek között. A kísérletek, amelyeket meg fogok mutatni, két Arduino Unos használatával készültek, de az Arduino más modelljeit is használhatja, feltéve, hogy ennek megfelelően megváltoztatja a csapokat.
összeállítottam egy diagramot, hogy segítsen kitalálni. Ez magában foglalja néhány közös Arduino táblák, valamint néhány diszkrét chipek. A chipek I listájához tartozó pinoutok (ATTiny és ATmega328P) a DIP csomaggal vannak ellátva, nem pedig a felületre szerelhető csomagokkal.
| Arduino Board or Chip | SDA | SCL |
| Uno | A4 | A5 |
| Mega2560 | 20 | 21 |
| Nano | A4 | A5 |
| Pro Mini | A4 | A5 |
| Leonardo | 2 | 3 |
| Due (has two I2C) | 20 + SDA1 | 20 + SCL1 |
| ATTiny85 & ATTiny45 | 5 | 7 |
| ATmega328P | 27 | 28 |
egyes Arduino Uno klónok külön SDA és SCL csapokkal rendelkeznek, és a két analóg csap helyett használhatja őket. Belsőleg ugyanarra a helyre vannak csatlakoztatva.
vegye figyelembe, hogy az Arduino Due-nak valójában két I2C portja van.
is, vegye figyelembe, hogy van néhány helytelen összeköttetés diagramok az interneten a Pro Mini. Használja a két analóg csapot, az A4-et és az A5-öt, amint az a fenti táblázatban látható.
I2C között 2 Arduino a
Az első kísérlet fogunk hoo két Arduinos együtt, és az adatok cseréje közöttük. Az egyik Arduino lesz a mester, a másik pedig a rabszolga.
én használ két Arduino Unos, de lehet helyettesíteni más Arduino, ha nincs két Unos. Használja a kapcsolatok előző diagramját.
összejönni 2 Arduino a
itt van, hogyan csatlakoztattam a két Arduino Unos együtt:
Ez egy nagyon egyszerű összeköttetés, lényegében csak összekapcsolja a talajt és a két I2C csapot.
egy dolog, amit tudnia kell, hogy a diagramom nem mutatja A felhúzó ellenállások használatát, azt tapasztaltam, hogy minden úgy tűnt, hogy nélkülük megfelelően működik. Azonban érdemes felvenni őket, különösen akkor, ha hibákat vagy szakaszos működést tapasztal.
egyes húzó ellenállások összekapcsolásához néhány 10k ellenállást kell csatlakoztatni az SDA és az SCL vonalakhoz. Csatlakoztassa a másik végét az Arduino egyik 5 voltos kimenetéhez.
Master Demo Sketch
itt van a vázlat, amelyet az Arduino-n használnak, amelyet mesternek jelölt.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
/*
I2C Mester Demo
i2c-mester-demo.ino
Demonstrate use of I2C bus
Master sends character and gets reply from Slave
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Slave I2C Address
#define SLAVE_ADDR 9
// Define Slave answer size
#define ANSWERSIZE 5
void setup() {
// Initialize I2C communications as Master
Wire.begin();
// Setup serial monitor
Serial.begin (9600);
Soros.println(“I2C Master Demonstration”);
}
void loop() {
delay(50);
Serial.println (“adatok írása slave-nek”);
// írjon charatre-t a Slave
vezetékhez.beginTransmission(SLAVE_ADDR);
Wire.írja (0);
vezeték.endtranszmisszió ();
Soros.println (“adatok fogadása”);
// Read response from Slave
// Read back 5 characters
Wire.request from(SLAVE_ADDR, ANSWERSIZE);
/ / add karakterek string
String response=””;
míg (drót.elérhető ()) {
char b = vezeték.olvassa el ();
válasz += b;
}
// Print to Serial Monitor
Soros Monitor.println (válasz);
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
/*
I2C Slave Demo
i2c-slave-demo.ino
Demonstrate use of I2C bus
Slave receives character from Master and responds
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Rabszolga I2C Cím
#define SLAVE_ADDR 9
// Define Rabszolga válasz mérete
#define ANSWERSIZE 5
// Define string válasz Mester
String válasz = “Hello”;
void setup() {
// Inicializálni I2C kommunikációt, mint Rabszolga
Drót.begin(SLAVE_ADDR);
// függvény futtatásához, ha adatokat kért mester
vezeték.onRequest (requestEvent);
// függvény futtatásához, ha az adatokat a master
vezeték.onReceive(receiveEvent);
// Setup Serial Monitor
Serial.begin (9600);
Soros.println(“I2C Slave Demonstration”);
}
void receiveEvent () {
/ / /Read míg a kapott adatok
míg (0< vezeték.elérhető ()) {
byte x = vezeték.olvassa el();
}
// nyomtatás Soros monitorra
Soros.println(“Esemény fogadása”);
}
void requestEvent () {
/ / setup byte változó a megfelelő méretben
byte válasz;
// formázza a választ array
for (byte i=0; i<ANSWERSIZE;i++) {
válasz = (byte)válaszként.charAt(i);
}
// válasz küldése vissza a mesternek
vezeték.írja (válasz, sizeof (válasz));
/ / nyomtatás Soros monitorra
Soros.println(“Request event”);
}
void loop () {
/ / Time delay in loop
delay(50);
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
/*
I2C Master Control Demo
i2c-mester-demo-ellenőrzés.ino
Demonstrate use of I2C bus
Master sends potentimeter position data
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Slave I2C Address
#define SLAVE_ADDR 9
// Analog pin for potentiometer
int analogPin = 0;
// Integer to hold potentiometer value
int val = 0;
void setup () {
/ / inicializálja az I2C kommunikációt Master
vezetékként.kezdés ();
}
void loop () {
delay(50);
/ / olvassa pot érték
// Térkép tartomány 1-255 a flash ráta
val = map(analogRead(analogPin), 0, 1023, 255, 1);
// írjon egy charatre-t a Slave
vezetékhez.beginTransmission(SLAVE_ADDR);
Wire.írja (val);
vezeték.endtranszmisszió();
}
|
mint mindig, a vázlat elején fel kell vennünk a vezetékes könyvtárat. Meghatározunk egy állandót is, hogy megtartsuk a rabszolga címet.
mivel potenciométert használunk, meg kell határoznunk mind a csatlakoztatott pin-kódot, mind a változót, hogy megtartsuk az értékét.
mindössze annyit teszünk a beállításban, hogy inicializáljuk az I2C kapcsolatot mesterként.
a hurokban elolvastuk a potenciométer értékét, és 01-255 tartományra térképeztük fel. Ezt meg kell tennünk, mivel egy bájtnyi információt küldünk, és ezt a sok értéket csak egyetlen byte-ban tudjuk tartani.
vegye figyelembe, hogy megfordítjuk a számozási sorrendet az Arduino Térképfunkcióban, ez úgy történik, hogy a rendszer úgy viselkedik, ahogy elvárjuk – a potenciométer jobbra forgatása növeli a vaku sebességét. Mivel a” flash rate ” által meghatározott időeltolódás egy nagyobb számot küldött egyenlő lesz a hosszabb flash rate.
azt is vegye figyelembe, hogy nem küldjük el a 0 értéket, amely csak egy állapotban tartja a LED-et. Ehelyett a tartományunkat 1-re állítjuk.
most már csak az a kérdés, hogy elküldjük a bájtot a rabszolgának, és megismételjük a hurkot.
Remote Demo Receive Sketch
a slave oldalnak adatokat kell fogadnia a mestertől, és a LED villogásához használni.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
/*
I2C Rabszolga Ellenőrzési Demo
i2c-rabszolga-demo-ellenőrzés.ino
Demonstrate use of I2C bus
Receives potentimeter position data
Controls LED blink rate
DroneBot Workshop 2019
https://dronebotworkshop.com
*/
// Include Arduino Wire library for I2C
#include <Wire.h>
// Define Slave I2C Address
#define SLAVE_ADDR 9
// Define LED Pin
int LED = 13;
// Variable for received data
int rd;
// Variable for blink rate
int br;
void setup () {
pinMode (LED, kimenet);
/ inicializálja az I2C kommunikációt Slave
vezetékként.begin(SLAVE_ADDR);
// függvény futtatásához, ha kapott adatokat mester
vezeték.onReceive (receiveEvent);
/ Setup Serial Monitor
Serial.begin (9600);
Soros.println(“I2C Slave Demonstration”);
}
void receiveEvent () {
/ / /read one character from the I2C
rd = Wire.olvassa el();
// a bejövő adatok nyomtatási értéke
Soros.println (rd);
}
void loop() {
késleltetés(50);
// Kiszámításához pislogott érték
br = térkép(rd, 1, 255, 100, 2000);
digitalWrite(LED-es, NAGY);
késleltetés(br);
digitalWrite(LED, ALACSONY);
késleltetés(br);
}
|
kezdjük a szokásos felvétele a Vezeték könyvtár, valamint a meghatározó a slave cím. Meghatározunk egy pin-kódot a LED-hez is.
néhány további változó definiálva van, az egyik a fogadott adatokat tartja, míg a másik a villogási sebesség késleltetési értékét hordozza.
a beállításban a LED I / O pin-kódját állítjuk be kimenetként, majd inicializáljuk az I2C buszt. Ahogy használjuk a szolga címet a begin funkció a vezetékes könyvtár tudja, mi jár, mint egy rabszolga.
csak egy onrece függvényt kell definiálnunk, ellentétben az utolsó demóval, nem várunk semmilyen kérést a mestertől. A Soros monitorra is beállítunk és nyomtatunk, a monitor segítségével tekinthetjük meg a beérkező adatokat.
a receiveEvent függvény beolvassa a beérkező adatokat, majd hozzárendeli az I változóhoz. Az értéket a Soros monitorra is kinyomtatja.
végül a hurokban a bejövő adatokat a LED villogásához használjuk. Ehhez ismét a térkép funkciót használjuk, az 1-255 bejövő értékeit szélesebb tartományra változtatva. Kísérletezhet ennek a tartománynak a megváltoztatásával, hogy a LED gyorsabban vagy lassabban villogjon, ha akarja.
az utolsó néhány állítás lényegében az Arduino Blink vázlat álruhában! Az utolsó lépésben meghatározott ideig bekapcsoljuk és kikapcsoljuk a LED-et.
majd megismételjük a hurkot.
fut a távoli Demo
töltse be a kódot és a teljesítmény mind Arduino. használhatja a Soros monitor a slave Arduino, hogy megtekinthesse a bejövő adatokat.
a potenciométer elforgatásának most meg kell változtatnia a LED villogási sebességét a slave-en.
következtetés
Ez befejezi az I2C első részletes áttekintését.a következő részletben többet fogunk megtudni a kicserélt adatok szerkezetéről. Egy normál érzékelőt is veszünk, majd I2C érzékelővé alakítjuk.
Boldog kommunikáció!
források
vázlatok-Az ebben a cikkben használt összes I2C vázlat.
I2C információt, Tájékoztatást az I2C protokoll
