i2c Communications Part 1-Arduino Til Arduino

No comments

Introduksjon

I2C kommunikasjon har blitt de facto metode for kommunikasjon mellom mikrokontrollere, datamaskiner og en rekke integrerte kretser og sensorer. Det har eksistert siden 1982 og ble opprinnelig utviklet for bruk i tv-mottakere.Selv om vi har brukt mange i2c-sensorer og skjermer i tidligere artikler, har vi ikke faktisk sett på hvordan I2C fungerer og hvordan det kan brukes til å kommunisere mellom mikrokontrollere.

I Dag vil vi rette opp det og lære MER om I2C. Vi ser også hvordan det kan brukes til å utveksle informasjon mellom To Arduinos og hvordan Det kan brukes til å tillate En Arduino å kontrollere en annen.

I2c Del 1-Ved Hjelp Av 2 Arduinos

Dette vil være den første av fire artikler på I2C. i fremtidige artikler vil vi se hvordan vi kan bygge våre egne i2c enheter, hvordan grensesnitt En Raspberry Pi og En Arduino bruker I2C og hvordan du gjør noen avanserte I2c konfigurasjoner, inkludert bruk av flere mestere på EN I2C buss.

La oss komme i gang!

I2c Communications

I2C er en seriell protokoll som brukes på et lavhastighets 2-tråds grensesnitt. Det ble opprinnelig utviklet Av Phillips i 1982 for å tillate integrerte kretser i fjernsynsmottakere å kommunisere med hverandre.Tider har endret Seg, Phillips er NÅ NXP og I2C har blitt en kommunikasjonsstandard som støttes av nesten alle store halvlederprodusenter.

I2C er en forkortelse for «Inter-Integrert Krets». Det kalles også » IIC «Eller» i squared C».

Bruker Og Begrensninger

I2C brukes med mikrokontrollere som Arduino og med mikrodatamaskiner som Raspberry Pi. Mange skjermer og sensorer grensesnitt til sin vert kontrolleren ved HJELP av I2C.

I2C har flere begrensninger men. Det er ikke spesielt raskt, men for de fleste av de tiltenkte bruksområdene er det mye raskt nok. I2C kan bare brukes over korte avstander, det var jo opprinnelig ment å kommunisere mellom integrerte kretser på samme trykte kretskort. Den maksimale avstanden til pålitelig overføring reduseres etter hvert som hastigheten øker, ved den laveste hastigheten (100 Kbaud eller en klokkefrekvens på 100 KHz) er maksimal avstand omtrent en meter.

I2c Hastigheter

den opprinnelige i2c bussen hadde en maksimal hastighet på 100 KHz. De fleste vanlige applikasjoner bruker fortsatt denne hastigheten, da det er ganske tilstrekkelig for overføring av data fra sensorer og til enkle skjermer.

I2C og har noen høyere hastighetsmoduser. Ikke alle i2c-enheter støtter disse modusene:

  • Rask Modus-Dette har en maksimal klokkehastighet på 400 KHz.
  • Hi-Speed Mode-en maksimal klokkefrekvens fo 3.4 MHz
  • Ultra Rask Modus-Maksimal klokkefrekvens på 5 MHz

på en i2c buss er det mesteren som bestemmer klokkehastigheten.

Hvordan I2c Fungerer

En i2c buss har to signaler, sammen med en strøm og jordforbindelse.

I2c Bus Communications

de to signallinjene er som følger:

  • SDA – DETTE er toveis datalinjen.
  • SCL-dette er klokkesignalet.

det er to trekkmotstander festet til hver signallinje, de trekker bussen opp til forsyningsspenningen når den er inaktiv.

Merk at forsyningsspenningen ikke er standard, den kan enten være 3,3 eller 5 volt. Det kan også være en lavere spenning for noen høyhastighets i2c implementeringer.

denne forskjellen i forsyningsspenninger kan forårsake problemer når DU kobler til I2C-enheter som bruker forskjellige logikknivåer. Vi vil diskutere dette mer i en fremtidig artikkel når jeg viser deg hvordan du grensesnitt En Raspberry Pi (3.3 volt logikk) Med En Arduino Uno (5 volt logikk).

det finnes to typer enheter som kan kobles til i2c-bussen-Mestere og Slaver.

Hovedenheten styrer bussen og leverer klokkesignalet. Det ber om data fra slavene individuelt. Det kan være mer enn en hovedenhet på bussen, men bare en kan være den aktive mesteren til enhver tid.

hovedenhetene har ikke en adresse som er tilordnet dem.

Slave-enheter har en adresse, og denne adressen må være unik på bussen. De bruker en 7-bit adresseringsordning, så opptil 128 slaver kan være på en i2c-buss. I virkeligheten er denne store samlingen av enheter aldri brukt, det er sjelden å se over et dusin I2C-enheter på en buss.

en nyere 10-biters adressering er implementert, den er bakoverkompatibel med den eksisterende 7-biters adresseringsmetoden.Kommersielle i2c-enheter tildeles i2c-adresse av NXP, som opprettholder busspesifikasjonene. Selv OM I2C har vært åpen kildekode siden 2006, er DET et gebyr for å skaffe en slaveadresse fra NXP. Ingen gebyr kreves for master enheter, eller for enheter som ikke er ment for kommersiell produksjon.

Noen i2c-enheter er tildelt flere adresser, vanligvis avvik i de nedre adressebitene. Disse enhetene kan konfigureres manuelt for forskjellige adresser, slik at flere enheter av samme type kan brukes på en ENKELT i2c-buss.

Andre I2c-Derivater

det finnes andre busser som er avledet fra i2c-bussen, og som på mange måter er kompatible med I2C.

  • TWI-Twin Wire-Grensesnittet er praktisk talt identisk med I2C-bussen. DETTE er faktisk bussen Som Arduino bruker, TWI ble utviklet da i2c-bussen ikke var åpen kildekode, og Atmel ville ikke risikere et handelsnavn brudd. DEN eneste store forskjellen MELLOM TWI og I2C er AT TWI ikke støtter en avansert teknikk kalt «klokkestrekning».
  • SMBus er en annen i2c-ekvivalent buss, utviklet av Intel. SOM TWI støtter de fleste i2c funksjoner. I en fremtidig artikkel vil jeg forklare hvordan dataene på i2c-bussen er strukturert. Men nå har vi noen grunnleggende I2C-informasjon, nok til å begynne å eksperimentere.

    Arduino Wire Library

    Arduino har et innebygd bibliotek for å arbeide med I2c kalt Wire Library. Det gjør det veldig enkelt å kommunisere på i2c bussen, og det kan konfigurere Arduino å bli enten en mester eller en slave.

    Trådbiblioteket har flere nyttige funksjoner for å jobbe med I2C.

    • begin () – dette starter biblioteket og setter Opp arduino til å være enten mester eller slave.
    • requestFrom () – denne funksjonen brukes av mesteren til å be om data fra en slave.
    • beginTransmission () – denne funksjonen brukes av mesteren til å sende data til en spesifisert slave.
    • endTransmission () – denne funksjonen brukes av mesteren til å avslutte en overføring startet med beginTransmission-funksjonen.
    • write () – Brukes av både master og slave til å sende data på i2c-bussen.
    • tilgjengelig () – Brukes av både master og slave for å bestemme antall byte i dataene de mottar.
    • read () – Leser en byte med data fra i2c-bussen.
    • SetClock () – Brukes av mesteren til å angi en bestemt klokkefrekvens.
    • onReceive () – Brukes av slaven til å angi en funksjon som kalles når data mottas fra mesteren.
    • onRequest () – Brukes av slaven til å angi en funksjon som kalles når masteren har bedt om data.

    vi vil bruke noen av disse funksjonene i våre skisser.

    Arduino I2c Tilkoblinger

    SDA og SCL tilkoblinger for I2c er forskjellige Mellom Arduino modeller. Eksperimentene jeg skal vise deg ble gjort ved hjelp Av to Arduino Unos, men du kan bruke Andre modeller Av Arduino gir deg endre pinnene tilsvarende.

    jeg har satt sammen et diagram for å hjelpe deg med å få det funnet ut. Den inneholder noen vanlige Arduino-brett, samt noen av de diskrete sjetongene. Pinouts for chips i-listen (ATTiny og ATmega328P) er MED DIP-pakken,ikke overflatemonterte.

    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

    Noen Arduino Uno-kloner har separate sda-og SCL-pinner, og du kan bruke Dem i stedet for de to analoge pinnene hvis du ønsker det. De er internt koblet til samme sted.

    Merk At Arduino Due faktisk har to i2c-porter.

    vær også oppmerksom på at Det er noen feil hookup diagrammer på internett For Pro Mini. Bruk de to analoge pinnene, A4 og A5, som vist i tabellen ovenfor.

    I2c Mellom 2 Arduino ‘ s

    for vårt første eksperiment vil vi hoo To Arduinos sammen og utveksle data mellom dem. En Arduino vil være mesteren, den andre vil være slaven.jeg bruker to Arduino Unos, men du kan erstatte Andre Arduino hvis du ikke har to Unos. Bruk det forrige diagrammet for tilkoblingene.

    Hooking up 2 Arduino ‘ s

    Her er hvordan jeg koblet mine to Arduino Unos sammen:

    I2c Arduino Til Arduino

    Det er ganske enkel oppkobling, i hovedsak knytter du bare bakken og de TO I2C-pinnene sammen.En ting å være klar over er at diagrammet mitt ikke viser bruken av pull-up motstander, jeg fant ut at alt syntes å fungere riktig uten dem. Du vil imidlertid kanskje inkludere dem, spesielt hvis du opplever feil eller intermitterende drift.

    for å koble opp noen pull-up motstander attache et par 10k motstander TIL SDA og SCL linjer. Fest den andre enden til 5-volt utgang på En Av Arduino tallet.

    Master Demo Sketch

    Her er skissen som skal brukes På Arduino som du har utpekt som master.

    I2c Master Demo

    /*
    i2c master demo
    i2c-master 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();
    / /Oppsett seriell skjerm
    Seriell.begynn (9600);
    Seriell.println («I2c Master Demonstrasjon»);
    }
    void loop () {
    forsinkelse (50);
    Seriell.println («Skriv data til slave»);
    // Skriv en charatre Til Slaven
    Wire.startoverføring (SLAVE_ADDR);
    Ledning.skriv (0);
    Ledning.endTransmission ();
    Seriell.println («Motta data»);
    // Les svar fra Slave
    / / Les tilbake 5 tegn
    Wire.requestFrom (SLAVE_ADDR, ANSWERSIZE);
    / /Legg til tegn til streng
    String response=»»;
    mens (Ledning.tilgjengelig ()) {
    char b = Wire.les();
    svar + = b;
    }
    / / Skriv Ut Til Seriell Skjerm
    Seriell.println (response);
    }
    1
    3
    4
    5
    6 /div>

    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/div>

    50
    51
    52
    53

    som med alle I2c skisser, starter vi med Å inkludere Trådbiblioteket.

    neste definerer vi noen få konstanter som representerer i2c-adressen til slaven og antall byte data som vi forventer å hente fra den.

    i Oppsettet initialiserer VI i2c-kommunikasjonen som en mester. Vi vet at det er en mester da det ikke er noen adresseparameter i startfunksjonen. Vi setter også opp en seriell skjerm og skriver ut en tekstlinje til den.

    nå Til Løkken.

    Vi starter med en liten tidsforsinkelse, for det meste for å bremse ting ned nok slik at vi kan lese skjermen på seriell skjerm.

    Neste bruker vi beginTransmission-funksjonen til å sende data til slaven. I dette tilfellet er dataene vi sender bare et tall null. Vi avslutter med å sende med et anrop til sluttenoverføringsfunksjon.

    neste ber vi om noen data tilbake fra slaven ved hjelp av requestFrom-funksjonen.

    etter det formulerer vi en responsstreng ved å lese dataene, en byte om gangen, fra slaven.

    vi skriver ut detaljene om hva vi gjør og dataene vi mottar til seriell skjerm. Og så avslutter Vi Løkken og gjør det igjen.

    Slave Demo Sketch

    nå på skissen som brukes av slaven.

    1
    3
    4
    5
    6 /div>

    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/div>

    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>
    // Definer Slave I2c-Adresse
    #definer SLAVE_ADDR 9
    // Definer Slavesvarstørrelse
    #definer SVARSTØRRELSE 5
    // Definer streng med Svar På Master
    string answer = «Hello»;
    void setup() {
    // initialiser i2c-kommunikasjon som slave
    LEDNING.START (SLAVE_ADDR);
    / / Funksjon for å kjøre når data forespurt fra master
    Wire.onRequest (requestEvent);
    // Funksjon for å kjøre når data mottatt fra master
    Wire.onReceive (receiveEvent);
    / /Oppsett Seriell Skjerm
    Seriell.begynn (9600);
    Seriell.println(«I2c Slave Demonstrasjon»);
    }
    ugyldig receiveEvent() {
    // Lese mens data mottatt
    mens (0 < Ledning.tilgjengelig ()) {
    byte x = Ledning.les();
    }
    // Skriv Ut Til Seriell Skjerm
    Seriell.println («Motta hendelse»);
    }
    void requestEvent () {
    // Setup byte variabel i riktig størrelse
    ;
    / /Formater svaret som matrise
    for (byte i=0;i < ANSWERSIZE; i++) {
    svar = (byte) svar.charAt (i);
    }
    // Sende svar tilbake Til Master
    Wire.skriv (respons,sizeof (respons));
    // Skriv Ut Til Seriell Skjerm
    Seriell.println(«Forespørsel hendelse»);
    }
    void loop() {
    // tidsforsinkelse i loop
    forsinkelse(50);
    }

    Igjen starter vi med å inkludere trådbiblioteket. Som med forrige skisse definerer vi OGSÅ i2c-adressen for slaven, samt antall byte vi planlegger å sende tilbake til mesteren.

    neste definerer vi strengen som vi skal sende tilbake til mesteren, i dette tilfellet bare ordet»Hei». Hvis du bestemmer deg for å endre dette, må DU kontrollere AT DU justerer ANSWERSIZE-konstanten i begge skissene for å være riktig.

    I Oppsettet initialiserer vi forbindelsen til i2c-bussen med en startfunksjon. Legg merke til den forskjellige måten vi gjør dette på, da dette er en slave vi angir I2C-adressen vi skal bruke. Ved Å gjøre Dette Vet Trådbiblioteket at vi vil operere i slavemodus.

    nå må vi definere navnene på funksjonene som vi vil ringe når to hendelser oppstår-en dataforespørsel mottatt fra mesteren og data mottatt fra mesteren. Vi setter også opp og skriver ut til seriell skjerm.

    funksjonen receiveEvent kalles når vi mottar data fra mesteren. I denne funksjonen leser vi data mens dataene er tilgjengelige og tilordner det til en byte (husk at dataene vil bli mottatt en byte om gangen).

    requestEvent-funksjonen kalles når vi får en forespørsel om data fra master. Vi må sende vår streng » Hei » tilbake til mesteren. Da vi trenger å sende dataene en byte om gangen, deler vi tegnene I » Hei » i individuelle elementer i en matrise og sender dem en etter en.

    vi rapporterer all vår fremgang i begge funksjonene til seriell skjerm.

    Sløyfen i denne skissen legger bare til en tidsforsinkelse, som samsvarer med den som brukes i hovedskissen.

    Kjører Demo Skisser

    for å kjøre disse skissene må du kunne se Seriell skjerm på Hver Arduino. Hvis du har to datamaskiner med Arduino IDE installert, vil det gjøre det mye enklere.

    I2C Experiment 1

    På Microsoft Windows er det mulig å åpne opp to forekomster Av Arduino IDE. Hvis det er gjort, kan du vise begge serielle skjermer side ved side på samme skjerm.

    Alternativt kan du bruke en datamaskin og slå Opp Den Andre Arduino med egen strømforsyning. Du må bytte datamaskin og strøm mellom De To Arduino-ene. Ved å gjøre dette kan du overvåke begge skjermene en etter en.

    Arduino Remote Ved HJELP Av I2C

    i neste demonstrasjon vil vi koble et potensiometer til master Arduino og EN LEDET til slaven. Vi vil bruke potensiometeret til å kontrollere blinkhastigheten TIL LYSDIODEN.

    dette er en annen enkel demonstrasjon, du kan bygge på den for å skape noe mer praktisk.

    Remote Demo Hookup

    Her er hvordan dette eksperimentet er satt sammen.

    I2c Arduino Kontroll

    Det er i hovedsak den samme oppkobling som den forrige eksperiment, med tillegg av potensiometeret på master og LED på slave.

    Merk at LYSDIODEN på slaven er festet til pin 13. Som Arduino Uno har en innebygd LED på pin 13 kan du eliminere LED og dens slippe motstand hvis du ønsker det.

    bemerkninger om pull-up motstander gjelder også for denne oppkobling.

    Remote Demo Master Sketch

    skissen for mastersiden av dette eksperimentet er veldig enkelt, på noen måter ER I2C-siden enda enklere enn den som ble brukt i den første demonstrasjonen. Dette skyldes at vi bare sender data til slaven og ikke forventer å få noe tilbake.

    I2c Master med Potensiometer

    /*
    i2c-master-demo-kontroll.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 () {
    / / Initialiser I2C-kommunikasjon som Master
    Ledning.start();
    }
    void loop () {
    forsinkelse (50);
    / /Les pot verdi
    / /Kart til området 1-255 for flash rate
    val = kart(analogRead(analogPin), 0, 1023, 255, 1);
    / / Skriv en charatre Til Slaven
    Wire.startoverføring (SLAVE_ADDR);
    Ledning.Skriv (val);
    Ledning.endTransmission();
    1
    3
    4
    5
    6 /div>

    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

    som alltid må Vi inkludere Trådbiblioteket i begynnelsen av skissen. Vi vil også definere en konstant for å holde slaveadressen.

    Siden vi bruker et potensiometer, må vi definere både pinnen den er koblet til og en variabel for å holde verdien.

    Alt vi gjør i Oppsettet er å initialisere i2c-tilkoblingen som en mester.

    I Løkken leser vi potensiometerverdien og kartlegger den til et område på 01-255. Vi må gjøre det som vi sender en byte med informasjon og kan bare holde så mange verdier i en enkelt byte.

    Merk at vi reverserer nummereringssekvensen I Arduino-Kartfunksjonen, dette er gjort slik at systemet oppfører seg slik vi forventer det – å dreie potensiometeret til høyre øker blitshastigheten. Som «flash rate» er spesifisert av en tidsforsinkelse et større antall blir sendt vil likestille til en lengre flash rate.

    legg Også merke til at vi ikke sender verdien 0, som bare vil holde LYSDIODEN i en tilstand. Vi setter vårt utvalg til slutt på 1 i stedet.

    Nå handler det bare om å sende byten til slaven og gjenta Sløyfen igjen.

    Ekstern Demo Motta Skisse

    slavesiden må motta data fra mesteren og bruke DEN til å blinke LYSDIODEN.

    I2c Slave med LED

    /*
    i2c-slave-demo
    i2c-slave-demo-kontroll.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, UTGANG);
    / / Initialiser I2C-kommunikasjon som Slave
    Ledning.START (SLAVE_ADDR);
    / / Funksjon for å kjøre når data mottatt fra master
    Wire.onReceive (receiveEvent);
    / /Oppsett Seriell Skjerm
    Seriell.begynn (9600);
    Seriell.println («I2c Slave Demonstrasjon»);
    }
    ugyldig receiveEvent () {
    / / les ett tegn fra I2C
    Rd = Ledning.les();
    // Skriv ut verdien av innkommende data
    Seriell.println (rd);
    }
    void loop () {
    forsinkelse(50);
    / / Beregn blinkverdi
    br = kart(rd, 1, 255, 100, 2000);
    digitalWrite(LED, HØY);
    forsinkelse(br);
    forsinkelse(BR);
    }

    1
    3
    4
    5
    6/div>

    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/div>

    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60

    vi starter med den vanlige inkluderingen av trådbiblioteket, samt definerer slaveadressen. Vi definerer også en pin for LYSDIODEN.

    et par ekstra variabler er definert, en holder de mottatte dataene mens den andre bærer tidsforsinkelsesverdien for blinkfrekvensen.

    I Oppsettet setter vi i / O-pin for LED som en utgang og initialiserer i2c-bussen. Når vi bruker slaveadressen i begynn-funksjonen, vet Wire library at vi opptrer som en slave.

    Vi trenger bare å definere en onReceive funksjon, i motsetning til den siste demo vi ikke forventer noen forespørsler fra master. Vi setter også opp Og skriver Ut Til Seriell skjerm, vi bruker skjermen til å vise innkommende data.

    receiveEvent-funksjonen leser innkommende data og tilordner den til i-variabelen. Den skriver også verdien til seriell skjerm.

    Til Slutt bruker Vi innkommende data til å blinke LYSDIODEN. Igjen bruker Vi Kartfunksjonen for å oppnå dette, og endrer innkommende verdier på 1-255 til et bredere spekter. Du kan eksperimentere med å endre dette området for Å få LED-lampen til å blinke raskere eller langsommere hvis du ønsker det.

    de siste uttalelsene er i hovedsak Arduino Blink sketch in disguise! VI slår LYSDIODEN på og av i en tidsperiode vi bestemte oss for i det siste trinnet.

    og så gjentar vi sløyfen.

    Kjører Ekstern Demo

    Last inn koden og strøm Begge Arduino. Du kan bruke seriell skjerm På slave Arduino for å vise innkommende data.

    I2C Experiment 2

    Dreining av potensiometeret skal nå variere led-blinkhastigheten på slaven.

    Konklusjon

    dette avslutter vårt første detaljerte blikk på I2C. i neste avdrag vil vi lære mer om strukturen av dataene som utveksles. Vi vil også ta en vanlig sensor og slå den inn i EN i2c sensor.

    Glad kommunikasjon!

    Ressurser

    Skisser – Alle i2c-skissene som brukes i denne artikkelen.

    I2C informasjon – Informasjon om i2c protokollen

    I2c Kommunikasjon Del 1 – Arduino Til Arduino
    Sammendrag
    I2C kommunikasjon del 1 - ARDUINO til arduino
    ARTIKKELNAVN
    I2C kommunikasjon del 1 – arduino til arduino
    beskrivelse
    i denne første delen av en serie artikler om i2c vil du lære hva i2c er. Du vil også se hvordan Arduino Wire library gjør kommunikasjon over I2C veldig enkelt.
    Forfatter
    Utgiver Navn
    Utgiver Logo
    DroneBot Workshop

    / div >

    merket på: arduino tutorial

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert. Obligatoriske felt er merket med *